import 'dart:async';

import 'package:dio/dio.dart';
import 'package:shared_preferences/shared_preferences.dart';

int _agentInt(dynamic value) {
  if (value is int) return value;
  return int.tryParse(value?.toString() ?? '') ?? 0;
}

class AgentCredentials {
  const AgentCredentials({
    required this.uid,
    required this.sellerId,
    required this.loginToken,
    required this.deviceName,
  });

  final int uid;
  final int sellerId;
  final String loginToken;
  final String deviceName;

  Map<String, dynamic> toJson() => <String, dynamic>{
        'uid': uid,
        'seller_id': sellerId,
        'login_token': loginToken,
        'device_name': deviceName,
      };
}

class AgentApiException implements Exception {
  const AgentApiException(this.statusCode, this.message);

  final int statusCode;
  final String message;

  @override
  String toString() => 'AgentApiException($statusCode, $message)';
}

class AgentUser {
  const AgentUser({
    required this.userType,
    required this.name,
    required this.externalUserId,
    required this.merchantId,
    required this.merchantCode,
    required this.externalRoleName,
  });

  final String userType;
  final String name;
  final int externalUserId;
  final int merchantId;
  final String merchantCode;
  final String externalRoleName;

  factory AgentUser.fromJson(Map<String, dynamic> json) => AgentUser(
        userType: json['user_type']?.toString() ?? '',
        name: json['name']?.toString() ?? '',
        externalUserId: _agentInt(json['external_user_id']),
        merchantId: _agentInt(json['merchant_id']),
        merchantCode: json['merchant_code']?.toString() ?? '',
        externalRoleName: json['external_role_name']?.toString() ?? '',
      );
}

class AgentLoginData {
  const AgentLoginData({
    required this.accessToken,
    required this.tokenType,
    required this.expiresAt,
    required this.user,
  });

  final String accessToken;
  final String tokenType;
  final DateTime? expiresAt;
  final AgentUser user;

  factory AgentLoginData.fromJson(Map<String, dynamic> json) {
    final Map<String, dynamic> data = Map<String, dynamic>.from(
        json['data'] as Map? ?? const <String, dynamic>{});
    final String accessToken = data['access_token']?.toString() ?? '';
    if (accessToken.isEmpty) {
      throw const AgentApiException(0, '兑换 Agent Token 失败');
    }
    return AgentLoginData(
      accessToken: accessToken,
      tokenType: data['token_type']?.toString() ?? 'Bearer',
      expiresAt: DateTime.tryParse(data['expires_at']?.toString() ?? ''),
      user: AgentUser.fromJson(
        Map<String, dynamic>.from(
            data['user'] as Map? ?? const <String, dynamic>{}),
      ),
    );
  }
}

class AgentConversation {
  const AgentConversation({required this.id});

  final String id;

  factory AgentConversation.fromJson(Map<String, dynamic> json) {
    final Map<String, dynamic> data = Map<String, dynamic>.from(
        json['data'] as Map? ?? const <String, dynamic>{});
    final String id = data['id']?.toString() ?? '';
    if (id.isEmpty) {
      throw const AgentApiException(0, '创建会话失败');
    }
    return AgentConversation(id: id);
  }
}

class AgentMessageData {
  const AgentMessageData({
    required this.id,
    required this.role,
    required this.content,
    required this.status,
    required this.inputType,
    required this.snapshotIds,
  });

  final String id;
  final String role;
  final String content;
  final String status;
  final String inputType;
  final List<String> snapshotIds;

  factory AgentMessageData.fromJson(Map<String, dynamic> json) {
    final Map<String, dynamic> data = Map<String, dynamic>.from(
        json['data'] as Map? ?? const <String, dynamic>{});
    final List<dynamic> snapshots = data['snapshot_ids'] is List
        ? data['snapshot_ids'] as List<dynamic>
        : const <dynamic>[];
    return AgentMessageData(
      id: data['id']?.toString() ?? '',
      role: data['role']?.toString() ?? 'assistant',
      content: data['content']?.toString() ?? '',
      status: data['status']?.toString() ?? '',
      inputType: data['input_type']?.toString() ?? 'text',
      snapshotIds: snapshots.whereType<String>().toList(),
    );
  }
}

/// Agent 商家助手接口客户端。
///
/// 页面只依赖这个客户端访问 Agent 服务；调用方传入 App 当前登录票据，
/// 由本客户端兑换并缓存短期 access_token，自动在 401 时重新兑换并重试一次。
class AgentApiClient {
  AgentApiClient._();

  static final AgentApiClient instance = AgentApiClient._();

  static const String baseUrl = 'https://agent.colorcun.com';
  static const String _tokenKey = 'agent_access_token';
  static const String _expiresKey = 'agent_token_expires_at';
  static const String _uidKey = 'agent_bound_uid';
  static const String _sellerKey = 'agent_bound_seller_id';

