// Copyright 2019 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"
 "path/filepath"

 "android/soong/android"
 "android/soong/java/config"

 "github.com/google/blueprint/pathtools"
)

func init() {
 android.RegisterParallelSingletonType("sdk", sdkSingletonFactory)
 android.RegisterMakeVarsProvider(pctx, sdkMakeVars)
}

var sdkFrameworkAidlPathKey = android.NewOnceKey("sdkFrameworkAidlPathKey")
var nonUpdatableFrameworkAidlPathKey = android.NewOnceKey("nonUpdatableFrameworkAidlPathKey")

func UseApiFingerprint(ctx android.BaseModuleContext) (useApiFingerprint bool, fingerprintSdkVersion string, fingerprintDeps android.OutputPath) {
 if ctx.Config().UnbundledBuild() && !ctx.Config().AlwaysUsePrebuiltSdks() {
  apiFingerprintTrue := ctx.Config().IsEnvTrue("UNBUNDLED_BUILD_TARGET_SDK_WITH_API_FINGERPRINT")
  dessertShaIsSet := ctx.Config().Getenv("UNBUNDLED_BUILD_TARGET_SDK_WITH_DESSERT_SHA") != ""

  // Error when both UNBUNDLED_BUILD_TARGET_SDK_WITH_API_FINGERPRINT and UNBUNDLED_BUILD_TARGET_SDK_WITH_DESSERT_SHA are set
  if apiFingerprintTrue && dessertShaIsSet {
   ctx.ModuleErrorf("UNBUNDLED_BUILD_TARGET_SDK_WITH_API_FINGERPRINT=true cannot be set alongside with UNBUNDLED_BUILD_TARGET_SDK_WITH_DESSERT_SHA")
  }

  useApiFingerprint = apiFingerprintTrue || dessertShaIsSet
  if apiFingerprintTrue {
   fingerprintSdkVersion = ctx.Config().PlatformSdkCodename() + fmt.Sprintf(".$$(cat %s)", android.ApiFingerprintPath(ctx).String())
   fingerprintDeps = android.ApiFingerprintPath(ctx)
  }
  if dessertShaIsSet {
   fingerprintSdkVersion = ctx.Config().Getenv("UNBUNDLED_BUILD_TARGET_SDK_WITH_DESSERT_SHA")
  }
 }
 return useApiFingerprint, fingerprintSdkVersion, fingerprintDeps
}

func defaultJavaLanguageVersion(ctx android.EarlyModuleContext, s android.SdkSpec) javaVersion {
 sdk, err := s.EffectiveVersion(ctx)
 if err != nil {
  ctx.PropertyErrorf("sdk_version", "%s", err)
 }
 if sdk.FinalOrFutureInt() <= 29 {
  return JAVA_VERSION_8
 } else if sdk.FinalOrFutureInt() <= 31 {
  return JAVA_VERSION_9
 } else if sdk.FinalOrFutureInt() <= 33 {
  return JAVA_VERSION_11
 } else if ctx.Config().TargetsJava21() {
  // Build flag that controls whether Java 21 is used as the
  // default target version, or Java 17.
  return JAVA_VERSION_21
 } else {
  return JAVA_VERSION_17
 }
}

// systemModuleKind returns the kind of system modules to use for the supplied combination of sdk
// kind and API level.
func systemModuleKind(sdkKind android.SdkKind, apiLevel android.ApiLevel) android.SdkKind {
 systemModuleKind := sdkKind
 if apiLevel.LessThanOrEqualTo(android.LastWithoutModuleLibCoreSystemModules) {
  // API levels less than or equal to 31 did not provide a core-for-system-modules.jar
  // specifically for the module-lib API. So, always use the public system modules for them.
  systemModuleKind = android.SdkPublic
 } else if systemModuleKind == android.SdkCore {
  // Core is by definition what is included in the system module for the public API so should
  // just use its system modules.
  systemModuleKind = android.SdkPublic
 } else if systemModuleKind == android.SdkSystem || systemModuleKind == android.SdkTest ||
  systemModuleKind == android.SdkTestFrameworksCore {
  // The core system and test APIs are currently the same as the public API so they should use
  // its system modules.
  systemModuleKind = android.SdkPublic
 } else if systemModuleKind == android.SdkSystemServer {
  // The core system server API is the same as the core module-lib API.
  systemModuleKind = android.SdkModule
 }

 return systemModuleKind
}

