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

import 'package:archive/archive.dart';
import 'package:crypto/crypto.dart';
import 'package:flutter/services.dart';
import 'package:http/http.dart' as http;
import 'package:path/path.dart' as p;

import '../game/runtime_options.dart';
import 'game_package.dart';
import 'game_package_manifest.dart';
import 'package_verifier.dart';
import 'stable_package_store.dart';

abstract interface class GamePackageRepository {
  Future<GamePackage> load(String gameId);
}

class AssetGamePackageRepository implements GamePackageRepository {
  const AssetGamePackageRepository({
    this.basePath = 'assets/games',
    this.runtimeOptions = const RuntimeOptions(),
  });

  final String basePath;
  final RuntimeOptions runtimeOptions;

  @override
  Future<GamePackage> load(String gameId) async {
    final root = '$basePath/$gameId';
    final source = await rootBundle.loadString('$root/manifest.json');
    return GamePackage.asset(
      rootPath: root,
      manifest: GamePackageManifest.fromJsonString(source),
      runtimeLuaRoot: runtimeOptions.runtimeLuaRoot,
    );
  }
}

class FileGamePackageRepository implements GamePackageRepository {
  const FileGamePackageRepository({
    required this.baseDirectory,
    this.runtimeOptions = const RuntimeOptions(),
  });

  final String baseDirectory;
  final RuntimeOptions runtimeOptions;

  @override
  Future<GamePackage> load(String gameId) async {
    final root = Directory(p.join(baseDirectory, gameId));
    final manifestFile = File(p.join(root.path, 'manifest.json'));
    if (!manifestFile.existsSync()) {
      throw FileSystemException(
        'Game package manifest not found',
        manifestFile.path,
      );
    }
    return GamePackage.file(
      rootPath: root.path,
      manifest: GamePackageManifest.fromJsonString(
        await manifestFile.readAsString(),
      ),
      runtimeLuaRoot: runtimeOptions.runtimeLuaRoot,
    );
  }
}

class RemoteGamePackageRepository implements GamePackageRepository {
  RemoteGamePackageRepository({
    required this.baseUri,
    this.runtimeApiVersion = 1,
    this.runtimeOptions = const RuntimeOptions(),
    GamePackageRepository? fallback,
    StablePackageStore? store,
    http.Client? client,
  }) : fallback =
           fallback ??
           AssetGamePackageRepository(runtimeOptions: runtimeOptions),
       store = store ?? StablePackageStore(runtimeOptions: runtimeOptions),
       _client = client;

  final Uri baseUri;
  final int runtimeApiVersion;
  final RuntimeOptions runtimeOptions;
  final GamePackageRepository fallback;
  final StablePackageStore store;
  final http.Client? _client;

  @override
  Future<GamePackage> load(String gameId) async {
    final verifier = PackageVerifier(runtimeApiVersion: runtimeApiVersion);
    final client = _client ?? http.Client();
    final shouldCloseClient = _client == null;

    try {
      final package = await _loadRemoteCandidate(client, gameId);
      await verifier.verify(package);
      return package;
    } catch (_) {
      final stable = await store.stablePackage(gameId);
      if (stable != null) {
        try {
          await verifier.verify(stable);
          return stable;
        } catch (_) {
          final previous = await store.previousStablePackage(gameId);
          if (previous != null) {
            try {
              await verifier.verify(previous);
              return previous;
            } catch (_) {
              // Fall through to bundled fallback.
            }
          }
        }
      }
      return fallback.load(gameId);
    } finally {
      if (shouldCloseClient) {
        client.close();
      }
    }
  }

  Future<GamePackage> _loadRemoteCandidate(
    http.Client client,
    String gameId,
  ) async {
    final remoteManifest = await _fetchRemoteManifest(client, gameId);
    if (remoteManifest.gameId != gameId) {
      throw const FormatException('Remote manifest gameId mismatch');
    }
    remoteManifest.compatibility.verify(
      runtimeApiVersion: runtimeApiVersion,
      runtimeOptions: runtimeOptions,
    );

    final packageRoot = await _downloadAndExtract(
      client,
      gameId,
      remoteManifest,
    );
    final manifestFile = File(p.join(packageRoot.path, 'manifest.json'));
    final packageManifest = GamePackageManifest.fromJsonString(
      await manifestFile.readAsString(),
    );
    if (packageManifest.gameId != gameId) {
      throw const FormatException('Package manifest gameId mismatch');
    }
    if (packageManifest.version != remoteManifest.version) {
      throw const FormatException('Package manifest version mismatch');
    }
    return GamePackage.file(
      rootPath: packageRoot.path,
      manifest: packageManifest,
      runtimeLuaRoot: runtimeOptions.runtimeLuaRoot,
    );
  }

