import 'dart:io';
import 'dart:typed_data';

import 'package:appframe/config/constant.dart';
import 'package:appframe/config/env_config.dart';
import 'package:appframe/config/locator.dart';
import 'package:appframe/config/routes.dart';
import 'package:appframe/data/repositories/phone_auth_repository.dart';
import 'package:appframe/services/api_service.dart';
import 'package:dio/dio.dart';
import 'package:equatable/equatable.dart';
import 'package:ffmpeg_kit_flutter_new/ffmpeg_kit.dart';
import 'package:ffmpeg_kit_flutter_new/return_code.dart';
import 'package:flutter/material.dart';
import 'package:flutter_bloc/flutter_bloc.dart';
import 'package:path/path.dart' as path;
import 'package:path_provider/path_provider.dart';
import 'package:shared_preferences/shared_preferences.dart';
import 'package:uuid/uuid.dart';

class AccountUserState extends Equatable {
  final String name;
  final String nickname;
  final String avatar;
  final bool showSnackBar;
  final String snackBarMsg;
  final bool isLoading;

  const AccountUserState({
    this.name = '',
    this.nickname = '',
    this.avatar = '',
    this.showSnackBar = false,
    this.snackBarMsg = '',
    this.isLoading = false,
  });

  AccountUserState copyWith({
    String? name,
    String? nickname,
    String? avatar,
    bool? showSnackBar,
    String? snackBarMsg,
    bool? isLoading,
  }) {
    return AccountUserState(
      name: name ?? this.name,
      nickname: nickname ?? this.nickname,
      avatar: avatar ?? this.avatar,
      showSnackBar: showSnackBar ?? this.showSnackBar,
      snackBarMsg: snackBarMsg ?? this.snackBarMsg,
      isLoading: isLoading ?? this.isLoading,
    );
  }

  @override
  List<Object?> get props => [
        name,
        nickname,
        avatar,
        showSnackBar,
        snackBarMsg,
        isLoading,
      ];
}

class AccountUserCubit extends Cubit<AccountUserState> {
  late TextEditingController _nameController;
  late TextEditingController _nickNameController;

  late final PhoneAuthRepository _phoneAuthRepository;

  TextEditingController get nameController => _nameController;

  TextEditingController get nickNameController => _nickNameController;

  AccountUserCubit(super.initialState) {
    _nameController = TextEditingController(text: state.name);
    _nickNameController = TextEditingController(text: state.nickname);

    _phoneAuthRepository = getIt.get<PhoneAuthRepository>();
  }

  void updateAvatar(String avatarPath) {
    emit(state.copyWith(avatar: avatarPath));
  }

  Future<void> save() async {
    String name = _nameController.text.trim();
    String nickname = _nickNameController.text.trim();

    if (name.isEmpty) {
      emit(state.copyWith(showSnackBar: true, snackBarMsg: '请输入姓名'));
      emit(state.copyWith(showSnackBar: false));
      return;
    }

    if (nickname.isEmpty) {
      emit(state.copyWith(showSnackBar: true, snackBarMsg: '请输入昵称'));
      emit(state.copyWith(showSnackBar: false));
      return;
    }

    emit(state.copyWith(isLoading: true));

    String imgPath = state.avatar;
    if (!imgPath.startsWith('http')) {
      imgPath = await _handleUpload(imgPath);
    }

    var sharedPreferences = getIt.get<SharedPreferences>();
    var userCode = sharedPreferences.getString('auth_userCode') ?? '';
    var result = await _phoneAuthRepository.updateUser(userCode, name, nickname, imgPath);

    emit(state.copyWith(isLoading: false));

    if (result['code'] != 0) {
      emit(state.copyWith(showSnackBar: true, snackBarMsg: result['error']));
      emit(state.copyWith(showSnackBar: false));
      return;
    }

    router.pop({"name": name, "nickname": nickname, "avatar": imgPath});
  }

