// Copyright (C) 2025 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 (
 "strings"

 "github.com/google/blueprint/proptools"

 "android/soong/android"
)

type bootOtas16k struct {
 android.ModuleBase
 properties BootOtas16kProperties
}

type BootOtas16kProperties struct {
 Dtbo_image          *string `android:"path_device_first"`
 Dtbo_image_16k      *string `android:"path_device_first"`
 Boot_image          *string `android:"path_device_first"`
 Boot_image_16k      *string `android:"path_device_first"`
 Use_ota_incremental *bool
}

func BootOtas16kFactory() android.Module {
 module := &bootOtas16k{}
 android.InitAndroidArchModule(module, android.DeviceSupported, android.MultilibCommon)
 module.AddProperties(&module.properties)
 return module
}

type bootOtas16kPaths struct {
 dtboImage    android.OptionalPath
 dtboImage16k android.OptionalPath
 bootImage    android.OptionalPath
 bootImage16k android.OptionalPath
}

func (b *bootOtas16k) collectImagePaths(ctx android.ModuleContext) bootOtas16kPaths {
 return bootOtas16kPaths{
  dtboImage:    android.OptionalPathForModuleSrc(ctx, b.properties.Dtbo_image),
  dtboImage16k: android.OptionalPathForModuleSrc(ctx, b.properties.Dtbo_image_16k),
  bootImage:    android.OptionalPathForModuleSrc(ctx, b.properties.Boot_image),
  bootImage16k: android.OptionalPathForModuleSrc(ctx, b.properties.Boot_image_16k),
 }
}

func (b *bootOtas16k) GenerateAndroidBuildActions(ctx android.ModuleContext) {

 imagePaths := b.collectImagePaths(ctx)

 // At least one of the bootImage or the bootImage16k must point to a valid path
 if !imagePaths.bootImage.Valid() && !imagePaths.bootImage16k.Valid() {
  ctx.ModuleErrorf("Neither boot_image nor the boot_image_16k are valid; at least one of them must be a valid path")
 }

 bootOta4kZip := b.createOtaPackage(
  ctx,
  imagePaths.bootImage,
  imagePaths.bootImage16k,
  imagePaths.dtboImage,
  "boot_ota_4k.zip",
 )
 bootOta16kZip := b.createOtaPackage(
  ctx,
  imagePaths.bootImage16k,
  imagePaths.bootImage,
  imagePaths.dtboImage16k,
  "boot_ota_16k.zip",
 )

 installDir := android.PathForModuleInstall(ctx, "boot_otas")
 ctx.PackageFile(installDir, bootOta4kZip.Base(), bootOta4kZip)
 ctx.PackageFile(installDir, bootOta16kZip.Base(), bootOta16kZip)
}

func (b *bootOtas16k) createOtaPackage(ctx android.ModuleContext, primaryBootImage, secondaryBootImage, dtboImage android.OptionalPath, filename string) android.Path {
 builder := android.NewRuleBuilder(pctx, ctx).SandboxDisabled()
 zip := android.PathForModuleOut(ctx, filename)

 _, key := ctx.Config().DefaultSystemDevCertificate(ctx)
 cmd := builder.Command().
  BuiltTool("ota_from_raw_img").
  FlagWithArg("--package_key ", strings.TrimSuffix(key.String(), key.Ext())).
  Implicit(key).
  Textf("--max_timestamp $(cat %s)", ctx.Config().Getenv("BUILD_DATETIME_FILE"))

 if dtboImage.Valid() {
  cmd.FlagWithArg("--partition_name ", "boot,dtbo")
 } else {
  cmd.FlagWithArg("--partition_name ", "boot")
 }

 cmd.FlagWithOutput("--output ", zip).
  FlagWithInput("--delta_generator_path ", ctx.Config().HostToolPath(ctx, "delta_generator"))

 if proptools.Bool(b.properties.Use_ota_incremental) {
  if secondaryBootImage.Valid() && primaryBootImage.Valid() {
   cmd.Textf("%s:%s", secondaryBootImage, primaryBootImage).
    Implicit(secondaryBootImage.Path()).
    Implicit(primaryBootImage.Path())
  }
 } else {
  cmd.Input(primaryBootImage.Path())
 }

 if dtboImage.Valid() {
  cmd.Input(dtboImage.Path())
 }

 builder.Build(filename, filename)
 return zip
}