  Future<RemotePackageManifest> _fetchRemoteManifest(
    http.Client client,
    String gameId,
  ) async {
    final uri = _remoteManifestUri(gameId);
    final response = await client.get(uri);
    if (response.statusCode != 200) {
      throw HttpException(
        'Remote manifest failed: ${response.statusCode}',
        uri: uri,
      );
    }
    return RemotePackageManifest.fromMap(
      jsonDecode(response.body) as Map<String, Object?>,
    );
  }

  Uri _remoteManifestUri(String gameId) {
    final uri = baseUri.resolve('$gameId/remote_manifest.json');
    final query = Map<String, String>.from(uri.queryParameters)
      ..addAll({
        'runtimeApiVersion': runtimeApiVersion.toString(),
        'runtimeVersion': runtimeOptions.runtimeVersion,
        'hostBuild': runtimeOptions.hostBuild.toString(),
        'platform': _platformName(runtimeOptions.platform),
        'channel': runtimeOptions.channel,
      });
    return uri.replace(queryParameters: query);
  }

  Future<Directory> _downloadAndExtract(
    http.Client client,
    String gameId,
    RemotePackageManifest manifest,
  ) async {
    final packageBytes = await _downloadPackage(client, manifest.packageUrl);
    _verifySha256(packageBytes, manifest.sha256);

    final packageRoot = await store.versionDirectory(gameId, manifest.version);
    if (packageRoot.existsSync()) {
      packageRoot.deleteSync(recursive: true);
    }
    packageRoot.createSync(recursive: true);

    final archive = ZipDecoder().decodeBytes(packageBytes);
    for (final file in archive.files) {
      final targetPath = p.normalize(p.join(packageRoot.path, file.name));
      if (!p.isWithin(packageRoot.path, targetPath) &&
          targetPath != packageRoot.path) {
        throw const FormatException('Unsafe zip entry path');
      }
      if (file.isFile) {
        File(targetPath)
          ..createSync(recursive: true)
          ..writeAsBytesSync(file.content as List<int>);
      } else {
        Directory(targetPath).createSync(recursive: true);
      }
    }
    return packageRoot;
  }

  Future<List<int>> _downloadPackage(http.Client client, Uri uri) async {
    final response = await client.get(uri);
    if (response.statusCode != 200) {
      throw HttpException(
        'Package download failed: ${response.statusCode}',
        uri: uri,
      );
    }
    return response.bodyBytes;
  }

  void _verifySha256(List<int> bytes, String expected) {
    final actual = sha256.convert(bytes).toString();
    if (actual != expected) {
      throw const FormatException('Package sha256 mismatch');
    }
  }
}

class RemotePackageManifest {
  const RemotePackageManifest({
    required this.gameId,
    required this.version,
    required this.packageUrl,
    required this.sha256,
    this.compatibility = const RemotePackageCompatibility(),
  });

  final String gameId;
  final String version;
  final Uri packageUrl;
  final String sha256;
  final RemotePackageCompatibility compatibility;

  static RemotePackageManifest fromMap(Map<String, Object?> map) {
    return RemotePackageManifest(
      gameId: _string(map, 'gameId'),
      version: _string(map, 'version'),
      packageUrl: Uri.parse(_string(map, 'packageUrl')),
      sha256: _string(map, 'sha256'),
      compatibility: RemotePackageCompatibility.fromMap(map['compat']),
    );
  }

  static String _string(Map<String, Object?> map, String key) {
    final value = map[key];
    if (value is String && value.isNotEmpty) {
      return value;
    }
    throw FormatException('remote_manifest.$key must be a non-empty string');
  }
}

class RemotePackageCompatibility {
  const RemotePackageCompatibility({
    this.runtimeApiVersion,
    this.minRuntimeVersion,
    this.maxRuntimeVersion,
    this.minHostBuild,
    this.maxHostBuild,
    this.platforms = const [],
    this.channels = const [],
  });

  final int? runtimeApiVersion;
  final String? minRuntimeVersion;
  final String? maxRuntimeVersion;
  final int? minHostBuild;
  final int? maxHostBuild;
  final List<String> platforms;
  final List<String> channels;

