// Copyright (C) 2024 The Android Open Source Project
//
// 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 filesystem

import (
 "fmt"
 "path/filepath"
 "sort"
 "strings"
 "time"

 "android/soong/android"

 "github.com/google/blueprint"
 "github.com/google/blueprint/depset"
 "github.com/google/blueprint/proptools"
)

var (
 systemOtherPropFileTweaks = pctx.AndroidStaticRule("system_other_prop_file_tweaks", blueprint.RuleParams{
  Command2: blueprint.NewCommand(
   android.Rm, ` -rf $out && `, android.Sed,
   ` -e 's@^mount_point=/$$@mount_point=system_other@g'`,
   ` -e 's@^partition_name=system$$@partition_name=system_other@g' $in > $out`,
  ),
 })
)

type SystemOtherImageProperties struct {
 // The system_other image always requires a reference to the system image. The system_other
 // partition gets built into the system partition's "b" slot in a/b partition builds. Thus, it
 // copies most of its configuration from the system image, such as filesystem type, avb signing
 // info, etc. Including it here does not automatically mean that it will pick up the system
 // image's dexpropt files, it must also be listed in Preinstall_dexpreopt_files_from for that.
 System_image *string

 // This system_other partition will include all the dexpreopt files from the apps on these
 // partitions.
 Preinstall_dexpreopt_files_from []string
}

type systemOtherImage struct {
 android.ModuleBase
 android.DefaultableModuleBase
 properties SystemOtherImageProperties
}

// The system_other image is the default contents of the "b" slot of the system image.
// It contains the dexpreopt files of all the apps on the device, for a faster first boot.
// Afterwards, at runtime, it will be used as a regular b slot for OTA updates, and the initial
// dexpreopt files will be deleted.
func SystemOtherImageFactory() android.Module {
 module := &systemOtherImage{}
 module.AddProperties(&module.properties)
 android.InitAndroidArchModule(module, android.DeviceSupported, android.MultilibCommon)
 android.InitDefaultableModule(module)
 return module
}

type systemImageDeptag struct {
 blueprint.BaseDependencyTag
}

var systemImageDependencyTag = systemImageDeptag{}

type dexpreoptDeptag struct {
 blueprint.BaseDependencyTag
}

var dexpreoptDependencyTag = dexpreoptDeptag{}

func (m *systemOtherImage) DepsMutator(ctx android.BottomUpMutatorContext) {
 if proptools.String(m.properties.System_image) == "" {
  ctx.ModuleErrorf("system_image property must be set")
  return
 }
 ctx.AddDependency(ctx.Module(), systemImageDependencyTag, *m.properties.System_image)
 ctx.AddDependency(ctx.Module(), dexpreoptDependencyTag, m.properties.Preinstall_dexpreopt_files_from...)
}