func decodeSdkDep(ctx android.EarlyModuleContext, sdkContext SdkVersionContext) sdkDep {
 sdkVersion := sdkContext.SdkVersion(ctx)
 if !sdkVersion.Valid() {
  ctx.PropertyErrorf("sdk_version", "invalid version %q", sdkVersion.Raw)
  return sdkDep{}
 }

 if ctx.DeviceSpecific() || ctx.SocSpecific() {
  sdkVersion = sdkVersion.ForVendorPartition(ctx)
 }

 if !sdkVersion.ValidateSystemSdk(ctx) {
  return sdkDep{}
 }

 if sdkVersion.UsePrebuilt(ctx) {
  dir := filepath.Join("prebuilts", "sdk", sdkVersion.ApiLevel.GetSdkVersion(), sdkVersion.Kind.String())
  jar := filepath.Join(dir, "android.jar")
  // There's no aidl for other SDKs yet.
  // TODO(77525052): Add aidl files for other SDKs too.
  publicDir := filepath.Join("prebuilts", "sdk", sdkVersion.ApiLevel.GetSdkVersion(), "public")
  aidl := filepath.Join(publicDir, "framework.aidl")
  jarPath := android.ExistentPathForSource(ctx, jar)
  aidlPath := android.ExistentPathForSource(ctx, aidl)
  lambdaStubsPath := android.PathForSource(ctx, config.SdkLambdaStubsPath)

  if (!jarPath.Valid() || !aidlPath.Valid()) && ctx.Config().AllowMissingDependencies() {
   return sdkDep{
    invalidVersion: true,
    bootclasspath:  []string{fmt.Sprintf("sdk_%s_%s_android", sdkVersion.Kind, sdkVersion.ApiLevel.GetSdkVersion())},
   }
  }

  if !jarPath.Valid() {
   ctx.PropertyErrorf("sdk_version", "invalid sdk version %q, %q does not exist", sdkVersion.Raw, jar)
   return sdkDep{}
  }

  if !aidlPath.Valid() {
   ctx.PropertyErrorf("sdk_version", "invalid sdk version %q, %q does not exist", sdkVersion.Raw, aidl)
   return sdkDep{}
  }

  var systemModules string
  if defaultJavaLanguageVersion(ctx, sdkVersion).usesJavaModules() {
   systemModuleKind := systemModuleKind(sdkVersion.Kind, sdkVersion.ApiLevel)
   systemModules = fmt.Sprintf("sdk_%s_%s_system_modules", systemModuleKind, sdkVersion.ApiLevel.GetSdkVersion())
  }

  return sdkDep{
   useFiles:      true,
   jars:          android.Paths{jarPath.Path(), lambdaStubsPath},
   aidl:          android.OptionalPathForPath(aidlPath.Path()),
   systemModules: systemModules,
  }
 }

 toModule := func(module string, aidl android.Path) sdkDep {
  // Select the kind of system modules needed for the sdk version.
  systemModulesKind := systemModuleKind(sdkVersion.Kind, android.FutureApiLevel)
  systemModules := fmt.Sprintf("core-%s-stubs-system-modules", systemModulesKind)
  return sdkDep{
   useModule:          true,
   bootclasspath:      []string{module, config.DefaultLambdaStubsLibrary},
   systemModules:      systemModules,
   java9Classpath:     []string{module},
   frameworkResModule: "framework-res",
   aidl:               android.OptionalPathForPath(aidl),
  }
 }

 switch sdkVersion.Kind {
 case android.SdkPrivate:
  // SdkPrivate is for platform apps that are not bundled in any APEX.
  // Such apps are allowed to use private platform APIs.
  //
  // Allowlisted /product apps may use select hidden APIs, but not private resources.
  // framework-minus-internal-res is identical to framework, except that
  // com.android.internal.R is explicitly removed with jarjar.
  classpath := append([]string{}, config.FrameworkLibraries...)
  if ctx.ProductSpecific() {
   for i, lib := range classpath {
    if lib == "framework" {
     classpath[i] = "framework-minus-internal-res"
     break
    }
   }
  }
  return sdkDep{
   useModule:          true,
   systemModules:      corePlatformSystemModules(ctx),
   bootclasspath:      corePlatformBootclasspathLibraries(ctx),
   classpath:          classpath,
   frameworkResModule: "framework-res",
   proguardFlags:      []string{"framework-private-proguard"},
  }
 case android.SdkNone:
  systemModules := sdkContext.SystemModules()
  if systemModules == "" {
   ctx.PropertyErrorf("sdk_version",
    `system_modules is required to be set to a non-empty value when sdk_version is "none", did you mean sdk_version: "core_platform"?`)
  } else if systemModules == "none" {
   return sdkDep{
    noStandardLibs: true,
   }
  }

  return sdkDep{
   useModule:      true,
   noStandardLibs: true,
   systemModules:  systemModules,
   bootclasspath:  []string{systemModules},
  }
 case android.SdkCorePlatform:
  return sdkDep{
   useModule:        true,
   systemModules:    corePlatformSystemModules(ctx),
   bootclasspath:    corePlatformBootclasspathLibraries(ctx),
   noFrameworksLibs: true,
  }
 case android.SdkPublic, android.SdkSystem, android.SdkTest, android.SdkTestFrameworksCore:
  return toModule(sdkVersion.Kind.DefaultJavaLibraryName(), sdkFrameworkAidlPath(ctx))
 case android.SdkCore:
  return sdkDep{
   useModule:        true,
   bootclasspath:    []string{android.SdkCore.DefaultJavaLibraryName(), config.DefaultLambdaStubsLibrary},
   systemModules:    "core-public-stubs-system-modules",
   noFrameworksLibs: true,
  }
 case android.SdkModule:
  // TODO(146757305): provide .apk and .aidl that have more APIs for modules
  return toModule(sdkVersion.Kind.DefaultJavaLibraryName(), nonUpdatableFrameworkAidlPath(ctx))
 case android.SdkSystemServer:
  // TODO(146757305): provide .apk and .aidl that have more APIs for modules
  return toModule(sdkVersion.Kind.DefaultJavaLibraryName(), sdkFrameworkAidlPath(ctx))
 default:
  panic(fmt.Errorf("invalid sdk %q", sdkVersion.Raw))
 }
}

