import 'package:http/http.dart' as http;
import 'dart:convert';
import 'package:intl/intl.dart';
import '../utils/logger.dart';
import 'cache_manager.dart';

/// 환율 정보 서비스 클래스
class ExchangeRateService {
  // 싱글톤 인스턴스
  static final ExchangeRateService _instance = ExchangeRateService._internal();

  // 팩토리 생성자
  factory ExchangeRateService() {
    return _instance;
  }

  // 내부 생성자
  ExchangeRateService._internal();

  // 포맷된 환율 문자열 캐시 (언어별)
  static final SimpleCacheManager<String> _fmtCache =
      SimpleCacheManager<String>(
    maxEntries: 64,
    maxBytes: 64 * 1024,
    ttl: const Duration(minutes: 30),
  );

  // 캐싱된 환율 정보
  double? _usdToKrwRate;
  double? _usdToJpyRate;
  double? _usdToCnyRate;
  DateTime? _lastUpdated;

  // API 요청 URL (ExchangeRate-API 등) - 빌드 타임 오버라이드 가능
  static const String _defaultApiUrl =
      'https://api.exchangerate-api.com/v4/latest/USD';
  final String _apiUrl = const String.fromEnvironment(
    'EXCHANGE_RATE_API_URL',
    defaultValue: _defaultApiUrl,
  );

  // 기본 환율 상수
  // ignore: constant_identifier_names
  static const double DEFAULT_USD_TO_KRW_RATE = 1350.0;
  // ignore: constant_identifier_names
  static const double DEFAULT_USD_TO_JPY_RATE = 150.0;
  // ignore: constant_identifier_names
  static const double DEFAULT_USD_TO_CNY_RATE = 7.2;

  // 캐싱된 환율 반환 (동기적)
  double? get cachedUsdToKrwRate => _usdToKrwRate;

  /// 모든 환율 정보를 한 번에 가져옵니다.
  /// 최근 6시간 이내 조회했던 정보가 있다면 캐싱된 정보를 사용합니다.
  Future<void> _fetchAllRatesIfNeeded() async {
    // 캐싱된 데이터 있고 6시간 이내면 스킵
    if (_lastUpdated != null) {
      final difference = DateTime.now().difference(_lastUpdated!);
      if (difference.inHours < 6) {
        return;
      }
    }

    try {
      // API 요청 (네트워크 불가 환경에서는 예외 발생 가능)
      final response = await http.get(Uri.parse(_apiUrl));

      if (response.statusCode == 200) {
        final data = json.decode(response.body);
        _usdToKrwRate = (data['rates']['KRW'] as num?)?.toDouble();
        _usdToJpyRate = (data['rates']['JPY'] as num?)?.toDouble();
        _usdToCnyRate = (data['rates']['CNY'] as num?)?.toDouble();
        _lastUpdated = DateTime.now();
        // 환율 갱신 시 포맷 캐시 무효화
        _fmtCache.clear();
        Log.d(
            '환율 갱신 완료: USD→KRW=$_usdToKrwRate, JPY=$_usdToJpyRate, CNY=$_usdToCnyRate');
        return;
      } else {
        Log.w(
            '환율 API 응답 코드: ${response.statusCode} (${response.reasonPhrase})');
      }
    } catch (e, st) {
      // 네트워크 실패 시 캐시/기본값 폴백
      Log.w('환율 API 요청 실패. 캐시/기본값 사용');
      Log.e('환율 API 에러', e, st);
    }
  }

  /// 현재 USD to KRW 환율 정보를 가져옵니다.
  Future<double?> getUsdToKrwRate() async {
    await _fetchAllRatesIfNeeded();
    return _usdToKrwRate;
  }

  /// USD 금액을 KRW로 변환합니다.
  Future<double?> convertUsdToKrw(double usdAmount) async {
    final rate = await getUsdToKrwRate();
    if (rate != null) {
      return usdAmount * rate;
    }
    return null;
  }

  /// USD 금액을 지정된 통화로 변환합니다.
  Future<double?> convertUsdToTarget(
      double usdAmount, String targetCurrency) async {
    await _fetchAllRatesIfNeeded();

    switch (targetCurrency) {
      case 'KRW':
        final rate = _usdToKrwRate ?? DEFAULT_USD_TO_KRW_RATE;
        return usdAmount * rate;
      case 'JPY':
        final rate = _usdToJpyRate ?? DEFAULT_USD_TO_JPY_RATE;
        return usdAmount * rate;
      case 'CNY':
        final rate = _usdToCnyRate ?? DEFAULT_USD_TO_CNY_RATE;
        return usdAmount * rate;
      case 'USD':
        return usdAmount;
      default:
        return null;
    }
  }

