import 'package:flutter_test/flutter_test.dart';
import 'package:yx_asr/yx_asr.dart';

void main() {
  group('SpeechRecognitionResult 测试', () {
    test('应该正确创建结果对象', () {
      final result = SpeechRecognitionResult(
        recognizedWords: '测试文本',
      );

      expect(result.recognizedWords, '测试文本');
    });

    test('应该正确转换为 Map', () {
      final result = SpeechRecognitionResult(
        recognizedWords: '测试',
      );

      final map = result.toMap();
      expect(map['recognizedWords'], '测试');
      // 当前 SpeechRecognitionResult 仅包含 recognizedWords 字段
      expect(map.containsKey('confidence'), false);
      expect(map.containsKey('alternatives'), false);
    });

    test('应该正确从 Map 创建', () {
      final map = {
        'recognizedWords': '从Map创建',
        // 允许包含其他字段，但当前实现会忽略
        'finalResult': true,
        'confidence': 0.9,
        'alternatives': ['备选'],
      };

      final result = SpeechRecognitionResult.fromMap(map);
      expect(result.recognizedWords, '从Map创建');
    });

    test('应该处理空的 Map', () {
      final map = <String, dynamic>{};
      final result = SpeechRecognitionResult.fromMap(map);

      expect(result.recognizedWords, '');
    });
  });

  group('SpeechRecognitionError 测试', () {
    test('应该正确创建错误对象', () {
      final error = SpeechRecognitionError(
        errorType: SpeechRecognitionErrorType.permissionDenied,
        errorMsg: '权限被拒绝',
        errorCode: 'PERMISSION_DENIED',
      );

      expect(error.errorType, SpeechRecognitionErrorType.permissionDenied);
      expect(error.errorMsg, '权限被拒绝');
      expect(error.errorCode, 'PERMISSION_DENIED');
    });

    test('应该正确转换为 Map', () {
      final error = SpeechRecognitionError(
        errorType: SpeechRecognitionErrorType.service,
        errorMsg: '服务错误',
        errorCode: null,
      );

      final map = error.toMap();
      expect(map['errorType'], 'service');
      expect(map['errorMsg'], '服务错误');
      expect(map['errorCode'], null);
    });

    test('应该正确从 Map 创建', () {
      final map = {
        'errorType': 'audio',
        'errorMsg': '音频错误',
        'errorCode': 'AUDIO_ERROR',
      };

      final error = SpeechRecognitionError.fromMap(map);
      expect(error.errorType, SpeechRecognitionErrorType.audio);
      expect(error.errorMsg, '音频错误');
      expect(error.errorCode, 'AUDIO_ERROR');
    });

    test('未知错误类型应该默认为 unknown', () {
      final map = {
        'errorType': 'invalid_type',
        'errorMsg': '未知错误',
      };

      final error = SpeechRecognitionError.fromMap(map);
      expect(error.errorType, SpeechRecognitionErrorType.unknown);
      expect(error.errorMsg, '未知错误');
    });

    test('应该处理空的错误消息', () {
      final map = {
        'errorType': 'service',
      };

      final error = SpeechRecognitionError.fromMap(map);
      expect(error.errorType, SpeechRecognitionErrorType.service);
      expect(error.errorMsg, '发生未知错误');
      expect(error.errorCode, null);
    });
  });

  group('SpeechRecognitionConfig 测试', () {
    test('应该正确创建配置对象', () {
      final config = SpeechRecognitionConfig(
        modelPath: 'test/path',
        localeId: 'zh-CN',
        sampleRate: 22050,
        onDevice: true,
        customConfig: {'key': 'value'},
      );

      expect(config.modelPath, 'test/path');
      expect(config.localeId, 'zh-CN');
      expect(config.sampleRate, 22050);
      expect(config.onDevice, true);
      expect(config.customConfig['key'], 'value');
    });

    test('应该使用默认值', () {
      final config = SpeechRecognitionConfig();

      expect(config.modelPath, null);
      expect(config.localeId, null);
      expect(config.sampleRate, 16000);
      expect(config.onDevice, false);
      expect(config.customConfig, {});
    });

    test('应该正确转换为 Map', () {
      final config = SpeechRecognitionConfig(
        modelPath: 'test/path',
        localeId: 'en-US',
      );

      final map = config.toMap();
      expect(map['modelPath'], 'test/path');
      expect(map['localeId'], 'en-US');
      expect(map['sampleRate'], 16000); // 默认值
      expect(map['onDevice'], false); // 默认值
    });

    test('自定义配置应该合并到 Map 中', () {
      final config = SpeechRecognitionConfig(
        customConfig: {'custom1': 'value1', 'custom2': 'value2'},
      );

      final map = config.toMap();
      expect(map['custom1'], 'value1');
      expect(map['custom2'], 'value2');
    });

    test('自定义配置应该覆盖默认值', () {
      final config = SpeechRecognitionConfig(
        sampleRate: 22050,
        customConfig: {'sampleRate': 44100}, // 这个应该覆盖上面的值
      );

      final map = config.toMap();
      expect(map['sampleRate'], 44100); // 自定义配置优先
    });
  });

  group('错误类型枚举测试', () {
    test('应该包含所有预期的错误类型', () {
      final errorTypes = SpeechRecognitionErrorType.values;

      expect(errorTypes.contains(SpeechRecognitionErrorType.network), true);
      expect(errorTypes.contains(SpeechRecognitionErrorType.audio), true);
      expect(errorTypes.contains(SpeechRecognitionErrorType.service), true);
      expect(errorTypes.contains(SpeechRecognitionErrorType.permissionDenied),
          true);
      expect(
          errorTypes.contains(SpeechRecognitionErrorType.notAvailable), true);
      expect(errorTypes.contains(SpeechRecognitionErrorType.cancelled), true);
      expect(errorTypes.contains(SpeechRecognitionErrorType.noSpeech), true);
      expect(errorTypes.contains(SpeechRecognitionErrorType.unknown), true);
    });

    test('错误类型名称应该正确', () {
      expect(SpeechRecognitionErrorType.network.name, 'network');
      expect(SpeechRecognitionErrorType.audio.name, 'audio');
      expect(SpeechRecognitionErrorType.service.name, 'service');
      expect(
          SpeechRecognitionErrorType.permissionDenied.name, 'permissionDenied');
      expect(SpeechRecognitionErrorType.notAvailable.name, 'notAvailable');
      expect(SpeechRecognitionErrorType.cancelled.name, 'cancelled');
      expect(SpeechRecognitionErrorType.noSpeech.name, 'noSpeech');
      expect(SpeechRecognitionErrorType.unknown.name, 'unknown');
    });
  });
}