import 'dart:async';
import 'dart:convert';
import 'dart:io';

import 'package:crypto/crypto.dart' show sha256;
import 'package:flutter/foundation.dart';
import 'package:http/http.dart' as http;
import 'package:path_provider/path_provider.dart';

import '../config/app_config.dart';

/// 识别档位标识：s = 高识别（@1280 精度优先，默认），n = 高性能（@704 速度优先）
const String kVariantS = 's';
const String kVariantN = 'n';

/// 模型身份键：同一数据集不同档位是两个独立条目（下载/激活/记账互不影响）
typedef ModelKey = ({int datasetId, String variant});

/// 模型目录条目（GET /api/v1/app/update 响应 data.models[]）。
/// 服务器发布模型后随版本检查一同下发，App 按目录逐数据集下载/更新。
/// 双档位（2026-09-03）：每数据集至多 2 条（s/n 各一），[variant] 标识档位。
class ModelCatalogItem {
  final int datasetId;
  final String datasetName;
  final String variant;
  final String version;
  final List<String> labels;
  final int sizeBytes;
  final String sha256;
  final String downloadUrl;
  final String coverUrl;

  const ModelCatalogItem({
    required this.datasetId,
    required this.datasetName,
    this.variant = kVariantS,
    required this.version,
    required this.labels,
    required this.sizeBytes,
    required this.sha256,
    required this.downloadUrl,
    this.coverUrl = '',
  });

  factory ModelCatalogItem.fromJson(Map<String, dynamic> j) =>
      ModelCatalogItem(
        datasetId: (j['datasetId'] as num?)?.toInt() ?? 0,
        datasetName: j['datasetName'] as String? ?? '',
        // 旧目录无 variant 字段（2026-09-03 前发布的单档 s）→ 归为 s
        variant: j['variant'] as String? ?? kVariantS,
        version: j['version'] as String? ?? '',
        labels: (j['labels'] as List? ?? const [])
            .map((e) => e.toString())
            .toList(),
        sizeBytes: (j['sizeBytes'] as num?)?.toInt() ?? 0,
        sha256: j['sha256'] as String? ?? '',
        downloadUrl: j['downloadUrl'] as String? ?? '',
        coverUrl: j['coverUrl'] as String? ?? '',
      );
}

/// 已就绪模型（字节 + 标签，供推理 worker 加载）
class ModelBundle {
  final int datasetId;
  final String datasetName;
  final String variant;
  final String version;
  final List<String> labels;
  final Uint8List bytes;

  const ModelBundle({
    required this.datasetId,
    required this.datasetName,
    required this.variant,
    required this.version,
    required this.labels,
    required this.bytes,
  });
}

/// 模型热更新管理：启动时拉取模型目录（随 /app/update 公开接口下发，无需登录态），
/// 按需下载/校验/持久化各数据集模型，供相机页多模型并行推理。
///
/// 双档位存储（2026-09-03）：`models/<datasetId>/` 存放 s 档（legacy 布局，目录键 =
/// 档位标识符的「无子目录」形态，存量设备无需迁移），n 档存 `models/<datasetId>/n/`；
/// 各目录含 model.tflite + labels.json + meta.json，meta 记录 {version, sha256}，
/// 版本与摘要都未变化时跳过下载。记账键一律是 (datasetId, variant) 二元组。
/// 激活集与识别档位无关（跨档保持）；推理加载「当前档位」下全部激活模型，
/// 切档即热加载新档位已激活模型（[mode] 持久化本地）。
class ModelManager extends ChangeNotifier {
  static final ModelManager instance = ModelManager._();

  final String baseUrl;
  final http.Client _client;
  final Future<Directory> Function()? _rootDirOverride;

  List<ModelBundle> _models = const [];
  List<ModelCatalogItem> _catalog = const [];
  final Set<ModelKey> _active = {};
  final Set<ModelKey> _downloaded = {};
  final Map<ModelKey, double> _progress = {};
  final Map<ModelKey, String> _errors = {};
  final Set<ModelKey> _cancelRequested = {};
  String _mode = kVariantS;
  bool _modeLoaded = false;
  bool _activeLoaded = false;
  bool _ready = false;
  bool _refreshing = false;
  String? _error;
  Future<void>? _inFlight;

  /// 模型文件/激活集变更版本戳：下载完成或激活变化 +1，
  /// UI 据此判断是否需要重建推理 worker（2026-09-01 自动更新引入）
  int _revision = 0;
  int get revision => _revision;