  Future<String> _handleUpload(String srcImgPath) async {
    /// 1
    /// 判断文件
    ///
    //判断文件
    File srcFile = File(srcImgPath);
    if (!srcFile.existsSync()) {
      throw Exception('文件不存在');
    }
    //暂时仅支持200M的文件上传
    var fileSize = srcFile.lengthSync();
    if (fileSize > 1024 * 1024 * 200) {
      throw Exception('上传的文件过大');
    }

    // 对图片进行压缩处理
    File file = await _compressImage(srcFile);

    /// 2
    /// bucket 存储桶名称 : bxe-files | bxe-pics | bxe-videos
    ///
    String bucket = "bxe-pics";

    /// 3
    /// objectKey
    ///
    var uuid = Uuid();
    String logicPrefix = _getLoginPrefix();
    String objectKey = '$logicPrefix/${uuid.v4()}${path.extension(file.path)}';

    ///
    /// 4 计算分片
    ///
    final chunkSize = Constant.obsUploadChunkSize;
    final totalChunks = (fileSize / chunkSize).ceil();

    ///
    /// 5 sig
    ///
    final bxeApiService = ApiService(baseUrl: Constant.iotAppBaseUrl);
    late String uploadId;
    var signUrls = [];
    for (int i = 0; i < totalChunks; i++) {
      if (i == 0) {
        final initResult = await _init(bxeApiService, objectKey, bucket);
        uploadId = initResult['upload_id'] as String;
        var signUrl = initResult['signed_url'] as String;
        signUrls.add(signUrl);
      } else {
        final nextResult = await _next(bxeApiService, objectKey, bucket, uploadId, i + 1);
        var signUrl = nextResult['signed_url'] as String;
        signUrls.add(signUrl);
      }
    }

    ///
    /// 6 上传
    ///
    final dio = Dio()
      ..options = BaseOptions(
        baseUrl: '',
        connectTimeout: Duration(milliseconds: 30000),
        receiveTimeout: Duration(milliseconds: 30000),
        headers: {'Content-Type': '', 'Accept': ''},
      );

    final randomAccessFile = await file.open();
    Map<int, String> tagsMap = {};
    final futures = <Future>[];

    for (int i = 0; i < totalChunks; i++) {
      final chunkSize = Constant.obsUploadChunkSize;
      final start = i * chunkSize;
      final actualChunkSize = (i + 1) * chunkSize > fileSize ? fileSize - start : chunkSize;

      final chunk = Uint8List(actualChunkSize);
      randomAccessFile.setPositionSync(start);
      await randomAccessFile.readInto(chunk, 0, actualChunkSize);

      futures.add(_uploadChunkWithRetry(dio, signUrls[i], i, chunk));
    }

    var resultList = await Future.wait(futures);
    for (var result in resultList) {
      if (result is Map<String, dynamic>) {
        tagsMap[result['idx'] as int] = result['etag'] as String;
      }
    }
    futures.clear();

    await randomAccessFile.close();

    ///
    /// 7 合并
    ///
    String location = await _merge(bxeApiService, objectKey, bucket, uploadId, tagsMap);

    dio.close(force: true);
    bxeApiService.close();

    return 'https://pics-obs.banxiaoer.com${location.substring(9)}';
  }

  Future<File> _compressImage(File file) async {
    try {
      // 获取临时目录用于存储压缩后的图片
      final tempDir = await getTemporaryDirectory();
      final outputPath = '${tempDir.path}/compressed_${Uuid().v4()}.jpg';

      // 构建 FFmpeg 压缩命令
      // -i: 输入文件
      // -vf scale: 设置缩放尺寸，宽度最大1280，高度自动按比例缩放
      // -q:v: JPEG 质量参数 (2-31，数值越小质量越高)，这里使用10表示较好的质量
      // -y: 覆盖已存在的输出文件
      String cmd = '-i "${file.path}" '
          '-vf "scale=\'min(1280,iw)\':-2" ' // 宽度最大1280px，高度按比例，-2确保偶数值
          '-q:v 10 ' // JPEG 质量设置为10，平衡质量和文件大小
          '-y ' // 覆盖输出文件
          '"$outputPath"';

      // 执行 FFmpeg 命令
      final session = await FFmpegKit.execute(cmd);
      final returnCode = await session.getReturnCode();

      // 检查执行结果
      if (ReturnCode.isSuccess(returnCode)) {
        File compressedFile = File(outputPath);

        // 验证压缩后的文件是否存在
        if (await compressedFile.exists()) {
          final originalSize = await file.length();
          final compressedSize = await compressedFile.length();
          print('图片压缩成功: 原始大小 ${originalSize} bytes -> 压缩后 ${compressedSize} bytes');
          return compressedFile;
        } else {
          throw Exception('压缩后的文件不存在');
        }
      } else {
        // 压缩失败，打印错误信息并返回原文件
        final output = await session.getOutput();
        print('FFmpeg 压缩失败: $output');
        throw Exception('图片压缩失败');
      }
    } catch (e) {
      print('图片压缩出错: $e');
      // 如果压缩失败，返回原文件
      return file;
    }
  }