func sdkSingletonFactory() android.Singleton {
 return sdkSingleton{}
}

type sdkSingleton struct{}

func (sdkSingleton) GenerateBuildActions(ctx android.SingletonContext) {
 if ctx.Config().AlwaysUsePrebuiltSdks() {
  return
 }

 createSdkFrameworkAidl(ctx)
 createNonUpdatableFrameworkAidl(ctx)
 createAPIFingerprint(ctx)
}

// Create framework.aidl by extracting anything that implements android.os.Parcelable from the SDK stubs modules.
func createSdkFrameworkAidl(ctx android.SingletonContext) {
 stubsModules := []string{
  android.SdkPublic.DefaultJavaLibraryName(),
  android.SdkTest.DefaultJavaLibraryName(),
  android.SdkSystem.DefaultJavaLibraryName(),
 }

 combinedAidl := sdkFrameworkAidlPath(ctx)
 tempPath := tempPathForRestat(ctx, combinedAidl)

 rule := createFrameworkAidl(stubsModules, tempPath, ctx)

 commitChangeForRestat(rule, tempPath, combinedAidl)

 rule.Build("framework_aidl", "generate framework.aidl")
}

// Creates a version of framework.aidl for the non-updatable part of the platform.
func createNonUpdatableFrameworkAidl(ctx android.SingletonContext) {
 stubsModules := []string{android.SdkModule.DefaultJavaLibraryName()}

 combinedAidl := nonUpdatableFrameworkAidlPath(ctx)
 tempPath := tempPathForRestat(ctx, combinedAidl)

 rule := createFrameworkAidl(stubsModules, tempPath, ctx)

 commitChangeForRestat(rule, tempPath, combinedAidl)

 rule.Build("framework_non_updatable_aidl", "generate framework_non_updatable.aidl")
}