  static RemotePackageCompatibility fromMap(Object? value) {
    if (value == null) {
      return const RemotePackageCompatibility();
    }
    if (value is! Map) {
      throw const FormatException('remote_manifest.compat must be a map');
    }
    final map = Map<String, Object?>.from(value);
    return RemotePackageCompatibility(
      runtimeApiVersion: _optionalInt(map, 'runtimeApiVersion'),
      minRuntimeVersion: _optionalString(map, 'minRuntimeVersion'),
      maxRuntimeVersion: _optionalString(map, 'maxRuntimeVersion'),
      minHostBuild: _optionalInt(map, 'minHostBuild'),
      maxHostBuild: _optionalInt(map, 'maxHostBuild'),
      platforms: _optionalStringList(map, 'platforms'),
      channels: _optionalStringList(map, 'channels'),
    );
  }

  void verify({
    required int runtimeApiVersion,
    required RuntimeOptions runtimeOptions,
  }) {
    if (this.runtimeApiVersion != null &&
        this.runtimeApiVersion != runtimeApiVersion) {
      throw const FormatException('Remote package runtimeApiVersion mismatch');
    }
    if (minRuntimeVersion != null &&
        _compareVersions(runtimeOptions.runtimeVersion, minRuntimeVersion!) <
            0) {
      throw const FormatException('Remote package requires newer runtime');
    }
    if (maxRuntimeVersion != null &&
        _compareVersions(runtimeOptions.runtimeVersion, maxRuntimeVersion!) >
            0) {
      throw const FormatException(
        'Remote package does not support this runtime',
      );
    }
    if (minHostBuild != null && runtimeOptions.hostBuild < minHostBuild!) {
      throw const FormatException('Remote package requires newer host build');
    }
    if (maxHostBuild != null && runtimeOptions.hostBuild > maxHostBuild!) {
      throw const FormatException(
        'Remote package does not support this host build',
      );
    }
    final platform = _platformName(runtimeOptions.platform);
    if (platforms.isNotEmpty && !platforms.contains(platform)) {
      throw const FormatException(
        'Remote package does not support this platform',
      );
    }
    if (channels.isNotEmpty && !channels.contains(runtimeOptions.channel)) {
      throw const FormatException(
        'Remote package does not support this channel',
      );
    }
  }

  static String? _optionalString(Map<String, Object?> map, String key) {
    final value = map[key];
    if (value == null) {
      return null;
    }
    if (value is String && value.isNotEmpty) {
      return value;
    }
    throw FormatException('remote_manifest.compat.$key must be a string');
  }

  static int? _optionalInt(Map<String, Object?> map, String key) {
    final value = map[key];
    if (value == null) {
      return null;
    }
    if (value is num) {
      return value.toInt();
    }
    throw FormatException('remote_manifest.compat.$key must be an integer');
  }

  static List<String> _optionalStringList(
    Map<String, Object?> map,
    String key,
  ) {
    final value = map[key];
    if (value == null) {
      return const [];
    }
    if (value is! List) {
      throw FormatException(
        'remote_manifest.compat.$key must be a string list',
      );
    }
    return value
        .map((item) {
          if (item is String && item.isNotEmpty) {
            return item;
          }
          throw FormatException(
            'remote_manifest.compat.$key must be a string list',
          );
        })
        .toList(growable: false);
  }
}

String _platformName(String? explicitPlatform) {
  if (explicitPlatform != null && explicitPlatform.isNotEmpty) {
    return explicitPlatform;
  }
  if (Platform.isAndroid) {
    return 'android';
  }
  if (Platform.isIOS) {
    return 'ios';
  }
  if (Platform.isMacOS) {
    return 'macos';
  }
  if (Platform.isWindows) {
    return 'windows';
  }
  if (Platform.isLinux) {
    return 'linux';
  }
  if (Platform.isFuchsia) {
    return 'fuchsia';
  }
  return 'unknown';
}

int _compareVersions(String left, String right) {
  final leftParts = _versionParts(left);
  final rightParts = _versionParts(right);
  final count = leftParts.length > rightParts.length
      ? leftParts.length
      : rightParts.length;
  for (var index = 0; index < count; index++) {
    final leftValue = index < leftParts.length ? leftParts[index] : 0;
    final rightValue = index < rightParts.length ? rightParts[index] : 0;
    if (leftValue != rightValue) {
      return leftValue.compareTo(rightValue);
    }
  }
  return 0;
}

List<int> _versionParts(String value) {
  final normalized = value.split('-').first;
  return normalized
      .split('.')
      .map((part) {
        final digits = RegExp(r'^\d+').firstMatch(part)?.group(0);
        return int.tryParse(digits ?? '') ?? 0;
      })
      .toList(growable: false);
}