  /// 服务器目录（弹层模型清单展示用；同一数据集可能 s/n 两行）
  List<ModelCatalogItem> get catalog => _catalog;

  /// 当前识别档位（s 高识别默认 / n 高性能），持久化，切档即热加载新档位模型
  String get mode => _mode;

  bool isActive(int datasetId, String variant) =>
      _active.contains((datasetId: datasetId, variant: variant));

  /// 该 (数据集, 档位) 模型文件是否已下载到本地（同步判断，内存态）
  bool isDownloaded(int datasetId, String variant) =>
      _downloaded.contains((datasetId: datasetId, variant: variant));

  /// 下载进度 0..1（无下载/已完成为 null）
  double? progressOf(int datasetId, String variant) =>
      _progress[(datasetId: datasetId, variant: variant)];

  /// 下载失败原因（失败后可重试）
  String? errorOf(int datasetId, String variant) =>
      _errors[(datasetId: datasetId, variant: variant)];

  /// 中断进行中的下载：下一个数据块到达时终止（丢弃 .part），卡片恢复「使用」。
  /// 取消不记错误，可再次下载。
  void cancelDownload(int datasetId, String variant) {
    _cancelRequested.add((datasetId: datasetId, variant: variant));
  }

  ModelManager._({String? baseUrl, http.Client? client})
      : this(baseUrl: baseUrl, client: client);

  /// 可注入 baseUrl / client / 存储根目录（单测用）
  @visibleForTesting
  ModelManager({
    String? baseUrl,
    http.Client? client,
    Future<Directory> Function()? rootDir,
  })  : baseUrl = baseUrl ?? AppConfig.apiBaseUrl,
        _client = client ?? http.Client(),
        _rootDirOverride = rootDir;

  /// 已激活且已下载、且属于当前档位的模型列表（空 = 未加载任何模型，仅预览）
  List<ModelBundle> get models => _models;

  /// 是否成功拉取过目录（即使下载失败也为 true，用于区分"从未联网"与"目录为空"）
  bool get ready => _ready;

  /// 模型目录拉取失败的错误信息（仅目录级；下载/校验失败见 errorOf）
  String? get error => _error;

  bool get refreshing => _refreshing;

  /// 模型名摘要（诊断行展示）：数据集名+档位
  String get modelsLabel {
    if (_models.isEmpty) return '未下载';
    return _models.map((m) => '${m.datasetName}(${m.variant})').join(',');
  }

  /// 切换识别档位：持久化本地并热加载该档位已激活模型（激活集跨档保留）
  Future<void> setMode(String variant) async {
    if (variant != kVariantS && variant != kVariantN) return;
    if (_mode == variant) return;
    _mode = variant;
    await _saveMode();
    _models = await _loadBundles(_catalog);
    _revision++;
    notifyListeners();
  }

  /// 拉取目录并同步本地模型；并发调用共享同一进行中的刷新。
  Future<void> refresh() {
    if (_refreshing) return _inFlight ?? Future.value();
    _refreshing = true;
    _inFlight = _doRefresh().whenComplete(() {
      _refreshing = false;
      _inFlight = null;
      notifyListeners();
    });
    return _inFlight!;
  }

  Future<void> _doRefresh() async {
    try {
      await _loadActive();
      await _loadMode();
      final res = await _client
          .get(Uri.parse('$baseUrl/api/v1/app/update'))
          .timeout(const Duration(seconds: 30));
      // 服务器 Content-Type 无 charset，http 包默认按 latin1 解码会乱码 → 显式 utf8
      final body =
          jsonDecode(utf8.decode(res.bodyBytes)) as Map<String, dynamic>;
      final data = body['data'] as Map<String, dynamic>? ?? const {};
      final list = data['models'] as List? ?? const [];
      _catalog = list
          .map((e) => ModelCatalogItem.fromJson(e as Map<String, dynamic>))
          .toList();

      // 只拉目录不下载；扫描本地已下载（meta+文件齐备）供清单展示
      final downloaded = <ModelKey>{};
      for (final item in _catalog) {
        if (await _isLocal(item)) {
          downloaded.add((datasetId: item.datasetId, variant: item.variant));
        }
      }
      _downloaded
        ..clear()
        ..addAll(downloaded);

      await _prune(_catalog);
      // 服务器已下线的 (数据集, 档位) 移出激活集
      final catalogKeys = _catalog
          .map((c) => (datasetId: c.datasetId, variant: c.variant))
          .toSet();
      final pruned = _active.where((k) => !catalogKeys.contains(k)).toList();
      if (pruned.isNotEmpty) {
        for (final k in pruned) {
          _active.remove(k);
        }
        await _saveActive();
      }

      _models = await _loadBundles(_catalog);
      _ready = true;
      _error = null;
      // 自动更新：已下载/已激活模型发现新版本后台重下（不阻塞目录刷新）
      unawaited(autoUpdate());
    } catch (e) {
      if (!_ready) _error = '模型目录拉取失败:$e';
      // 已就绪过则保留旧目录/旧模型，不覆盖 error（下载级错误优先展示）
    }
  }

