// Copyright (c) 2022, the Dart project authors. Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.

import 'dart:io';

import 'package:path/path.dart';

import '../logging/logging.dart';

class _AndroidToolsException implements Exception {
  _AndroidToolsException(this.message);
  String message;
  @override
  String toString() => message;
}

class SdkNotFoundException extends _AndroidToolsException {
  SdkNotFoundException(String message) : super(message);
}

class GradleException extends _AndroidToolsException {
  GradleException(String message) : super(message);
}

class AndroidSdkTools {
  static String getAndroidSdkRoot() {
    final envVar = Platform.environment['ANDROID_SDK_ROOT'];
    if (envVar == null) {
      throw SdkNotFoundException('Android SDK not found. Please set '
          'ANDROID_SDK_ROOT environment variable or specify through command '
          'line override.');
    }
    return envVar;
  }

  static Future<String?> _getVersionDir(
      String relative, String sdkRoot, List<int> versionOrder) async {
    final parent = join(sdkRoot, relative);
    for (var version in versionOrder) {
      final dir = Directory(join(parent, 'android-$version'));
      if (await dir.exists()) {
        return dir.path;
      }
    }
    return null;
  }

  static Future<String?> _getFile(String sdkRoot, String relative,
      List<int> versionOrder, String file) async {
    final platform = await _getVersionDir(relative, sdkRoot, versionOrder);
    if (platform == null) return null;
    final filePath = join(platform, file);
    if (await File(filePath).exists()) {
      log.info('Found $filePath');
      return filePath;
    }
    return null;
  }

  static const _gradleCannotFindJars = 'Gradle stub cannot find JAR libraries. '
      'This might be because no APK build has happened yet.';

  static const _leftOverStubWarning = 'If you are seeing this error in '
      '`flutter build` output, it is likely that `jnigen` left some stubs in '
      'the build.gradle file. Please restore that file from your version '
      'control system or manually remove the stub functions named '
      '$_gradleGetClasspathTaskName and / or $_gradleGetSourcesTaskName.';

  static Future<String?> getAndroidJarPath(
          {required String sdkRoot, required List<int> versionOrder}) async =>
      await _getFile(sdkRoot, 'platforms', versionOrder, 'android.jar');

  static const _gradleGetClasspathTaskName = 'getReleaseCompileClasspath';

  static const _gradleGetClasspathStub = '''
// Gradle stub for listing dependencies in jnigen. If found in
// android/build.gradle, please delete the following function.
task $_gradleGetClasspathTaskName(type: Copy) {
  project.afterEvaluate {
    try {
      def app = project(':app')
      def android = app.android
      def cp = [android.getBootClasspath()[0]]
      android.applicationVariants.each { variant ->
        if (variant.name.equals('release')) {
          cp += variant.javaCompile.classpath.getFiles()
        }
      }
      cp.each { println it }
    } catch (Exception e) {
      System.err.println("$_gradleCannotFindJars")
      System.err.println("$_leftOverStubWarning")
      throw e
    }
  }
}
''';

  static const _gradleGetSourcesTaskName = 'getSources';
  // adapted from https://stackoverflow.com/questions/39975780/how-can-i-use-gradle-to-download-dependencies-and-their-source-files-and-place-t/39981143#39981143
  // Although it appears we can use this same code for getting JAR artifacts,
  // there is no JAR equivalent for `org.gradle.language.base.Artifact`.
  // So it appears different methods should be used for JAR artifacts.
  static const _gradleGetSourcesStub = '''
// Gradle stub for fetching source dependencies in jnigen. If found in
// android/build.gradle, please delete the following function.
task $_gradleGetSourcesTaskName(type: Copy) {
  project.afterEvaluate {
    def componentIds = project(':app').configurations.releaseCompileClasspath.incoming
      .resolutionResult.allDependencies.collect { it.selected.id }

    ArtifactResolutionResult result = dependencies.createArtifactResolutionQuery()
      .forComponents(componentIds)
      .withArtifacts(JvmLibrary, SourcesArtifact)
      .execute()

    def sourceArtifacts = []

    result.resolvedComponents.each { ComponentArtifactsResult component ->
      Set<ArtifactResult> sources = component.getArtifacts(SourcesArtifact)
      sources.each { ArtifactResult ar ->
        if (ar instanceof ResolvedArtifactResult) {
          sourceArtifacts << ar.file
        }
      }
    }
    sourceArtifacts.forEach { println it }
  }
  System.err.println("$_leftOverStubWarning")
}
''';

