import 'package:camera/camera.dart';
import 'package:flutter/foundation.dart';

import 'package:mini_tias/models/preview_frame.dart';
import 'package:mini_tias/services/file_service.dart';
import 'package:mini_tias/services/permission_service.dart';
import 'package:mini_tias/services/raw_capture_service.dart';
import 'package:mini_tias/services/sound_service.dart';

/// カメラの初期化・プレビュー制御・撮影実行・ライフサイクルを管理する．
class CameraProvider extends ChangeNotifier {
  final PermissionService _permissionService = PermissionService();
  final FileService _fileService = FileService();
  final RawCaptureService _rawCaptureService = RawCaptureService();
  final SoundService _soundService = SoundService();

  CameraController? _controller;
  bool _isInitialized = false;
  String? _errorMessage;
  bool _permissionDenied = false;
  bool _permissionPermanentlyDenied = false;
  String? _lastSavedFileName;
  bool _isSaving = false;
  bool _imageStreamActive = false;
  PreviewFrame? _latestFrame;

  CameraController? get controller => _controller;
  bool get isInitialized => _isInitialized;
  String? get errorMessage => _errorMessage;
  bool get permissionDenied => _permissionDenied;
  bool get permissionPermanentlyDenied => _permissionPermanentlyDenied;
  String? get lastSavedFileName => _lastSavedFileName;
  bool get isSaving => _isSaving;
  bool get isSoundEnabled => _soundService.isSoundEnabled;

  /// サウンド設定を切り替える．
  Future<void> toggleSound() async {
    await _soundService.toggleSound();
    notifyListeners();
  }

  /// シャッター音を再生する．
  Future<void> playShutterSound() async {
    await _soundService.playShutterSound();
  }

  /// カメラを初期化する．
  Future<void> initialize() async {
    await _soundService.init();

    final granted = await _permissionService.requestCamera();
    if (!granted) {
      _permissionDenied = true;
      _permissionPermanentlyDenied = await _permissionService
          .isCameraPermanentlyDenied();
      _errorMessage = 'カメラの権限が必要です';
      notifyListeners();
      return;
    }

    _permissionDenied = false;
    _permissionPermanentlyDenied = false;

    try {
      final cameras = await availableCameras();
      final frontCamera = cameras.firstWhere(
        (c) => c.lensDirection == CameraLensDirection.front,
      );

      _controller = CameraController(
        frontCamera,
        ResolutionPreset.max,
        enableAudio: false,
      );

      await _controller!.initialize();
      await _controller!.setFlashMode(FlashMode.off);
      _isInitialized = true;
      _errorMessage = null;

      _startImageStream();
    } catch (e) {
      _errorMessage = 'カメラの初期化に失敗しました: $e';
      _isInitialized = false;
    }

    notifyListeners();
  }

  /// 画像ストリームを開始して最新フレームを保持する．
  void _startImageStream() {
    if (_controller == null || _imageStreamActive) return;

    try {
      _controller!.startImageStream((CameraImage image) {
        _latestFrame = PreviewFrame(
          width: image.width,
          height: image.height,
          yPlane: Uint8List.fromList(image.planes[0].bytes),
          uPlane: Uint8List.fromList(image.planes[1].bytes),
          vPlane: Uint8List.fromList(image.planes[2].bytes),
          yRowStride: image.planes[0].bytesPerRow,
          uvRowStride: image.planes[1].bytesPerRow,
          uvPixelStride: image.planes[1].bytesPerPixel ?? 1,
        );
      });
      _imageStreamActive = true;
    } catch (e) {
      debugPrint('画像ストリーム開始失敗: $e');
    }
  }

  /// 画像ストリームを停止する．
  Future<void> _stopImageStream() async {
    if (!_imageStreamActive || _controller == null) return;

    try {
      await _controller!.stopImageStream();
    } catch (_) {
      // 既に停止済みの場合等は無視
    }
    _imageStreamActive = false;
  }