  final Dio _dio = Dio(
    BaseOptions(
      baseUrl: baseUrl,
      connectTimeout: const Duration(seconds: 15),
      sendTimeout: const Duration(seconds: 30),
      receiveTimeout: const Duration(seconds: 130),
      responseType: ResponseType.json,
    ),
  );

  String? _accessToken;
  DateTime? _expiresAt;
  int? _boundUid;
  int? _boundSellerId;
  AgentCredentials? _credentials;

  bool get _tokenUsable {
    final String? token = _accessToken;
    final DateTime? expiresAt = _expiresAt;
    if (token == null || token.isEmpty) return false;
    if (expiresAt == null) return false;
    return expiresAt
        .subtract(const Duration(seconds: 60))
        .isAfter(DateTime.now());
  }

  Future<void> prepare(AgentCredentials credentials) async {
    _credentials = credentials;
    await _loadToken();
    if (!_tokenUsable ||
        _boundUid != credentials.uid ||
        _boundSellerId != credentials.sellerId) {
      await login(credentials);
    }
  }

  Future<AgentLoginData> login(AgentCredentials credentials) async {
    final Map<String, dynamic> response = await _request(
      'POST',
      '/api/v1/auth/merchant/login',
      data: credentials.toJson(),
      auth: false,
    );
    final AgentLoginData result = AgentLoginData.fromJson(response);
    _accessToken = result.accessToken;
    _expiresAt = result.expiresAt;
    _boundUid = result.user.externalUserId;
    _boundSellerId = result.user.merchantId;
    _credentials = credentials;
    await _saveToken(result);
    return result;
  }

  Future<AgentUser> me() async {
    final Map<String, dynamic> response =
        await _authorized('GET', '/api/v1/me');
    final Map<String, dynamic> data = Map<String, dynamic>.from(
        response['data'] as Map? ?? const <String, dynamic>{});
    return AgentUser.fromJson(data);
  }

  Future<AgentConversation> createConversation(
      {CancelToken? cancelToken}) async {
    final Map<String, dynamic> response = await _authorized(
      'POST',
      '/api/v1/conversations',
      data: const <String, dynamic>{},
      cancelToken: cancelToken,
    );
    return AgentConversation.fromJson(response);
  }

  Future<AgentMessageData> sendMessage({
    required String conversationId,
    required String content,
    required String inputType,
    required String clientMessageId,
    CancelToken? cancelToken,
  }) async {
    final Map<String, dynamic> response = await _authorized(
      'POST',
      '/api/v1/conversations/$conversationId/messages',
      data: <String, dynamic>{
        'content': content,
        'input_type': inputType,
        'client_message_id': clientMessageId,
      },
      cancelToken: cancelToken,
    );
    return AgentMessageData.fromJson(response);
  }

  Future<String> transcribeAudio({
    required String filePath,
    required String fileName,
    required String mimeType,
    CancelToken? cancelToken,
  }) async {
    final List<String> parts = mimeType.split('/');
    final DioMediaType mediaType = parts.length == 2
        ? DioMediaType(parts[0], parts[1])
        : DioMediaType('application', 'octet-stream');
    final FormData formData = FormData.fromMap(<String, dynamic>{
      'audio': await MultipartFile.fromFile(
        filePath,
        filename: fileName,
        contentType: mediaType,
      ),
    });
    final Map<String, dynamic> response = await _authorized(
      'POST',
      '/api/v1/audio/transcriptions',
      data: formData,
      cancelToken: cancelToken,
    );
    final Map<String, dynamic> data = Map<String, dynamic>.from(
        response['data'] as Map? ?? const <String, dynamic>{});
    return data['text']?.toString().trim() ?? '';
  }

  Future<void> submitFeedback({
    required String messageId,
    required int rating,
    String reason = '',
    String comment = '',
  }) async {
    await _authorized(
      'PUT',
      '/api/v1/messages/$messageId/feedback',
      data: <String, dynamic>{
        'rating': rating,
        'reason': reason,
        'comment': comment,
      },
    );
  }

  Future<void> deleteConversation(String conversationId) async {
    await _authorized('DELETE', '/api/v1/conversations/$conversationId');
  }

  /// 退出登录时调用：尝试通知 Agent 服务并立即清除本地 Token。
  Future<void> logout() async {
    final String? token = _accessToken;
    _credentials = null;
    await _clearToken();
    if (token == null || token.isEmpty) return;

    _accessToken = token;
    try {
      await _request('DELETE', '/api/v1/auth/merchant/token', auth: true);
    } catch (_) {
      // 网络失败时本地已清除，不再阻塞退出登录。
    } finally {
      _accessToken = null;
    }
  }

