// Copyright 2018 Google Inc. All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package java

import (
 "fmt"
 "strconv"
 "strings"

 "github.com/google/blueprint"

 "android/soong/android"
 "android/soong/dexpreopt"
)

var manifestFixerRule = pctx.AndroidStaticRule("manifestFixer",
 blueprint.RuleParams{
  Command: `${config.ManifestFixerCmd} ` +
   `$args $in $out`,
  CommandDeps:     []string{"${config.ManifestFixerCmd}"},
  SandboxDisabled: true,
 },
 "args")

var manifestMergerRule = pctx.AndroidStaticRule("manifestMerger",
 blueprint.RuleParams{
  Command:         `${config.ManifestMergerCmd} $args --main $in $libs --out $out`,
  CommandDeps:     []string{"${config.ManifestMergerCmd}"},
  SandboxDisabled: true,
 },
 "args", "libs")

// targetSdkVersion for manifest_fixer
// When TARGET_BUILD_APPS is not empty, this method returns 10000 for modules targeting an unreleased SDK
// This enables release builds (that run with TARGET_BUILD_APPS=[val...]) to target APIs that have not yet been finalized as part of an SDK
func targetSdkVersionForManifestFixer(ctx android.ModuleContext, params ManifestFixerParams) string {
 targetSdkVersionLevel := params.SdkContext.TargetSdkVersion(ctx)

 // Check if we want to return 10000
 // TODO(b/240294501): Determine the rules for handling test apexes
 if shouldReturnFinalOrFutureInt(ctx, targetSdkVersionLevel, params.EnforceDefaultTargetSdkVersion) {
  return strconv.Itoa(android.FutureApiLevel.FinalOrFutureInt())
 }
 targetSdkVersion, err := targetSdkVersionLevel.EffectiveVersionString(ctx)
 if err != nil {
  ctx.ModuleErrorf("invalid targetSdkVersion: %s", err)
 }
 return targetSdkVersion
}

// Return true for modules targeting "current" if either
// 1. The module is built in unbundled mode (TARGET_BUILD_APPS not empty)
// 2. The module is run as part of MTS, and should be testable on stable branches
// Do not return 10000 if we are enforcing default targetSdkVersion and sdk has been finalised
func shouldReturnFinalOrFutureInt(ctx android.ModuleContext, targetSdkVersionLevel android.ApiLevel, enforceDefaultTargetSdkVersion bool) bool {
 // If this is a REL branch, do not return 10000
 if ctx.Config().PlatformSdkFinal() {
  return false
 }
 // If this a module targeting an unreleased SDK (MTS or unbundled builds), return 10000
 return targetSdkVersionLevel.IsPreview() && (ctx.Config().HasUnbundledBuildApps() || includedInMts(ctx.Module()))
}

// Helper function that returns true if android_test, android_test_helper_app, java_test are in an MTS suite.
func includedInMts(module android.Module) bool {
 if test, ok := module.(androidTestApp); ok {
  return test.includedInTestSuite("mts")
 }
 // java_test
 if test, ok := module.(*Test); ok {
  return android.PrefixInList(test.testProperties.Test_suites, "mts")
 }
 return false
}

type ManifestFixerParams struct {
 SdkContext                     android.SdkContext
 ClassLoaderContexts            dexpreopt.ClassLoaderContextMap
 IsLibrary                      bool
 DefaultManifestVersion         string
 UseEmbeddedNativeLibs          bool
 UsesNonSdkApis                 bool
 UseEmbeddedDex                 bool
 HasNoCode                      bool
 TestOnly                       bool
 LoggingParent                  string
 EnforceDefaultTargetSdkVersion bool
}