  /// 最新のプレビューフレームを JPEG として取得する（オーバーレイなし）．
  Future<Uint8List?> capturePreviewSnapshot() async {
    if (_latestFrame == null) return null;

    final frame = _latestFrame!;
    return _rawCaptureService.convertYuvToJpeg(
      width: frame.width,
      height: frame.height,
      yPlane: frame.yPlane,
      uPlane: frame.uPlane,
      vPlane: frame.vPlane,
      yRowStride: frame.yRowStride,
      uvRowStride: frame.uvRowStride,
      uvPixelStride: frame.uvPixelStride,
      rotation: 90,
      mirror: true,
    );
  }

  /// Camera2 API で定量モード撮影を行い，DNG ファイルとメタデータ JSON を保存する．
  ///
  /// [previewBytes] が指定された場合，`<baseName>.preview.jpg` として保存する．
  /// 指定しない場合はプレビュー JPEG の保存をスキップする．
  Future<void> takePicture({Uint8List? previewBytes}) async {
    if (!_isInitialized || _isSaving) return;

    _isSaving = true;
    _isInitialized = false;
    notifyListeners();

    try {
      // ストレージ権限の確認
      final storageGranted = await _permissionService.requestStorage();
      if (!storageGranted) {
        _errorMessage = 'ストレージの権限が必要です';
        _isSaving = false;
        notifyListeners();
        return;
      }

      // 画像ストリームを停止してカメラを解放
      await _stopImageStream();
      await _controller?.dispose();
      _controller = null;

      // カメラが完全に解放されるまで待つ
      await Future.delayed(const Duration(milliseconds: 500));

      // 定量モード撮影（DNG 経路）
      // baseName を先に確定し，Kotlin 側で DNG を直接書き込む
      final baseName = await _fileService.generateQuantitativeBaseName();
      final capture = await _rawCaptureService.captureQuantitativeDng(
        baseName: baseName,
        directoryPath: _fileService.directoryPath,
      );
      debugPrint(
        'DNG saved: ${capture.dngFileSize} bytes at ${capture.dngPath}',
      );

      // メタデータ JSON は引き続き Dart 側で保存
      final metaPath = await _fileService.saveQuantitativeMetadata(
        baseName,
        capture.metadata,
        lscMap: capture.lscMap,
        lscMapRowCount: capture.lscMapRowCount,
        lscMapColumnCount: capture.lscMapColumnCount,
      );

      // プレビュー JPEG 保存（snapshot がある場合のみ）
      String? previewPath;
      if (previewBytes != null) {
        previewPath = await _fileService.savePreviewJpeg(
          baseName,
          previewBytes,
        );
        debugPrint(
          'Preview saved: ${previewBytes.length} bytes at $previewPath',
        );
      }

      // MediaStore に登録（PC から MTP で見えるようにする）
      await _rawCaptureService.scanFile(capture.dngPath);
      await _rawCaptureService.scanFile(metaPath);
      if (previewPath != null) {
        await _rawCaptureService.scanFile(previewPath);
      }

      _lastSavedFileName = capture.dngPath.split('/').last;
      _errorMessage = null;

      // 保存完了音を再生（エラーで撮影フロー全体は止めない）
      await _soundService.playSaveCompleteSound();
    } catch (e) {
      _errorMessage = '撮影に失敗しました: $e';
      _lastSavedFileName = null;
    }

    _isSaving = false;
    notifyListeners();

    // プレビューを再開
    await initialize();
  }

  /// カメラリソースを解放する．
  Future<void> disposeCamera() async {
    await _stopImageStream();
    _latestFrame = null;
    _controller?.dispose();
    _controller = null;
    _isInitialized = false;
    notifyListeners();
  }

  /// アプリの設定画面を開く（権限が永久拒否された場合）．
  Future<void> openSettings() async {
    await _permissionService.openSettings();
  }

  @override
  void dispose() {
    _controller?.dispose();
    super.dispose();
  }
}