  Future<Map<String, dynamic>> _authorized(
    String method,
    String path, {
    Object? data,
    Options? options,
    CancelToken? cancelToken,
  }) async {
    if (_credentials == null) {
      throw const AgentApiException(0, '未获取到 App 登录信息，请重新登录');
    }
    await _ensureToken();
    try {
      return await _request(
        method,
        path,
        data: data,
        options: options,
        cancelToken: cancelToken,
        auth: true,
      );
    } on AgentApiException catch (error) {
      if (error.statusCode != 401) rethrow;
      await _clearToken();
      await login(_credentials!);
      return _request(
        method,
        path,
        data: data,
        options: options,
        cancelToken: cancelToken,
        auth: true,
      );
    }
  }

  Future<void> _ensureToken() async {
    await _loadToken();
    final AgentCredentials? credentials = _credentials;
    if (credentials == null ||
        !_tokenUsable ||
        _boundUid != credentials.uid ||
        _boundSellerId != credentials.sellerId) {
      if (credentials == null) {
        throw const AgentApiException(0, '未获取到 App 登录信息，请重新登录');
      }
      await login(credentials);
    }
  }

  Future<Map<String, dynamic>> _request(
    String method,
    String path, {
    Object? data,
    Options? options,
    CancelToken? cancelToken,
    bool auth = true,
  }) async {
    final Options requestOptions = options ?? Options();
    requestOptions.method = method;
    requestOptions.headers ??= <String, dynamic>{};
    requestOptions.headers!['Accept'] = 'application/json';
    if (auth) {
      requestOptions.headers!['Authorization'] = 'Bearer ${_accessToken ?? ''}';
    }
    if (data is Map) {
      requestOptions.headers!['Content-Type'] = 'application/json';
    }

    try {
      final Response<dynamic> response = await _dio.request<dynamic>(
        path,
        data: data,
        options: requestOptions,
        cancelToken: cancelToken,
      );
      return _toMap(response.data);
    } on DioException catch (error) {
      if (error.type == DioExceptionType.cancel) rethrow;
      final int status = error.response?.statusCode ?? 0;
      throw AgentApiException(
          status, _messageFor(status, error.response?.data));
    }
  }

  Map<String, dynamic> _toMap(dynamic data) {
    if (data == null) return <String, dynamic>{};
    if (data is Map) return Map<String, dynamic>.from(data);
    return <String, dynamic>{'data': data};
  }

  String _messageFor(int statusCode, dynamic data) {
    switch (statusCode) {
      case 400:
        return '请求参数有误，请检查后重试';
      case 401:
        return 'App 登录状态无效或已过期，请重新登录';
      case 403:
        return '当前商家账号暂无权限，请联系管理员';
      case 404:
        return '会话或消息不存在，请刷新后重试';
      case 422:
        return '输入内容不符合要求，请修改后重试';
      case 429:
        return '操作太频繁，请稍后再试';
      case 502:
        return '业务数据服务繁忙，请稍后重试';
      case 503:
        return 'AI 服务暂时不可用，请稍后重试';
      default:
        if (data is Map) {
          final dynamic message = data['message'];
          if (message is String && message.trim().isNotEmpty) {
            return message.trim();
          }
          final dynamic error = data['error'];
          if (error is String && error.trim().isNotEmpty) return error.trim();
          if (error is Map && error['message'] is String) {
            return error['message'].toString();
          }
        }
        return '网络请求失败，请稍后重试';
    }
  }

  Future<void> _loadToken() async {
    final SharedPreferences prefs = await SharedPreferences.getInstance();
    _accessToken = prefs.getString(_tokenKey);
    _expiresAt = DateTime.tryParse(prefs.getString(_expiresKey) ?? '');
    _boundUid = prefs.getInt(_uidKey);
    _boundSellerId = prefs.getInt(_sellerKey);
  }

  Future<void> _saveToken(AgentLoginData data) async {
    final SharedPreferences prefs = await SharedPreferences.getInstance();
    await prefs.setString(_tokenKey, data.accessToken);
    if (data.expiresAt != null) {
      await prefs.setString(_expiresKey, data.expiresAt!.toIso8601String());
    }
    await prefs.setInt(_uidKey, data.user.externalUserId);
    await prefs.setInt(_sellerKey, data.user.merchantId);
  }

  Future<void> _clearToken() async {
    _accessToken = null;
    _expiresAt = null;
    _boundUid = null;
    _boundSellerId = null;
    final SharedPreferences prefs = await SharedPreferences.getInstance();
    await prefs.remove(_tokenKey);
    await prefs.remove(_expiresKey);
    await prefs.remove(_uidKey);
    await prefs.remove(_sellerKey);
  }
}