func createFrameworkAidl(stubsModules []string, path android.WritablePath, ctx android.SingletonContext) *android.RuleBuilder {
 stubsJars := make([]android.Paths, len(stubsModules))

 ctx.VisitAllModuleProxies(func(module android.ModuleProxy) {
  // Collect dex jar paths for the modules listed above.
  if j, ok := android.OtherModuleProvider(ctx, module, JavaInfoProvider); ok {
   name := ctx.ModuleName(module)
   if i := android.IndexList(name, stubsModules); i != -1 {
    stubsJars[i] = j.HeaderJars
   }
  }
 })

 var missingDeps []string

 for i := range stubsJars {
  if stubsJars[i] == nil {
   if ctx.Config().AllowMissingDependencies() {
    missingDeps = append(missingDeps, stubsModules[i])
   } else {
    ctx.Errorf("failed to find dex jar path for module %q", stubsModules[i])
   }
  }
 }

 rule := android.NewRuleBuilder(pctx, ctx).SandboxDisabled()
 rule.MissingDeps(missingDeps)

 var aidls android.Paths
 for _, jars := range stubsJars {
  for _, jar := range jars {
   aidl := android.PathForOutput(ctx, "aidl", pathtools.ReplaceExtension(jar.Base(), "aidl"))

   rule.Command().
    Text("rm -f").Output(aidl)

   rule.Command().
    BuiltTool("sdkparcelables").
    Input(jar).
    Output(aidl).
    Flag("--guarantee_stable")

   aidls = append(aidls, aidl)
  }
 }

 rule.Command().
  Text("rm -f").Output(path)
 rule.Command().
  Text("cat").
  Inputs(aidls).
  Text("| sort -u >").
  Output(path)

 return rule
}

func sdkFrameworkAidlPath(ctx android.PathContext) android.OutputPath {
 return ctx.Config().Once(sdkFrameworkAidlPathKey, func() interface{} {
  return android.PathForOutput(ctx, "framework.aidl")
 }).(android.OutputPath)
}

func nonUpdatableFrameworkAidlPath(ctx android.PathContext) android.OutputPath {
 return ctx.Config().Once(nonUpdatableFrameworkAidlPathKey, func() interface{} {
  return android.PathForOutput(ctx, "framework_non_updatable.aidl")
 }).(android.OutputPath)
}

// Create api_fingerprint.txt
func createAPIFingerprint(ctx android.SingletonContext) {
 out := android.ApiFingerprintPath(ctx)

 rule := android.NewRuleBuilder(pctx, ctx).SandboxDisabled()

 rule.Command().
  Text("rm -f").Output(out)
 cmd := rule.Command()

 if ctx.Config().PlatformSdkCodename() == "REL" {
  cmd.Text("echo REL >").Output(out)
 } else if ctx.Config().FrameworksBaseDirExists(ctx) && !ctx.Config().AlwaysUsePrebuiltSdks() {
  cmd.Text("cat")
  apiTxtFileModules := []string{
   "api_fingerprint",
  }
  count := 0
  ctx.VisitAllModuleProxies(func(module android.ModuleProxy) {
   name := ctx.ModuleName(module)
   if android.InList(name, apiTxtFileModules) {
    cmd.Inputs(android.OutputFilesForModule(ctx, module, ""))
    count++
   }
  })
  if count != len(apiTxtFileModules) {
   ctx.Errorf("Could not find expected API module %v, found %d\n", apiTxtFileModules, count)
   return
  }
  cmd.Text(">").
   Output(out)
 } else {
  // Unbundled build
  // TODO: use a prebuilt api_fingerprint.txt from prebuilts/sdk/current.txt once we have one
  cmd.Text("echo").
   Flag(ctx.Config().PlatformPreviewSdkVersion()).
   Text(">").
   Output(out)
 }

 rule.Build("api_fingerprint", "generate api_fingerprint.txt")

 if ctx.Config().BuildOS.Linux() {
  ctx.DistForGoals([]string{"sdk", "droidcore"}, out)
 }
}

func sdkMakeVars(ctx android.MakeVarsContext) {
 if ctx.Config().AlwaysUsePrebuiltSdks() {
  return
 }

 ctx.Strict("FRAMEWORK_AIDL", sdkFrameworkAidlPath(ctx).String())
 ctx.Strict("API_FINGERPRINT", android.ApiFingerprintPath(ctx).String())
}