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

import 'package:yaml/yaml.dart';

final RegExp _validBrandName = RegExp(r'^[a-z][a-z0-9_]*$');
const List<String> _defaultPreferredOrientations = <String>[
  'portraitUp',
  'portraitDown',
];
final Directory _repoRootDir = File.fromUri(Platform.script).parent.parent;
final String _currentDartExecutable = Platform.resolvedExecutable;
final String _flutterExecutable = _resolveFlutterExecutable();
final String _dartExecutable = _resolveDartExecutable();

Future<void> main(List<String> args) async {
  Directory.current = _repoRootDir.path;

  if (args.isEmpty) {
    print('\x1B[31m用法：dart run tool/generate_app.dart <品牌名>\x1B[0m');
    print('\x1B[33m示例：dart run tool/generate_app.dart aixue\x1B[0m');
    exit(1);
  }

  final brand = args.first;
  if (!_validBrandName.hasMatch(brand)) {
    print('\x1B[31m[错误] 品牌名 "$brand" 格式无效，仅允许小写字母、数字和下划线。\x1B[0m');
    exit(1);
  }

  final configFile = File('flavors/$brand.yaml');
  if (!configFile.existsSync()) {
    print('\x1B[31m[错误] 未找到配置文件：${configFile.path}\x1B[0m');
    exit(1);
  }

  print('\x1B[34m[信息] 正在为品牌生成应用：$brand...\x1B[0m');
  print('\x1B[34m[信息] Flutter 命令：$_flutterExecutable\x1B[0m');
  print('\x1B[34m[信息] Dart 命令：$_dartExecutable\x1B[0m');
  final yamlString = await configFile.readAsString();
  final config = loadYaml(yamlString) as YamlMap;

  final appName = config['app_name'] as String;
  final applicationId = config['application_id'] as String;
  final appKey = config['app_key'] as String;
  final defaultUrl = config['default_url'] as String?;
  final bootstrapConfigUrl = config['bootstrap_config_url'] as String?;
  final upgradeConfigUrl = config['upgrade_config_url'] as String?;
  final preferredOrientations = _readPreferredOrientations(
    config['preferred_orientations'],
  );

  final theme = config['theme'] as YamlMap;
  final accentColor = theme['accent_color'] as String;
  final bgColor = theme['bg_color'] as String;
  final textColor = theme['text_color'] as String;
  final mutedTextColor = theme['muted_text_color'] as String;

  final appDir = 'apps/$brand';

  await _createFlutterApp(brand, appDir, applicationId);
  await _addCoreDependency(appDir);
  await _rewriteAndroidPackageId(appDir, applicationId);
  await _overwriteMainActivity(appDir, applicationId);
  await _overwriteManifestLabel(appDir, appName);
  await _generateDartEntrypoint(
    appDir: appDir,
    appName: appName,
    appKey: appKey,
    accentColor: accentColor,
    backgroundColor: bgColor,
    textColor: textColor,
    mutedTextColor: mutedTextColor,
  );
  await _generateBootstrapConfig(
    appDir: appDir,
    defaultUrl: defaultUrl,
    preferredOrientations: preferredOrientations,
    bootstrapConfigUrl: bootstrapConfigUrl,
    upgradeConfigUrl: upgradeConfigUrl,
  );
  await _generateBrandingAssets(brand, appDir, config);
  await _registerFlutterAssets(appDir);
  await _configureSigning(appDir, config);

  print('\x1B[32m✔ 应用 $brand 已生成到 $appDir！\x1B[0m');
  print('\x1B[34m构建应用请执行：\x1B[0m');
  print('  cd $appDir');
  print('  ${_buildApkCommandForCurrentPlatform()}');
}

String _resolveFlutterExecutable() {
  final candidates = <String>[
    ..._toolCandidatesFromFlutterRoot(_flutterToolRelativePaths),
    ..._toolCandidatesFromRepo(_flutterToolRelativePaths),
    ..._flutterCandidatesFromCurrentDart(),
    'flutter',
  ];

  return _firstAvailableExecutable(candidates, fallback: 'flutter');
}