  ///
  /// 规则：http://wiki.zbuku.cn/confluence/pages/viewpage.action?pageId=137172780
  ///
  String _getLoginPrefix() {
    var now = DateTime.now();
    var year = now.year;
    var month = now.month;
    var day = now.day;

    String obsLogicPrefix = "d2";
    if (EnvConfig.env == 'pro') {
      obsLogicPrefix = "p2";
    }
    obsLogicPrefix = '$obsLogicPrefix/pridel/user/';
    String busiCode = 'app_avatar';

    String userCode = getIt.get<SharedPreferences>().getString('auth_userCode') ?? 'na';
    String classCode = getIt.get<SharedPreferences>().getString('auth_classCode') ?? 'nac';

    return '$obsLogicPrefix$year$month$day/app/$classCode/$busiCode/$userCode';
  }

  static const _signatureNewUrl = '/api/v1/obs/multipart/signaturenew';
  static const _signatureNextUrl = '/api/v1/obs/multipart/signaturenext';
  static const _completeUrl = '/api/v1/obs/multipart/complete';

  /// 初始化，请求后端获取签名信息和上传任务ID
  Future<Map<String, dynamic>> _init(ApiService bxeApiService, String objectKey, String bucket) async {
    var endpoint = '$_signatureNewUrl?objectKey=$objectKey&bucket=$bucket';
    final resp = await bxeApiService.get(endpoint);
    return resp.data;
  }

  /// 每次上传前，请求后端获取签名信息
  Future<Map<String, dynamic>> _next(
    ApiService bxeApiService,
    String objectKey,
    String bucket,
    String uploadId,
    int partNum,
  ) async {
    var endpoint = '$_signatureNextUrl?objectKey=$objectKey&bucket=$bucket&uploadId=$uploadId&partNum=$partNum';
    final resp = await bxeApiService.get(endpoint);
    return resp.data;
  }

  /// 上传段，按照最大重试次数进行上传重试
  Future<Map<String, dynamic>> _uploadChunkWithRetry(
    Dio dio,
    String signUrl,
    int chunkIndex,
    Uint8List chunk, {
    int maxRetries = 3,
  }) async {
    //print('====================> 分片$chunkIndex ， 开始上传 ${DateTime.now()}');
    for (int attempt = 0; attempt <= maxRetries; attempt++) {
      try {
        var starTime = DateTime.now();
        final resp = await _uploadChunk(dio, signUrl, chunk, chunkIndex);
        var endTime = DateTime.now();
        if (resp.statusCode == 200) {
          print(
              '====================> 分片$chunkIndex 第${attempt + 1}次， $endTime 上传耗时：${endTime.millisecondsSinceEpoch - starTime.millisecondsSinceEpoch} 毫秒');
          final etags = resp.headers['etag'] as List<String>;
          return Future.value({'idx': chunkIndex + 1, 'etag': etags[0]}); // 上传成功
        } else {
          throw Exception('Chunk $chunkIndex upload failed: ${resp.statusCode}');
        }
      } catch (e) {
        print('====================> 分片$chunkIndex 第${attempt + 1}次， 上传失败：${e.toString()}');
        if (attempt == maxRetries) {
          throw Exception('Chunk $chunkIndex upload failed after $maxRetries attempts: $e');
        }
        // 等待后重试
        await Future.delayed(Duration(seconds: 2 * attempt));
      }
    }
    throw Exception('上传失败');
  }

  /// 上传段
  Future<Response> _uploadChunk(Dio dio, String signUrl, Uint8List chunk, int chunkIndex) async {
    var url = signUrl.replaceFirst('AWSAccessKeyId=', 'AccessKeyId=').replaceFirst(':443', '');
    try {
      // Response response = await _put(url, chunk);
      print('====================> 分片$chunkIndex ， 开始上传 ${DateTime.now()}');
      final response = await dio.put(
        url,
        // data: Stream.fromIterable(chunk.map((e) => [e])),
        // data: Stream.fromIterable([chunk]),
        data: chunk,
      );
      print('====================> 分片$chunkIndex ， 上传成功 ${DateTime.now()}');

      return response;
    } catch (e) {
      throw Exception('Chunk upload failed: $e');
    }
  }

  /// 请求合并文件
  Future<String> _merge(
    ApiService bxeApiService,
    String objectKey,
    String bucket,
    String uploadId,
    Map<int, String> tagsMap,
  ) async {
    final parts = [];
    for (int i = 1; i <= tagsMap.length; i++) {
      parts.add({'partNumber': i, 'etag': tagsMap[i]});
    }

    final response = await bxeApiService.post(_completeUrl, {
      'objectKey': objectKey,
      'bucket': bucket,
      'uploadId': uploadId,
      'parts': parts,
    });

    if (response.statusCode != 200) {
      throw Exception('合并文件失败');
    }

    return response.data["location"];
  }

  @override
  Future<void> close() async {
    try {
      _nameController.dispose();
    } catch (e) {
      print(e);
    }

    try {
      _nickNameController.dispose();
    } catch (e) {
      print(e);
    }

    await super.close();
  }
}