  /// 本地是否已有匹配版本的文件（meta 版本+sha256 相符且文件存在）
  Future<bool> _isLocal(ModelCatalogItem item) async {
    final dir = await _modelDir(item.datasetId, item.variant);
    try {
      final meta = await _readMeta(dir);
      final file = File('${dir.path}/model.tflite');
      return meta != null &&
          meta['version'] == item.version &&
          meta['sha256'] == item.sha256 &&
          await file.exists();
    } catch (e) {
      return false;
    }
  }

  /// 按需下载并激活：流式下载 + sha256 校验 + 落盘（labels/meta）；
  /// 成功自动加入激活集（下载完成即使用；非当前档位则备好待切档）。
  /// 失败重试一次并记录错误。
  Future<bool> downloadModel(ModelCatalogItem item,
      {void Function(int received, int total)? onProgress}) async {
    final key = (datasetId: item.datasetId, variant: item.variant);
    // 并发保护：同一 (数据集, 档位) 已有进行中的下载则直接短路
    if (_progress.containsKey(key)) return false;
    _cancelRequested.remove(key);
    _progress[key] = 0;
    final dir = await _modelDir(item.datasetId, item.variant);
    final file = File('${dir.path}/model.tflite');
    try {
      for (var attempt = 0; attempt < 2; attempt++) {
        if (_cancelRequested.contains(key)) break;
        final ok = await _downloadAndVerify(item, dir, file,
            onProgress: (r, t) {
          _progress[key] = t == 0 ? 0 : r / t;
          onProgress?.call(r, t);
          notifyListeners();
        });
        if (ok) {
          _progress.remove(key);
          _errors.remove(key);
          _downloaded.add(key);
          if (item.variant == _mode) {
            // 字节替换生效（当前档位模型更新需重建 worker 读新文件）
            _revision++;
          }
          _models = await _loadBundles(_catalog);
          notifyListeners();
          await setActive(item.datasetId, item.variant, true);
          return true;
        }
        if (_cancelRequested.contains(key)) break;
        await file.delete().catchError((_) => file);
        await File('${dir.path}/model.tflite.part')
            .delete()
            .catchError((_) => file);
      }
      if (_cancelRequested.contains(key)) {
        // 用户取消：清理残留，不记错误
        await file.delete().catchError((_) => file);
        await File('${dir.path}/model.tflite.part')
            .delete()
            .catchError((_) => file);
        _progress.remove(key);
        notifyListeners();
        debugPrint('[ModelManager] 下载已取消: ${item.datasetName}');
        return false;
      }
      _progress.remove(key);
      _errors[key] = '下载失败，请重试';
      notifyListeners();
      debugPrint('[ModelManager] 下载失败: ${item.datasetName} ${item.version}');
      return false;
    } catch (e) {
      if (_cancelRequested.contains(key)) {
        await file.delete().catchError((_) => file);
        await File('${dir.path}/model.tflite.part')
            .delete()
            .catchError((_) => file);
        _progress.remove(key);
        notifyListeners();
        debugPrint('[ModelManager] 下载已取消: ${item.datasetName}');
        return false;
      }
      _progress.remove(key);
      _errors[key] = '下载异常:$e';
      notifyListeners();
      debugPrint('[ModelManager] 下载异常 ${item.datasetName}: $e');
      return false;
    }
  }