  /// Get release compile classpath used by Gradle for android build.
  ///
  /// This function temporarily overwrites the build.gradle file by a stub with
  /// function to list all dependency paths for release variant.
  /// This function fails if no gradle build is attempted before.
  ///
  /// If current project is not directly buildable by gradle, eg: a plugin,
  /// a relative path to other project can be specified using [androidProject].
  static List<String> getGradleClasspaths(
          {Uri? configRoot, String androidProject = '.'}) =>
      _runGradleStub(
        stubName: _gradleGetClasspathTaskName,
        stubCode: _gradleGetClasspathStub,
        androidProject: androidProject,
        configRoot: configRoot,
      );

  /// Get source paths for all gradle dependencies.
  ///
  /// This function temporarily overwrites the build.gradle file by a stub with
  /// function to list all dependency paths for release variant.
  /// This function fails if no gradle build is attempted before.
  static List<String> getGradleSources(
      {Uri? configRoot, String androidProject = '.'}) {
    return _runGradleStub(
      stubName: _gradleGetSourcesTaskName,
      stubCode: _gradleGetSourcesStub,
      androidProject: androidProject,
      configRoot: configRoot,
    );
  }

  static String _appendStub(String script, String stub) {
    return script.contains(stub) ? script : script + stub;
  }

  static List<String> _runGradleStub({
    required String stubName,
    required String stubCode,
    Uri? configRoot,
    String androidProject = '.',
  }) {
    log.info('trying to obtain gradle dependencies [$stubName]...');
    if (configRoot != null) {
      androidProject = configRoot.resolve(androidProject).toFilePath();
    }
    final android = join(androidProject, 'android');
    final buildGradle = join(android, 'build.gradle');
    final buildGradleOld = join(android, 'build.gradle.old');
    final origBuild = File(buildGradle);
    final script = origBuild.readAsStringSync();
    origBuild.renameSync(buildGradleOld);
    origBuild.createSync();
    log.finer('Writing temporary gradle script with stub "$stubName"...');
    origBuild.writeAsStringSync(_appendStub(script, stubCode));
    log.finer('Running gradle wrapper...');
    final gradleCommand = Platform.isWindows ? '.\\gradlew.bat' : './gradlew';
    ProcessResult procRes;
    try {
      procRes = Process.runSync(gradleCommand, ['-q', stubName],
          workingDirectory: android, runInShell: true);
    } finally {
      log.info('Restoring build scripts');
      origBuild.writeAsStringSync(
        script
            .replaceAll(_gradleGetClasspathStub, "")
            .replaceAll(_gradleGetSourcesStub, ""),
      );
      File(buildGradleOld).deleteSync();
    }
    if (procRes.exitCode != 0) {
      final inAndroidProject =
          (androidProject == '.') ? '' : ' in $androidProject';
      throw GradleException('\n\ngradle exited with status '
          '${procRes.exitCode}\n. This can be because the Android build is not '
          'yet cached. Please run `flutter build apk`$inAndroidProject and try '
          'again\n');
    }
    // Record both stdout and stderr of gradle.
    log.writeSectionToFile("Gradle logs ($stubName)", procRes.stderr);
    log.writeSectionToFile("Gradle output ($stubName)", procRes.stdout);
    final output = procRes.stdout as String;
    if (output.isEmpty) {
      printError(procRes.stderr);
      throw Exception("Gradle stub exited without output.");
    }
    final paths = (procRes.stdout as String)
        .trim()
        .split(Platform.isWindows ? '\r\n' : '\n');
    log.fine('Found ${paths.length} entries');
    return paths;
  }
}