String _resolveDartExecutable() {
  final candidates = <String>[
    ..._toolCandidatesFromFlutterRoot(_dartToolRelativePaths),
    ..._toolCandidatesFromRepo(_dartToolRelativePaths),
    _currentDartExecutable,
    'dart',
  ];

  return _firstAvailableExecutable(candidates, fallback: 'dart');
}

List<String> _flutterCandidatesFromCurrentDart() {
  final dartExecutable = File(_currentDartExecutable);
  final dartBinDir = dartExecutable.parent;
  final dartSdkDir = dartBinDir.parent;
  final cacheDir = dartSdkDir.parent;
  final flutterBinDir = cacheDir.parent;

  if (_basename(dartSdkDir.path) != 'dart-sdk' ||
      _basename(cacheDir.path) != 'cache' ||
      !_isSameDirectoryName(flutterBinDir.path, 'bin')) {
    return <String>[];
  }

  final flutterBat = File.fromUri(flutterBinDir.uri.resolve('flutter.bat'));
  final flutterShell = File.fromUri(flutterBinDir.uri.resolve('flutter'));

  return <String>[
    if (flutterBat.existsSync()) flutterBat.path,
    if (flutterShell.existsSync()) flutterShell.path,
  ];
}

List<String> get _flutterToolRelativePaths => Platform.isWindows
    ? <String>['bin/flutter.bat', 'bin/flutter']
    : <String>['bin/flutter', 'bin/flutter.bat'];

List<String> get _dartToolRelativePaths => Platform.isWindows
    ? <String>[
        'bin/dart.bat',
        'bin/cache/dart-sdk/bin/dart.exe',
        'bin/dart',
        'bin/cache/dart-sdk/bin/dart',
      ]
    : <String>['bin/dart', 'bin/cache/dart-sdk/bin/dart'];

List<String> _toolCandidatesFromFlutterRoot(List<String> relativePaths) {
  final flutterRoot = Platform.environment['FLUTTER_ROOT'];
  if (flutterRoot == null || flutterRoot.isEmpty) {
    return <String>[];
  }

  return <String>[
    for (final relativePath in relativePaths)
      if (_fileExists(flutterRoot, relativePath))
        _joinPath(flutterRoot, relativePath),
  ];
}

List<String> _toolCandidatesFromRepo(List<String> relativePaths) {
  return <String>[
    for (final relativePath in relativePaths)
      if (_repoFile(relativePath).existsSync()) _repoFile(relativePath).path,
  ];
}

String _firstAvailableExecutable(
  List<String> candidates, {
  required String fallback,
}) {
  for (final candidate in candidates) {
    if (candidate == fallback || File(candidate).existsSync()) {
      return candidate;
    }
  }
  return fallback;
}

bool _fileExists(String? basePath, String childPath) {
  if (basePath == null || basePath.isEmpty) {
    return false;
  }
  return File(_joinPath(basePath, childPath)).existsSync();
}

String _joinPath(String basePath, String childPath) {
  final normalizedBase = basePath.replaceAll('\\', '/');
  final normalizedChild = childPath.replaceAll('\\', '/');
  return File.fromUri(
    Directory(normalizedBase).uri.resolve(normalizedChild),
  ).path;
}

File _repoFile(String relativePath) {
  return File.fromUri(_repoRootDir.uri.resolve(relativePath));
}

String _basename(String path) {
  final normalized = path
      .replaceAll('\\', '/')
      .replaceFirst(RegExp(r'/+$'), '');
  final segments = normalized.split('/');
  return segments.isEmpty ? normalized : segments.last;
}

bool _isSameDirectoryName(String path, String name) {
  return _basename(path).toLowerCase() == name.toLowerCase();
}

String _buildApkCommandForCurrentPlatform() {
  final fvmFlutter = _repoFile(
    Platform.isWindows
        ? '.fvm/flutter_sdk/bin/flutter.bat'
        : '.fvm/flutter_sdk/bin/flutter',
  );

  if (fvmFlutter.existsSync()) {
    final commandPath = Platform.isWindows
        ? '../../.fvm/flutter_sdk/bin/flutter.bat'
        : '../../.fvm/flutter_sdk/bin/flutter';
    return '$commandPath build apk';
  }

  return 'flutter build apk';
}