func (m *systemOtherImage) GenerateAndroidBuildActions(ctx android.ModuleContext) {
 systemImage := ctx.GetDirectDepProxyWithTag(*m.properties.System_image, systemImageDependencyTag)
 systemInfo, ok := android.OtherModuleProvider(ctx, systemImage, FilesystemProvider)
 if !ok {
  ctx.PropertyErrorf("system_image", "Expected system_image module to provide FilesystemProvider")
  return
 }

 output := android.PathForModuleOut(ctx, "system_other.img")
 stagingDir := android.PathForModuleOut(ctx, "system_other").OutputPath
 stagingDirTimestamp := android.PathForModuleOut(ctx, "staging_dir.timestamp")

 builder := android.NewRuleBuilder(pctx, ctx).SandboxDisabled()
 builder.Command().Textf("rm -rf %s && mkdir -p %s", stagingDir, stagingDir)

 specs := make(map[string]android.PackagingSpec)
 for _, otherPartition := range m.properties.Preinstall_dexpreopt_files_from {
  dexModule := ctx.GetDirectDepProxyWithTag(otherPartition, dexpreoptDependencyTag)
  fsInfo, ok := android.OtherModuleProvider(ctx, dexModule, FilesystemProvider)
  if !ok {
   ctx.PropertyErrorf("preinstall_dexpreopt_files_from", "Expected module %q to provide FilesystemProvider", otherPartition)
   return
  }
  // Merge all the packaging specs into 1 map
  for k := range fsInfo.SpecsForSystemOther {
   if _, ok := specs[k]; ok {
    ctx.ModuleErrorf("Packaging spec %s given by two different partitions", k)
    continue
   }
   specs[k] = fsInfo.SpecsForSystemOther[k]
  }
 }

 // TOOD: CopySpecsToDir only exists on PackagingBase, but doesn't use any fields from it. Clean this up.
 (&android.PackagingBase{}).CopySpecsToDir(ctx, builder, specs, stagingDir)

 fullInstallPaths := []FullInstallPathInfo{}
 for _, mod := range android.SortedKeys(specs) {
  spec := specs[mod]
  fullInstallPaths = append(fullInstallPaths, FullInstallPathInfo{
   FullInstallPath:     spec.FullInstallPath(),
   RequiresFullInstall: spec.RequiresFullInstall(),
   SourcePath:          spec.SrcPath(),
   SymlinkTarget:       spec.SymlinkTarget(),
  })
 }

 platformGenerated := []string{}
 if len(m.properties.Preinstall_dexpreopt_files_from) > 0 {
  builtPath := android.PathForModuleOut(ctx, "system_other", "system-other-odex-marker")
  builder.Command().Textf("touch").Output(builtPath)
  installPath := android.PathForModuleInPartitionInstall(ctx, "system_other", "system-other-odex-marker")
  fullInstallPaths = append(fullInstallPaths, FullInstallPathInfo{
   FullInstallPath: installPath,
   SourcePath:      builtPath,
  })
  platformGenerated = append(platformGenerated, installPath.String())
 }
 builder.Command().Textf("touch").Output(stagingDirTimestamp)
 builder.Build("assemble_filesystem_staging_dir", "Assemble filesystem staging dir")

 // Most of the time, if build_image were to call a host tool, it accepts the path to the
 // host tool in a field in the prop file. However, it doesn't have that option for fec, which
 // it expects to just be on the PATH. Add fec to the PATH.
 fec := ctx.Config().HostToolPath(ctx, "fec")
 pathToolDirs := []string{filepath.Dir(fec.String())}

 // In make, the exact same prop file is used for both system and system_other. However, I
 // believe make goes through a different build_image code path that is based on the name of
 // the output file. So it sees the output file is named system_other.img and makes some changes.
 // We don't use that codepath, so make the changes manually to the prop file.
 propFile := android.PathForModuleOut(ctx, "prop")
 ctx.Build(pctx, android.BuildParams{
  Rule:   systemOtherPropFileTweaks,
  Input:  systemInfo.BuildImagePropFile,
  Output: propFile,
 })

 builder = android.NewRuleBuilder(pctx, ctx).SandboxDisabled()
 builder.Command().
  Textf("PATH=%s:$PATH", strings.Join(pathToolDirs, ":")).
  BuiltTool("build_image").
  Text(stagingDir.String()). // input directory
  Input(propFile).
  Implicits(systemInfo.BuildImagePropFileDeps).
  Implicit(fec).
  Implicit(stagingDirTimestamp).
  Output(output).
  Text(stagingDir.String())

 builder.Build("build_system_other", "build system other")

 fsInfo := FilesystemInfo{
  Output:              output,
  RootDir:             stagingDir,
  ModuleName:          ctx.ModuleName(),
  FilesystemConfig:    m.generateFilesystemConfig(ctx, stagingDir, stagingDirTimestamp),
  PropFileForMiscInfo: m.buildPropFileForMiscInfo(ctx),
  InstalledFilesDepSet: depset.New(
   depset.POSTORDER,
   []InstalledFilesStruct{buildInstalledFiles(ctx, "system-other", stagingDir, output)},
   nil,
  ),
  FullInstallPaths: fullInstallPaths,
 }

 android.SetProvider(ctx, FilesystemProvider, fsInfo)

 ctx.SetOutputFiles(android.Paths{output}, "")
 ctx.CheckbuildFile(output)

 // Dump compliance metadata
 complianceMetadataInfo := ctx.ComplianceMetadataInfo()
 filesContained := make([]string, 0, len(fullInstallPaths))
 for _, file := range fullInstallPaths {
  filesContained = append(filesContained, file.FullInstallPath.String())
 }
 complianceMetadataInfo.SetFilesContained(filesContained)
 complianceMetadataInfo.SetPlatformGeneratedFiles(platformGenerated)
}

func (s *systemOtherImage) generateFilesystemConfig(ctx android.ModuleContext, stagingDir, stagingDirTimestamp android.Path) android.Path {
 out := android.PathForModuleOut(ctx, "filesystem_config.txt")
 ctx.Build(pctx, android.BuildParams{
  Rule:   fsConfigRule,
  Input:  stagingDirTimestamp, // assemble the staging directory
  Output: out,
  Args: map[string]string{
   "rootDir": stagingDir.String(),
   "prefix":  "system/",
  },
 })
 return out
}

func (f *systemOtherImage) buildPropFileForMiscInfo(ctx android.ModuleContext) android.Path {
 var lines []string
 addStr := func(name string, value string) {
  lines = append(lines, fmt.Sprintf("%s=%s", name, value))
 }

 addStr("building_system_other_image", "true")

 systemImage := ctx.GetDirectDepProxyWithTag(*f.properties.System_image, systemImageDependencyTag)
 systemInfo, ok := android.OtherModuleProvider(ctx, systemImage, FilesystemProvider)
 if !ok {
  ctx.PropertyErrorf("system_image", "Expected system_image module to provide FilesystemProvider")
  return nil
 }
 if systemInfo.PartitionSize == nil {
  addStr("system_other_disable_sparse", "true")
 }
 if systemInfo.UseAvb {
  addStr("avb_system_other_hashtree_enable", "true")
  addStr("avb_system_other_algorithm", systemInfo.AvbAlgorithm)
  footerArgs := fmt.Sprintf("--hash_algorithm %s", systemInfo.AvbHashAlgorithm)
  if rollbackIndex, err := f.avbRollbackIndex(ctx); err == nil {
   footerArgs += fmt.Sprintf(" --rollback_index %d", rollbackIndex)
  } else {
   ctx.ModuleErrorf("Could not determine rollback_index %s\n", err)
  }
  addStr("avb_system_other_add_hashtree_footer_args", footerArgs)
  if systemInfo.AvbKey != nil {
   addStr("avb_system_other_key_path", systemInfo.AvbKey.String())
  }
 }

 sort.Strings(lines)

 propFile := android.PathForModuleOut(ctx, "prop_file")
 android.WriteFileRule(ctx, propFile, strings.Join(lines, "\n"))
 return propFile
}

// Use the default: PlatformSecurityPatch
// TODO: Get this value from vbmeta_system
func (f *systemOtherImage) avbRollbackIndex(ctx android.ModuleContext) (int64, error) {
 t, err := time.Parse(time.DateOnly, ctx.Config().PlatformSecurityPatch())
 if err != nil {
  return -1, err
 }
 return t.Unix(), err
}