  Future<bool> _downloadAndVerify(
      ModelCatalogItem item, Directory dir, File file,
      {void Function(int received, int total)? onProgress}) async {
    final part = File('${file.path}.part');
    final sink = part.openWrite();
    var received = 0;
    try {
      // 下载无总时长上限（大模型慢网可能数分钟）；连接/响应头与数据流
      // 分别做 30s 停滞判定，避免断流黑洞永久卡死
      final res = await _client
          .send(http.Request('GET', Uri.parse('$baseUrl${item.downloadUrl}')))
          .timeout(const Duration(seconds: 30));
      if (res.statusCode != 200) {
        await sink.close();
        return false;
      }
      final total = res.contentLength ?? item.sizeBytes;
      await for (final chunk
          in res.stream.timeout(const Duration(seconds: 30))) {
        if (_cancelRequested.contains(
            (datasetId: item.datasetId, variant: item.variant))) {
          break; // 用户取消
        }
        sink.add(chunk);
        received += chunk.length;
        onProgress?.call(received, total);
      }
      if (_cancelRequested.contains(
          (datasetId: item.datasetId, variant: item.variant))) {
        await sink.close();
        return false;
      }
      await sink.close();
      final bytes = await part.readAsBytes();
      final hex = sha256.convert(bytes).toString();
      if (item.sha256.isNotEmpty && hex != item.sha256) {
        debugPrint('[ModelManager] sha256 不匹配: ${item.datasetName} '
            'want=${item.sha256} got=$hex');
        return false;
      }
      await part.rename(file.path);
      await dir.create(recursive: true);
      await File('${dir.path}/labels.json')
          .writeAsString(jsonEncode(item.labels));
      await File('${dir.path}/meta.json').writeAsString(jsonEncode({
        'version': item.version,
        'sha256': item.sha256,
      }));
      debugPrint('[ModelManager] 已下载 ${item.datasetName}(${item.variant}) '
          '${bytes.length}B -> ${file.path}');
      return true;
    } catch (e) {
      await sink.close().catchError((_) {});
      debugPrint('[ModelManager] 下载异常 ${item.datasetName}: $e');
      return false;
    }
  }

  /// 清理本地目录：数据集整体下线（s/n 两档都无目录条目）删整目录；
  /// 数据集仍在但某档已下线时清该档子目录（s 档为同级文件，无独立目录，
  /// 残留文件不再被引用，仅占用磁盘，不做细粒度清除）。
  Future<void> _prune(List<ModelCatalogItem> catalog) async {
    final root = await _rootDir();
    if (!await root.exists()) return;
    final dsIds = catalog.map((c) => c.datasetId).toSet();
    final nDsIds = catalog
        .where((c) => c.variant == kVariantN)
        .map((c) => c.datasetId)
        .toSet();
    await for (final e in root.list()) {
      if (e is! Directory) continue;
      // 目录 URI 末尾带 '/'，pathSegments 末位为空串 → 过滤后取目录名
      final name = e.uri.pathSegments.where((s) => s.isNotEmpty).last;
      final dsId = int.tryParse(name);
      if (dsId == null) continue;
      if (!dsIds.contains(dsId)) {
        await e.delete(recursive: true).catchError((_) => e);
        continue;
      }
      if (!nDsIds.contains(dsId)) {
        final sub = Directory('${e.path}/$kVariantN');
        if (await sub.exists()) {
          await sub.delete(recursive: true).catchError((_) => e);
        }
      }
    }
  }

  /// 设置激活状态（true=使用，false=取消）；持久化到 `root/active.json`。
  /// 激活跨档位保留（切档后仍生效）；仅影响当前档位加载时才需重建推理 worker。
  /// 未下载的模型不可激活（下载完成由 downloadModel 自动激活）。
  Future<void> setActive(int datasetId, String variant, bool active) async {
    final key = (datasetId: datasetId, variant: variant);
    final changed = active ? _active.add(key) : _active.remove(key);
    if (!changed) return;
    if (variant == _mode) {
      _revision++;
      _models = await _loadBundles(_catalog);
    }
    await _saveActive();
    notifyListeners();
  }

  /// 自动更新：已下载/已激活的模型，目录出现新版本时自动重下（保持原激活状态；
  /// 未下载的模型不自动拉取，避免无谓流量）。下载进度经 downloadModel 通知。
  /// 2026-09-01 用户需求：发布新模型后 App 端自动更新，无需手动触发。
  Future<void> autoUpdate() async {
    if (_catalog.isEmpty) return;
    final tracked = {..._downloaded, ..._active};
    for (final item in _catalog) {
      final key = (datasetId: item.datasetId, variant: item.variant);
      if (!tracked.contains(key)) continue;
      final wasActive = _active.contains(key);
      try {
        // 后台 fire-and-forget：本地检查/下载都可能撞上存储变动（如清理），
        // 不得向外抛未处理异步异常
        if (await _isLocal(item)) continue;
        final ok = await downloadModel(item);
        // 原本未激活：下载完成自动激活后恢复原状态
        if (ok && !wasActive) {
          await setActive(item.datasetId, item.variant, false);
        }
      } catch (e) {
        debugPrint('[ModelManager] 自动更新失败: ${item.datasetName} $e');
      }
    }
  }