Future<ProcessResult> _runProcess(
  String executable,
  List<String> arguments, {
  String? workingDirectory,
}) async {
  try {
    return await Process.run(
      executable,
      arguments,
      workingDirectory: workingDirectory,
      runInShell:
          Platform.isWindows && executable.toLowerCase().endsWith('.bat'),
    );
  } on ProcessException catch (error) {
    print('\x1B[31m[错误] 外部命令启动失败：$executable\x1B[0m');
    print('\x1B[33m命令参数：${arguments.join(' ')}\x1B[0m');
    print('\x1B[33m系统信息：${error.message}\x1B[0m');

    if (executable == _flutterExecutable || executable == 'flutter') {
      print('\x1B[33m建议先执行：\x1B[0m');
      if (Platform.isWindows) {
        print(
          '  \$env:PATH = "${_repoFile('.fvm/flutter_sdk/bin').path};\$env:PATH"',
        );
      } else {
        print(
          '  export PATH="${_repoFile('.fvm/flutter_sdk/bin').path}:\$PATH"',
        );
      }
    }

    exit(1);
  }
}

List<String> _readPreferredOrientations(Object? raw) {
  if (raw is! YamlList && raw is! List) {
    return _defaultPreferredOrientations;
  }

  final values = <String>[];
  for (final item in (raw as List)) {
    final normalized = _normalizeOrientation(item?.toString());
    if (normalized != null && !values.contains(normalized)) {
      values.add(normalized);
    }
  }
  return values.isEmpty ? _defaultPreferredOrientations : values;
}

String? _normalizeOrientation(String? raw) {
  final value = raw?.trim();
  if (value == null || value.isEmpty) {
    return null;
  }
  return switch (value) {
    'portraitUp' || 'DeviceOrientation.portraitUp' => 'portraitUp',
    'portraitDown' || 'DeviceOrientation.portraitDown' => 'portraitDown',
    'landscapeLeft' || 'DeviceOrientation.landscapeLeft' => 'landscapeLeft',
    'landscapeRight' || 'DeviceOrientation.landscapeRight' => 'landscapeRight',
    _ => null,
  };
}

Future<void> _createFlutterApp(
  String brand,
  String appDir,
  String applicationId,
) async {
  print('\x1B[34m[信息] 正在执行 flutter create...\x1B[0m');
  final dir = Directory(appDir);
  if (dir.existsSync()) {
    print('\x1B[33m[警告] 目录 $appDir 已存在，正在清理...\x1B[0m');
    dir.deleteSync(recursive: true);
  }

  final segments = applicationId.split('.');
  final org = segments.sublist(0, segments.length - 1).join('.');
  final result = await _runProcess(_flutterExecutable, <String>[
    'create',
    '--org',
    org,
    '--project-name',
    brand,
    '--platforms',
    'android',
    '--android-language',
    'java',
    appDir,
  ]);

  if (result.exitCode != 0) {
    print('\x1B[31m[错误] flutter create 执行失败：\n${result.stderr}\x1B[0m');
    exit(1);
  }
}

Future<void> _addCoreDependency(String appDir) async {
  print('\x1B[34m[信息] 正在添加 web_shell_core 依赖...\x1B[0m');
  final result = await _runProcess(_flutterExecutable, <String>[
    'pub',
    'add',
    'web_shell_core',
    '--path',
    '../../packages/web_shell_core',
  ], workingDirectory: appDir);

  if (result.exitCode != 0) {
    print('\x1B[31m[错误] 添加依赖失败：\n${result.stderr}\x1B[0m');
    exit(1);
  }
}

Future<void> _rewriteAndroidPackageId(
  String appDir,
  String applicationId,
) async {
  print('\x1B[34m[信息] 正在校正 Android applicationId / namespace...\x1B[0m');
  final gradleFile = File('$appDir/android/app/build.gradle.kts');
  if (!gradleFile.existsSync()) {
    print('\x1B[31m[错误] 未找到 ${gradleFile.path}\x1B[0m');
    exit(1);
  }

  var content = await gradleFile.readAsString();
  content = content.replaceFirst(
    RegExp(r'namespace\s*=\s*"[^"]+"'),
    'namespace = "$applicationId"',
  );
  content = content.replaceFirst(
    RegExp(r'applicationId\s*=\s*"[^"]+"'),
    'applicationId = "$applicationId"',
  );
  await gradleFile.writeAsString(content);

  final javaDir = Directory('$appDir/android/app/src/main/java');
  if (javaDir.existsSync()) {
    javaDir.deleteSync(recursive: true);
  }
  await javaDir.create(recursive: true);
}