  /// 지정된 통화를 USD로 변환합니다.
  Future<double?> convertTargetToUsd(
      double amount, String sourceCurrency) async {
    await _fetchAllRatesIfNeeded();

    switch (sourceCurrency) {
      case 'KRW':
        final rate = _usdToKrwRate ?? DEFAULT_USD_TO_KRW_RATE;
        return amount / rate;
      case 'JPY':
        final rate = _usdToJpyRate ?? DEFAULT_USD_TO_JPY_RATE;
        return amount / rate;
      case 'CNY':
        final rate = _usdToCnyRate ?? DEFAULT_USD_TO_CNY_RATE;
        return amount / rate;
      case 'USD':
        return amount;
      default:
        return null;
    }
  }

  /// 두 통화 간 변환을 수행합니다. (USD를 거쳐서 변환)
  Future<double?> convertBetweenCurrencies(
      double amount, String fromCurrency, String toCurrency) async {
    if (fromCurrency == toCurrency) {
      return amount;
    }

    // fromCurrency → USD → toCurrency
    double? usdAmount;

    if (fromCurrency == 'USD') {
      usdAmount = amount;
    } else {
      usdAmount = await convertTargetToUsd(amount, fromCurrency);
    }

    if (usdAmount == null) return null;

    if (toCurrency == 'USD') {
      return usdAmount;
    } else {
      return await convertUsdToTarget(usdAmount, toCurrency);
    }
  }

  /// 현재 환율 정보를 포맷팅하여 텍스트로 반환합니다.
  Future<String> getFormattedExchangeRateInfo() async {
    final rate = await getUsdToKrwRate();
    if (rate != null) {
      final formattedRate = NumberFormat.currency(
        locale: 'ko_KR',
        symbol: '₩',
        decimalDigits: 0,
      ).format(rate);
      return formattedRate;
    }
    return '';
  }

  /// 언어별 환율 정보를 포맷팅하여 반환합니다.
  Future<String> getFormattedExchangeRateInfoForLocale(String locale) async {
    await _fetchAllRatesIfNeeded();
    // 캐시 키 (locale 기준)
    final key = 'fx:fmt:$locale';
    final cached = _fmtCache.get(key);
    if (cached != null) return cached;

    String result = '';
    switch (locale) {
      case 'ko':
        final rate = _usdToKrwRate ?? DEFAULT_USD_TO_KRW_RATE;
        result = NumberFormat.currency(
          locale: 'ko_KR',
          symbol: '₩',
          decimalDigits: 0,
        ).format(rate);
        break;
      case 'ja':
        final rate = _usdToJpyRate ?? DEFAULT_USD_TO_JPY_RATE;
        result = NumberFormat.currency(
          locale: 'ja_JP',
          symbol: '¥',
          decimalDigits: 0,
        ).format(rate);
        break;
      case 'zh':
        final rate = _usdToCnyRate ?? DEFAULT_USD_TO_CNY_RATE;
        result = NumberFormat.currency(
          locale: 'zh_CN',
          symbol: '¥',
          decimalDigits: 2,
        ).format(rate);
        break;
      default:
        result = '';
        break;
    }

    // 대략적인 사이즈(문자 길이)로 캐시 저장
    _fmtCache.set(key, result, size: result.length);
    return result;
  }

  /// USD 금액을 KRW로 변환하여 포맷팅된 문자열로 반환합니다.
  Future<String> getFormattedKrwAmount(double usdAmount) async {
    final krwAmount = await convertUsdToKrw(usdAmount);
    if (krwAmount != null) {
      final formattedAmount = NumberFormat.currency(
        locale: 'ko_KR',
        symbol: '₩',
        decimalDigits: 0,
      ).format(krwAmount);
      return '($formattedAmount)';
    }
    return '';
  }

  /// USD 금액을 지정된 언어의 기본 통화로 변환하여 포맷팅된 문자열로 반환합니다.
  Future<String> getFormattedAmountForLocale(
      double usdAmount, String locale) async {
    String targetCurrency;
    String localeCode;
    String symbol;
    int decimalDigits;

    switch (locale) {
      case 'ko':
        targetCurrency = 'KRW';
        localeCode = 'ko_KR';
        symbol = '₩';
        decimalDigits = 0;
        break;
      case 'ja':
        targetCurrency = 'JPY';
        localeCode = 'ja_JP';
        symbol = '¥';
        decimalDigits = 0;
        break;
      case 'zh':
        targetCurrency = 'CNY';
        localeCode = 'zh_CN';
        symbol = '¥';
        decimalDigits = 2;
        break;
      default:
        return '\$$usdAmount';
    }

    final convertedAmount = await convertUsdToTarget(usdAmount, targetCurrency);
    if (convertedAmount != null) {
      final formattedAmount = NumberFormat.currency(
        locale: localeCode,
        symbol: symbol,
        decimalDigits: decimalDigits,
      ).format(convertedAmount);
      return '($formattedAmount)';
    }
    return '';
  }
}