  Future<void> _saveActive() async {
    try {
      final root = await _rootDir();
      await root.create(recursive: true);
      await File('${root.path}/active.json').writeAsString(jsonEncode({
        'active': [
          for (final k in _active) {'d': k.datasetId, 'v': k.variant}
        ]
      }));
    } catch (e) {
      debugPrint('[ModelManager] 激活集持久化失败: $e');
    }
  }

  /// 读取激活集。兼容旧版纯 int 列表（双档位前只有 s 档，int 一律归为 s）。
  Future<void> _loadActive() async {
    if (_activeLoaded) return;
    _activeLoaded = true;
    try {
      final root = await _rootDir();
      final f = File('${root.path}/active.json');
      if (!await f.exists()) return;
      final data = jsonDecode(await f.readAsString()) as Map<String, dynamic>;
      for (final e in data['active'] as List? ?? const []) {
        if (e is num) {
          _active.add((datasetId: e.toInt(), variant: kVariantS));
        } else if (e is Map) {
          final v = e['v'] as String? ?? kVariantS;
          final d = (e['d'] as num?)?.toInt();
          if (d != null && v != kVariantS && v != kVariantN) continue;
          if (d != null) _active.add((datasetId: d, variant: v));
        }
      }
    } catch (e) {
      debugPrint('[ModelManager] 激活集读取失败: $e');
    }
  }

  Future<void> _saveMode() async {
    try {
      final root = await _rootDir();
      await root.create(recursive: true);
      await File('${root.path}/mode.json')
          .writeAsString(jsonEncode({'mode': _mode}));
    } catch (e) {
      debugPrint('[ModelManager] 识别档位持久化失败: $e');
    }
  }

  Future<void> _loadMode() async {
    if (_modeLoaded) return;
    _modeLoaded = true;
    try {
      final root = await _rootDir();
      final f = File('${root.path}/mode.json');
      if (!await f.exists()) return;
      final data = jsonDecode(await f.readAsString()) as Map<String, dynamic>;
      final m = data['mode'] as String? ?? kVariantS;
      if (m == kVariantS || m == kVariantN) _mode = m;
    } catch (e) {
      debugPrint('[ModelManager] 识别档位读取失败: $e');
    }
  }

  Future<List<ModelBundle>> _loadBundles(
      List<ModelCatalogItem> catalog) async {
    final bundles = <ModelBundle>[];
    for (final item in catalog) {
      if (item.variant != _mode) continue;
      final key = (datasetId: item.datasetId, variant: item.variant);
      if (!_active.contains(key)) continue;
      try {
        final dir = await _modelDir(item.datasetId, item.variant);
        final file = File('${dir.path}/model.tflite');
        if (!await file.exists()) continue;
        final labels = await File('${dir.path}/labels.json').exists()
            ? (jsonDecode(
                    await File('${dir.path}/labels.json').readAsString())
                as List)
                .map((e) => e.toString())
                .toList()
            : item.labels;
        bundles.add(ModelBundle(
          datasetId: item.datasetId,
          datasetName: item.datasetName,
          variant: item.variant,
          version: item.version,
          labels: labels,
          bytes: await file.readAsBytes(),
        ));
      } catch (e) {
        debugPrint('[ModelManager] 读取 ${item.datasetName} 失败: $e');
      }
    }
    return bundles;
  }

  Future<Map<String, dynamic>?> _readMeta(Directory dir) async {
    final f = File('${dir.path}/meta.json');
    if (!await f.exists()) return null;
    try {
      return jsonDecode(await f.readAsString()) as Map<String, dynamic>;
    } catch (_) {
      return null;
    }
  }

  Future<Directory> _rootDir() async {
    if (_rootDirOverride != null) return _rootDirOverride();
    final support = await getApplicationSupportDirectory();
    return Directory('${support.path}/models');
  }

  /// 档位目录：s 档存 `models/<datasetId>/`（legacy 无子目录，目录键 = 档位
  /// 标识符的 s 形态，存量设备零迁移）；n 档存 `models/<datasetId>/n/`。
  Future<Directory> _modelDir(int datasetId, String variant) async {
    final root = await _rootDir();
    final sub = variant == kVariantS ? '' : '/$variant';
    final dir = Directory('${root.path}/$datasetId$sub');
    await dir.create(recursive: true);
    return dir;
  }
}