Future<void> _overwriteMainActivity(String appDir, String applicationId) async {
  print('\x1B[34m[信息] 正在注入 CoreShellActivity 继承关系...\x1B[0m');
  final mainActivityPath =
      '$appDir/android/app/src/main/java/${applicationId.replaceAll('.', '/')}/MainActivity.java';
  final javaContent =
      '''
package $applicationId;

import com.yuanxuan.webshell.core.web_shell_core.CoreShellActivity;

public class MainActivity extends CoreShellActivity {
}
''';

  final mainActivityFile = File(mainActivityPath);
  await mainActivityFile.parent.create(recursive: true);
  await mainActivityFile.writeAsString(javaContent);
}

Future<void> _overwriteManifestLabel(String appDir, String appName) async {
  print('\x1B[34m[信息] 正在更新 AndroidManifest.xml 应用名...\x1B[0m');
  final manifestFile = File('$appDir/android/app/src/main/AndroidManifest.xml');
  var content = await manifestFile.readAsString();
  content = content.replaceAll(
    RegExp(r'android:label="[^"]*"'),
    'android:label="$appName"',
  );
  await manifestFile.writeAsString(content);
}

Future<void> _generateDartEntrypoint({
  required String appDir,
  required String appName,
  required String appKey,
  required String accentColor,
  required String backgroundColor,
  required String textColor,
  required String mutedTextColor,
}) async {
  print('\x1B[34m[信息] 正在生成 lib/main.dart...\x1B[0m');
  final mainFile = File('$appDir/lib/main.dart');

  final dartContent =
      '''
import 'package:flutter/material.dart';
import 'package:web_shell_core/web_shell_core.dart';

void main() {
  runShellApp(
    ShellEnvironment(
      appName: '$appName',
      appKey: '$appKey',
      accentColor: const Color($accentColor),
      backgroundColor: const Color($backgroundColor),
      textColor: const Color($textColor),
      mutedTextColor: const Color($mutedTextColor),
      splashImage: const AssetImage('assets/branding/splash.png'),
      bootstrapConfigAsset: 'assets/config/bootstrap.json',
    ),
  );
}
''';

  await mainFile.writeAsString(dartContent);

  final defaultTestFile = File('$appDir/test/widget_test.dart');
  if (defaultTestFile.existsSync()) {
    await defaultTestFile.delete();
  }
}

Future<void> _generateBootstrapConfig({
  required String appDir,
  required String? defaultUrl,
  required List<String> preferredOrientations,
  String? bootstrapConfigUrl,
  String? upgradeConfigUrl,
}) async {
  print('\x1B[34m[信息] 正在生成默认启动配置 assets/config/bootstrap.json...\x1B[0m');
  final file = File('$appDir/assets/config/bootstrap.json');
  await file.parent.create(recursive: true);

  final data = <String, Object?>{
    if (defaultUrl != null && defaultUrl.trim().isNotEmpty)
      'initialUrl': defaultUrl.trim(),
    'preferredOrientations': preferredOrientations,
    if (bootstrapConfigUrl != null && bootstrapConfigUrl.trim().isNotEmpty)
      'bootstrapConfigUrl': bootstrapConfigUrl.trim(),
    if (upgradeConfigUrl != null && upgradeConfigUrl.trim().isNotEmpty)
      'upgradeConfigUrl': upgradeConfigUrl.trim(),
  };

  final content = const JsonEncoder.withIndent('  ').convert(data);
  await file.writeAsString('$content\n');
}