// Uses manifest_fixer.py to inject minSdkVersion, etc. into an AndroidManifest.xml
func ManifestFixer(ctx android.ModuleContext, manifest android.Path,
 params ManifestFixerParams) android.Path {
 var args []string

 if params.IsLibrary {
  args = append(args, "--library")
 } else if params.SdkContext != nil {
  minSdkVersion, err := params.SdkContext.MinSdkVersion(ctx).EffectiveVersion(ctx)
  if err != nil {
   ctx.ModuleErrorf("invalid minSdkVersion: %s", err)
  }
  if minSdkVersion.FinalOrFutureInt() >= 23 {
   args = append(args, fmt.Sprintf("--extract-native-libs=%v", !params.UseEmbeddedNativeLibs))
  } else if params.UseEmbeddedNativeLibs {
   ctx.ModuleErrorf("module attempted to store uncompressed native libraries, but minSdkVersion=%s doesn't support it",
    minSdkVersion.String())
  }
 }

 if params.UsesNonSdkApis {
  args = append(args, "--uses-non-sdk-api")
 }

 if params.UseEmbeddedDex {
  args = append(args, "--use-embedded-dex")
 }

 if params.ClassLoaderContexts != nil {
  // Libraries propagated via `uses_libs`/`optional_uses_libs` are also added (they may be
  // propagated from dependencies).
  requiredUsesLibs, optionalUsesLibs := params.ClassLoaderContexts.UsesLibs()

  for _, usesLib := range requiredUsesLibs {
   args = append(args, "--uses-library", usesLib)
  }
  for _, usesLib := range optionalUsesLibs {
   args = append(args, "--optional-uses-library", usesLib)
  }
 }

 if params.HasNoCode {
  args = append(args, "--has-no-code")
 }

 if params.TestOnly {
  args = append(args, "--test-only")
 }

 if params.LoggingParent != "" {
  args = append(args, "--logging-parent", params.LoggingParent)
 }
 var deps android.Paths
 var argsMapper = make(map[string]string)

 if params.SdkContext != nil {
  targetSdkVersion := targetSdkVersionForManifestFixer(ctx, params)

  if useApiFingerprint, fingerprintTargetSdkVersion, fingerprintDeps :=
   UseApiFingerprint(ctx); useApiFingerprint && ctx.ModuleName() != "framework-res" {
   targetSdkVersion = fingerprintTargetSdkVersion
   deps = append(deps, fingerprintDeps)
  }

  args = append(args, "--targetSdkVersion ", targetSdkVersion)

  minSdkVersion, err := params.SdkContext.MinSdkVersion(ctx).EffectiveVersionString(ctx)
  if err != nil {
   ctx.ModuleErrorf("invalid minSdkVersion: %s", err)
  }

  replaceMaxSdkVersionPlaceholder, err := params.SdkContext.ReplaceMaxSdkVersionPlaceholder(ctx).EffectiveVersion(ctx)
  if err != nil {
   ctx.ModuleErrorf("invalid ReplaceMaxSdkVersionPlaceholder: %s", err)
  }

  if useApiFingerprint, fingerprintMinSdkVersion, fingerprintDeps :=
   UseApiFingerprint(ctx); useApiFingerprint && ctx.ModuleName() != "framework-res" {
   minSdkVersion = fingerprintMinSdkVersion
   deps = append(deps, fingerprintDeps)
  }

  if err != nil {
   ctx.ModuleErrorf("invalid minSdkVersion: %s", err)
  }
  args = append(args, "--minSdkVersion ", minSdkVersion)
  args = append(args, "--replaceMaxSdkVersionPlaceholder ", strconv.Itoa(replaceMaxSdkVersionPlaceholder.FinalOrFutureInt()))
  args = append(args, "--raise-min-sdk-version")
 }
 if params.DefaultManifestVersion != "" {
  args = append(args, "--override-placeholder-version", params.DefaultManifestVersion)
 }

 fixedManifest := android.PathForModuleOut(ctx, "manifest_fixer", "AndroidManifest.xml")
 argsMapper["args"] = strings.Join(args, " ")

 ctx.Build(pctx, android.BuildParams{
  Rule:        manifestFixerRule,
  Description: "fix manifest",
  Input:       manifest,
  Implicits:   deps,
  Output:      fixedManifest,
  Args:        argsMapper,
 })

 return fixedManifest.WithoutRel()
}

type ManifestMergerParams struct {
 staticLibManifests android.Paths
 isLibrary          bool
 packageName        string
}

func manifestMerger(ctx android.ModuleContext, manifest android.Path,
 params ManifestMergerParams) android.Path {

 var args []string
 if !params.isLibrary {
  // Follow Gradle's behavior, only pass --remove-tools-declarations when merging app manifests.
  args = append(args, "--remove-tools-declarations")
 }

 packageName := params.packageName
 if packageName != "" {
  args = append(args, "--property PACKAGE="+packageName)
 }

 mergedManifest := android.PathForModuleOut(ctx, "manifest_merger", "AndroidManifest.xml")
 ctx.Build(pctx, android.BuildParams{
  Rule:        manifestMergerRule,
  Description: "merge manifest",
  Input:       manifest,
  Implicits:   params.staticLibManifests,
  Output:      mergedManifest,
  Args: map[string]string{
   "libs": android.JoinWithPrefix(params.staticLibManifests.Strings(), "--libs "),
   "args": strings.Join(args, " "),
  },
 })

 return mergedManifest.WithoutRel()
}