Future<void> _generateBrandingAssets(
  String brand,
  String appDir,
  YamlMap config,
) async {
  print('\x1B[34m[信息] 正在配置图标与启动页...\x1B[0m');
  if (config['branding'] == null) {
    print('\x1B[33m[警告] 配置中未找到 branding 段，跳过资源生成。\x1B[0m');
    return;
  }

  final branding = config['branding'] as YamlMap;
  final brandSourceDir = Directory('flavors/$brand');
  final brandTargetDir = Directory('$appDir/assets/branding');
  if (!brandSourceDir.existsSync()) {
    print('\x1B[31m[错误] 品牌资源目录不存在：${brandSourceDir.path}\x1B[0m');
    exit(1);
  }

  await brandTargetDir.create(recursive: true);
  for (final entity in brandSourceDir.listSync(recursive: true)) {
    if (entity is! File) {
      continue;
    }
    final relativePath = entity.path.substring(brandSourceDir.path.length + 1);
    final targetFile = File('${brandTargetDir.path}/$relativePath');
    await targetFile.parent.create(recursive: true);
    await entity.copy(targetFile.path);
  }

  print('\x1B[32m✔ 品牌资源已复制到 ${brandTargetDir.path}\x1B[0m');

  print('\x1B[34m[信息] 正在添加资源生成器依赖...\x1B[0m');
  final addDevDepsResult = await _runProcess(_flutterExecutable, <String>[
    'pub',
    'add',
    '--dev',
    'flutter_launcher_icons',
    'flutter_native_splash',
  ], workingDirectory: appDir);
  if (addDevDepsResult.exitCode != 0) {
    print('\x1B[31m[错误] 添加资源生成器依赖失败：\n${addDevDepsResult.stderr}\x1B[0m');
    exit(1);
  }

  await _runProcess(_flutterExecutable, <String>[
    'pub',
    'get',
  ], workingDirectory: appDir);

  final iconPath = 'assets/branding/${branding['icon']}';
  final iconBackground = branding['icon_background'] as String;
  final iconsYaml =
      '''
flutter_launcher_icons:
  android: true
  image_path: "$iconPath"
  adaptive_icon_background: "$iconBackground"
  adaptive_icon_foreground: "$iconPath"
''';
  await File('$appDir/flutter_launcher_icons.yaml').writeAsString(iconsYaml);

  final splashPath = 'assets/branding/${branding['splash']}';
  final splashColor = branding['splash_color'] as String;
  final splashYaml =
      '''
flutter_native_splash:
  color: "$splashColor"
  image: "$splashPath"
  android_12:
    image: "$splashPath"
    icon_background_color: "$splashColor"
''';
  await File('$appDir/flutter_native_splash.yaml').writeAsString(splashYaml);

  print('\x1B[34m[信息] 正在生成应用图标...\x1B[0m');
  final iconsResult = await _runProcess(_dartExecutable, <String>[
    'run',
    'flutter_launcher_icons',
    '-f',
    'flutter_launcher_icons.yaml',
  ], workingDirectory: appDir);
  if (iconsResult.exitCode != 0) {
    print('\x1B[31m[错误] 图标生成失败：\n${iconsResult.stderr}\x1B[0m');
    print('\x1B[33mstdout:\n${iconsResult.stdout}\x1B[0m');
    exit(1);
  }

  print('\x1B[34m[信息] 正在生成启动页...\x1B[0m');
  final splashResult = await _runProcess(_dartExecutable, <String>[
    'run',
    'flutter_native_splash:create',
    '--path=flutter_native_splash.yaml',
  ], workingDirectory: appDir);
  if (splashResult.exitCode != 0) {
    print('\x1B[31m[错误] 启动页生成失败：\n${splashResult.stderr}\x1B[0m');
    print('\x1B[33mstdout:\n${splashResult.stdout}\x1B[0m');
    exit(1);
  }

  print('\x1B[34m[信息] 正在移除资源生成器依赖...\x1B[0m');
  await _runProcess(_flutterExecutable, <String>[
    'pub',
    'remove',
    'flutter_launcher_icons',
    'flutter_native_splash',
  ], workingDirectory: appDir);
}

Future<void> _registerFlutterAssets(String appDir) async {
  print('\x1B[34m[信息] 正在注册 Flutter assets...\x1B[0m');
  final pubspecFile = File('$appDir/pubspec.yaml');
  var content = await pubspecFile.readAsString();

  if (!RegExp(r'^\s+assets:\s*$', multiLine: true).hasMatch(content)) {
    content = content.replaceFirst(
      RegExp(r'^flutter:\s*\n', multiLine: true),
      'flutter:\n  assets:\n    - assets/branding/\n    - assets/config/\n',
    );
  } else {
    if (!content.contains('    - assets/branding/')) {
      content = content.replaceFirst(
        RegExp(r'^\s+assets:\s*\n', multiLine: true),
        '  assets:\n    - assets/branding/\n',
      );
    }
    if (!content.contains('    - assets/config/')) {
      content = content.replaceFirst(
        '    - assets/branding/\n',
        '    - assets/branding/\n    - assets/config/\n',
      );
    }
  }

  await pubspecFile.writeAsString(content);
}

Future<void> _configureSigning(String appDir, YamlMap config) async {
  print('\x1B[34m[信息] 正在配置应用签名...\x1B[0m');
  final signing = config['signing'] as YamlMap?;
  final keyAlias = signing?['key_alias'] as String? ?? 'my-key-alias';
  final keyPassword = signing?['key_password'] as String? ?? '123456';
  final storePassword = signing?['store_password'] as String? ?? '123456';
  final storeFile =
      signing?['store_file'] as String? ?? '../../../tool/key.jks';

  final keyPropsContent =
      '''
storePassword=$storePassword
keyPassword=$keyPassword
keyAlias=$keyAlias
storeFile=$storeFile
''';
  await File('$appDir/android/key.properties').writeAsString(keyPropsContent);

  final gradleFile = File('$appDir/android/app/build.gradle.kts');
  if (!gradleFile.existsSync()) {
    print('\x1B[33m[警告] 未找到 build.gradle.kts，跳过注入签名配置。\x1B[0m');
    return;
  }

  var content = await gradleFile.readAsString();
  if (!content.contains('val keystoreProperties = Properties()')) {
    content = content.replaceFirst('android {', '''
import java.io.File
import java.util.Properties
import java.io.FileInputStream

val keystoreProperties = Properties()
val keystorePropertiesFile = rootProject.file("key.properties")
if (keystorePropertiesFile.exists()) {
    FileInputStream(keystorePropertiesFile).use { keystoreProperties.load(it) }
}

val defaultReleaseStoreFile = rootProject.file("../../../tool/key.jks")
fun resolveKeystoreFile(rawPath: String?): File {
    val candidate = rawPath?.trim().orEmpty()
    if (candidate.isEmpty()) {
        return defaultReleaseStoreFile
    }

    val expandedHome = if (candidate.startsWith("~/") || candidate == "~") {
        candidate.replaceFirst("~", System.getProperty("user.home"))
    } else {
        candidate
    }

    val normalized = expandedHome.replace('\\\\', File.separatorChar).replace('/', File.separatorChar)
    val storeFile = File(normalized)
    if (storeFile.isAbsolute) {
        return storeFile
    }

    val rootRelativeFile = rootProject.file(normalized)
    if (rootRelativeFile.exists()) {
        return rootRelativeFile
    }

    val moduleRelativeFile = project.file(normalized)
    if (moduleRelativeFile.exists()) {
        return moduleRelativeFile
    }

    return rootRelativeFile
}

val releaseStoreFile =
    resolveKeystoreFile(keystoreProperties["storeFile"] as String?)
val releaseKeyAlias = keystoreProperties["keyAlias"] as String? ?: "my-key-alias"
val releaseKeyPassword = keystoreProperties["keyPassword"] as String? ?: "123456"
val releaseStorePassword = keystoreProperties["storePassword"] as String? ?: "123456"

android {
''');
  }

  if (!content.contains('signingConfigs {\n        create("release") {')) {
    const newBuildTypes = '''
    signingConfigs {
        create("release") {
            keyAlias = releaseKeyAlias
            keyPassword = releaseKeyPassword
            storeFile = releaseStoreFile
            storePassword = releaseStorePassword
        }
    }

    buildTypes {
        getByName("release") {
            signingConfig = signingConfigs.getByName("release")
        }
    }
''';
    final buildTypeRegex = RegExp(
      r'\s*buildTypes\s*\{[\s\S]*?signingConfigs\.getByName\("debug"\)\s*\}\s*\}',
    );
    content = content.replaceFirst(buildTypeRegex, '\n$newBuildTypes');
  }

  await gradleFile.writeAsString(content);
}