package fsgen

import (
 "fmt"
 "path/filepath"
 "strconv"
 "strings"

 "android/soong/android"
 "android/soong/filesystem"
 "android/soong/genrule"

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

// helper function to create boot.img and boot_16k.img
func createBootImageCommon(ctx android.LoadHookContext, kernelPath string, prebuiltBootImagePath string, dtbImg dtbImg, stem *string) bool {
 getPartitionSize := func(partitionVariables android.PartitionVariables) proptools.Configurable[int64] {
  return getPartitionSizeFromString(ctx, partitionVariables.BoardBootimagePartitionSize, "BOARD_BOOTIMAGE_PARTITION_SIZE")
 }
 partitionVariables := ctx.Config().ProductVariables().PartitionVarsForSoongMigrationOnlyDoNotUse
 avbInfo := getAvbInfo(ctx.Config(), "boot")
 bootImageName := generatedModuleNameForPartition(ctx.Config(), strings.TrimSuffix(*stem, ".img"))
 var securityPatch *string
 if partitionVariables.BootSecurityPatch != "" {
  securityPatch = &partitionVariables.BootSecurityPatch
 }

 if prebuiltBootImagePath != "" {
  file := android.ExistentPathForSource(ctx, prebuiltBootImagePath)
  // If the prebuilt doesn't exist yet, something else in the build is expected to populate it
  // (along with the corresponding prebuilt vbmeta if necessary).
  // TODO(b/465530439): this works for the current use case, but may not be the right long-term solution.
  if !file.Valid() && ctx.Config().KatiEnabled() {
   return false
  }

  // prebuilt bootimg
  ctx.CreateModuleInDirectory(
   filesystem.PrebuiltBootimgFactory,
   ".",
   &struct {
    Name *string
    Src  *string
   }{
    Name: proptools.StringPtr(bootImageName),
    Src:  proptools.StringPtr(prebuiltBootImagePath),
   },
   &filesystem.CommonBootimgProperties{
    Boot_image_type:             proptools.StringPtr("boot"),
    Partition_name:              proptools.StringPtr("boot"),
    Header_version:              proptools.StringPtr(partitionVariables.BoardBootHeaderVersion),
    Partition_size:              getPartitionSize(partitionVariables),
    Use_avb:                     avbInfo.avbEnable,
    Avb_mode:                    avbInfo.avbMode,
    Avb_private_key:             avbInfo.avbkeyFilegroup,
    Avb_rollback_index:          avbInfo.avbRollbackIndex,
    Avb_rollback_index_location: avbInfo.avbRollbackIndexLocation,
    Avb_algorithm:               avbInfo.avbAlgorithm,
    Security_patch:              securityPatch,
   },
  )

  return true
 }

 if kernelPath == "" {
  // There are potentially code paths that don't use `PRODUCT_COPY_FILES` to copy the kernel to
  // ANDROID_PRODUCT_OUT
  return false
 }

 kernelDir := filepath.Dir(kernelPath)
 kernelBase := filepath.Base(kernelPath)
 kernelFilegroupName := generatedModuleName(ctx.Config(), "kernel"+*stem) // to prevent name collisions.

 ctx.CreateModuleInDirectory(
  android.FileGroupFactory,
  kernelDir,
  &struct {
   Name       *string
   Srcs       []string
   Visibility []string
  }{
   Name:       proptools.StringPtr(kernelFilegroupName),
   Srcs:       []string{kernelBase},
   Visibility: []string{"//visibility:public"},
  },
 )

 var dtbPrebuilt *string
 if dtbImg.include && dtbImg.imgType == "boot" {
  dtbPrebuilt = proptools.StringPtr(":" + dtbImg.name)
 }

 var cmdline []string
 if !buildingVendorBootImage(partitionVariables) {
  cmdline = partitionVariables.InternalKernelCmdline
 }

 ctx.CreateModule(
  filesystem.BootimgFactory,
  &filesystem.BootimgProperties{
   Kernel_prebuilt: proptools.NewSimpleConfigurable(":" + kernelFilegroupName),
   Dtb_prebuilt:    dtbPrebuilt,
   Cmdline:         cmdline,
   Stem:            stem,
  },
  &filesystem.CommonBootimgProperties{
   Boot_image_type:             proptools.StringPtr("boot"),
   Partition_name:              proptools.StringPtr("boot"),
   Header_version:              proptools.StringPtr(partitionVariables.BoardBootHeaderVersion),
   Partition_size:              getPartitionSize(partitionVariables),
   Use_avb:                     avbInfo.avbEnable,
   Avb_mode:                    avbInfo.avbMode,
   Avb_private_key:             avbInfo.avbkeyFilegroup,
   Avb_rollback_index:          avbInfo.avbRollbackIndex,
   Avb_rollback_index_location: avbInfo.avbRollbackIndexLocation,
   Avb_algorithm:               avbInfo.avbAlgorithm,
   Security_patch:              securityPatch,
  },
  &struct {
   Name       *string
   Visibility []string
  }{
   Name:       proptools.StringPtr(bootImageName),
   Visibility: []string{"//visibility:public"},
  },
 )
 return true
}

func createBootImage(ctx android.LoadHookContext, dtbImg dtbImg) bool {
 partitionVariables := ctx.Config().ProductVariables().PartitionVarsForSoongMigrationOnlyDoNotUse
 return createBootImageCommon(ctx, getPrebuiltKernelPath(ctx), partitionVariables.BoardPrebuiltBootImage, dtbImg, proptools.StringPtr("boot.img"))
}

func createBootImage16k(ctx android.LoadHookContext) bool {
 partitionVariables := ctx.Config().ProductVariables().PartitionVarsForSoongMigrationOnlyDoNotUse
 // TODO: prebuilt boot_16k.img and dtb is currently not supported in fsgen.
 return createBootImageCommon(ctx, partitionVariables.BoardKernelPath16k, "", dtbImg{include: false}, proptools.StringPtr("boot_16k.img"))
}

func getPartitionSizeFromString(ctx android.LoadHookContext, s string, name string) proptools.Configurable[int64] {
 if s == "" {
  return proptools.NewEmptyConfigurable[int64]()
 }
 // Base of zero will allow base 10 or base 16 if starting with 0x
 parsed, err := strconv.ParseInt(s, 0, 64)
 if err != nil {
  ctx.ModuleErrorf("%s must be an int, got %s", name, s)
 }
 return proptools.NewSimpleConfigurable(parsed)
}

// The first return arg will be true if a vendor_boot.img bootimg module is autogenerated.
// The second arg is the ramdisk fragments.
func createVendorBootImage(ctx android.LoadHookContext, dtbImg dtbImg) (bool, []string) {
 partitionVariables := ctx.Config().ProductVariables().PartitionVarsForSoongMigrationOnlyDoNotUse

 bootImageName := generatedModuleNameForPartition(ctx.Config(), "vendor_boot")

 avbInfo := getAvbInfo(ctx.Config(), "vendor_boot")

 var dtbPrebuilt *string
 if dtbImg.include && dtbImg.imgType == "vendor_boot" {
  dtbPrebuilt = proptools.StringPtr(":" + dtbImg.name)
 }

 cmdline := partitionVariables.InternalKernelCmdline

 var vendorBootConfigImg *string
 if name, ok := createVendorBootConfigImg(ctx); ok {
  vendorBootConfigImg = proptools.StringPtr(":" + name)
 }

 partitionSize := getPartitionSizeFromString(ctx, partitionVariables.BoardVendorBootimagePartitionSize, "BOARD_VENDOR_BOOTIMAGE_PARTITION_SIZE")

 var ramdiskFragmentModules []string
 if buildingVendorRamdiskFragmentDlkm(ctx, partitionVariables) {
  ramdiskFragmentModules = append(ramdiskFragmentModules, generatedModuleNameForPartition(ctx.Config(), "vendor_ramdisk_fragment_dlkm"))
 }
 if ramdisk16kModuleName := createRamdisk16k(ctx); ramdisk16kModuleName != "" {
  ramdiskFragmentModules = append(ramdiskFragmentModules, ramdisk16kModuleName)
 }

 ctx.CreateModule(
  filesystem.BootimgFactory,
  &filesystem.BootimgProperties{
   Ramdisk_module:           proptools.StringPtr(generatedModuleNameForPartition(ctx.Config(), "vendor_ramdisk")),
   Ramdisk_fragment_modules: ramdiskFragmentModules,
   Dtb_prebuilt:             dtbPrebuilt,
   Cmdline:                  cmdline,
   Bootconfig:               vendorBootConfigImg,
   Stem:                     proptools.StringPtr("vendor_boot.img"),
  },
  &filesystem.CommonBootimgProperties{
   Boot_image_type:             proptools.StringPtr("vendor_boot"),
   Partition_name:              proptools.StringPtr("vendor_boot"),
   Header_version:              proptools.StringPtr(partitionVariables.BoardBootHeaderVersion),
   Partition_size:              partitionSize,
   Use_avb:                     avbInfo.avbEnable,
   Avb_mode:                    avbInfo.avbMode,
   Avb_private_key:             avbInfo.avbkeyFilegroup,
   Avb_rollback_index:          avbInfo.avbRollbackIndex,
   Avb_rollback_index_location: avbInfo.avbRollbackIndexLocation,
  },

  &struct {
   Name       *string
   Visibility []string
  }{
   Name:       proptools.StringPtr(bootImageName),
   Visibility: []string{"//visibility:public"},
  },
 )
 return true, ramdiskFragmentModules
}

// Same as vendor_boot, with the exception of the ramdisk module.
func createVendorBootDebugImage(ctx android.LoadHookContext, dtbImg dtbImg, ramdiskFragmentModules []string) bool {
 partitionVariables := ctx.Config().ProductVariables().PartitionVarsForSoongMigrationOnlyDoNotUse

 bootImageName := generatedModuleNameForPartition(ctx.Config(), "vendor_boot-debug")

 avbInfo := getAvbInfo(ctx.Config(), "vendor_boot")

 var dtbPrebuilt *string
 if dtbImg.include && dtbImg.imgType == "vendor_boot" {
  dtbPrebuilt = proptools.StringPtr(":" + dtbImg.name)
 }

 cmdline := partitionVariables.InternalKernelCmdline

 var vendorBootConfigImg *string
 if name := getVendorBootConfigImgName(ctx); name != "" {
  vendorBootConfigImg = proptools.StringPtr(":" + name)
 }

 partitionSize := getPartitionSizeFromString(ctx, partitionVariables.BoardVendorBootimagePartitionSize, "BOARD_VENDOR_BOOTIMAGE_PARTITION_SIZE")

 ctx.CreateModule(
  filesystem.BootimgFactory,
  &filesystem.BootimgProperties{
   Ramdisk_module:           proptools.StringPtr(generatedModuleNameForPartition(ctx.Config(), "vendor_ramdisk-debug")),
   Ramdisk_fragment_modules: ramdiskFragmentModules,
   Dtb_prebuilt:             dtbPrebuilt,
   Cmdline:                  cmdline,
   Bootconfig:               vendorBootConfigImg,
   Stem:                     proptools.StringPtr("vendor_boot-debug.img"),
  },
  &filesystem.CommonBootimgProperties{
   Boot_image_type:             proptools.StringPtr("vendor_boot"),
   Partition_name:              proptools.StringPtr("vendor_boot"),
   Header_version:              proptools.StringPtr(partitionVariables.BoardBootHeaderVersion),
   Partition_size:              partitionSize,
   Use_avb:                     avbInfo.avbEnable,
   Avb_mode:                    avbInfo.avbMode,
   Avb_private_key:             avbInfo.avbkeyFilegroup,
   Avb_rollback_index:          avbInfo.avbRollbackIndex,
   Avb_rollback_index_location: avbInfo.avbRollbackIndexLocation,
  },

  &struct {
   Name       *string
   Visibility []string
  }{
   Name:       proptools.StringPtr(bootImageName),
   Visibility: []string{"//visibility:public"},
  },
 )
 return true
}

// Same as vendor_boot-debug, with the exception of some additional properties in the installed adb_debug.prop file.
func createVendorBootTestHarnessImage(ctx android.LoadHookContext, dtbImg dtbImg, ramdiskFragmentModules []string) bool {
 partitionVariables := ctx.Config().ProductVariables().PartitionVarsForSoongMigrationOnlyDoNotUse

 bootImageName := generatedModuleNameForPartition(ctx.Config(), "vendor_boot-test-harness")

 avbInfo := getAvbInfo(ctx.Config(), "vendor_boot")

 var dtbPrebuilt *string
 if dtbImg.include && dtbImg.imgType == "vendor_boot" {
  dtbPrebuilt = proptools.StringPtr(":" + dtbImg.name)
 }

 cmdline := partitionVariables.InternalKernelCmdline

 var vendorBootConfigImg *string
 if name := getVendorBootConfigImgName(ctx); name != "" {
  vendorBootConfigImg = proptools.StringPtr(":" + name)
 }

 partitionSize := getPartitionSizeFromString(ctx, partitionVariables.BoardVendorBootimagePartitionSize, "BOARD_VENDOR_BOOTIMAGE_PARTITION_SIZE")

 ctx.CreateModule(
  filesystem.BootimgFactory,
  &filesystem.BootimgProperties{
   Ramdisk_module:           proptools.StringPtr(generatedModuleNameForPartition(ctx.Config(), "vendor_ramdisk-test-harness")),
   Ramdisk_fragment_modules: ramdiskFragmentModules,
   Dtb_prebuilt:             dtbPrebuilt,
   Cmdline:                  cmdline,
   Bootconfig:               vendorBootConfigImg,
   Stem:                     proptools.StringPtr("vendor_boot-test-harness.img"),
  },
  &filesystem.CommonBootimgProperties{
   Boot_image_type:             proptools.StringPtr("vendor_boot"),
   Partition_name:              proptools.StringPtr("vendor_boot"),
   Header_version:              proptools.StringPtr(partitionVariables.BoardBootHeaderVersion),
   Partition_size:              partitionSize,
   Use_avb:                     avbInfo.avbEnable,
   Avb_mode:                    avbInfo.avbMode,
   Avb_private_key:             avbInfo.avbkeyFilegroup,
   Avb_rollback_index:          avbInfo.avbRollbackIndex,
   Avb_rollback_index_location: avbInfo.avbRollbackIndexLocation,
  },

  &struct {
   Name       *string
   Visibility []string
  }{
   Name:       proptools.StringPtr(bootImageName),
   Visibility: []string{"//visibility:public"},
  },
 )
 return true
}

func createVendorKernelBootImage(ctx android.LoadHookContext, dtbImg dtbImg) bool {
 vendorKernelBootVariables, exists := ctx.Config().ProductVariables().PartitionVarsForSoongMigrationOnlyDoNotUse.PartitionQualifiedVariables["vendor_kernel_boot"]
 if !exists {
  return false
 }

 bootImageName := generatedModuleNameForPartition(ctx.Config(), "vendor_kernel_boot")

 avbInfo := getAvbInfo(ctx.Config(), "vendor_kernel_boot")

 var dtbPrebuilt *string
 if dtbImg.include && dtbImg.imgType == "vendor_kernel_boot" {
  dtbPrebuilt = proptools.StringPtr(":" + dtbImg.name)
 }

 partitionSize := getPartitionSizeFromString(ctx, vendorKernelBootVariables.BoardPartitionSize, "BOARD_VENDOR_KERNEL_BOOTIMAGE_PARTITION_SIZE")

 ctx.CreateModule(
  filesystem.BootimgFactory,
  &filesystem.BootimgProperties{
   Ramdisk_module: proptools.StringPtr(generatedModuleNameForPartition(ctx.Config(), "vendor_kernel_ramdisk")),
   Dtb_prebuilt:   dtbPrebuilt,
   Stem:           proptools.StringPtr("vendor_kernel_boot.img"),
  },
  &filesystem.CommonBootimgProperties{
   Boot_image_type:             proptools.StringPtr("vendor_kernel_boot"),
   Partition_name:              proptools.StringPtr("vendor_kernel_boot"),
   Header_version:              proptools.StringPtr("4"),
   Partition_size:              partitionSize,
   Use_avb:                     avbInfo.avbEnable,
   Avb_mode:                    avbInfo.avbMode,
   Avb_private_key:             avbInfo.avbkeyFilegroup,
   Avb_rollback_index:          avbInfo.avbRollbackIndex,
   Avb_rollback_index_location: avbInfo.avbRollbackIndexLocation,
  },

  &struct {
   Name       *string
   Visibility []string
  }{
   Name:       proptools.StringPtr(bootImageName),
   Visibility: []string{"//visibility:public"},
  },
 )
 return true
}

func createInitBootImage(ctx android.LoadHookContext) bool {
 partitionVariables := ctx.Config().ProductVariables().PartitionVarsForSoongMigrationOnlyDoNotUse

 bootImageName := generatedModuleNameForPartition(ctx.Config(), "init_boot")

 var securityPatch *string
 if partitionVariables.InitBootSecurityPatch != "" {
  securityPatch = &partitionVariables.InitBootSecurityPatch
 } else if partitionVariables.BootSecurityPatch != "" {
  securityPatch = &partitionVariables.BootSecurityPatch
 }

 partitionSize := getPartitionSizeFromString(ctx, partitionVariables.BoardInitBootimagePartitionSize, "BOARD_INIT_BOOT_IMAGE_PARTITION_SIZE")

 avbInfo := getAvbInfo(ctx.Config(), "init_boot")

 ctx.CreateModule(
  filesystem.BootimgFactory,
  &filesystem.BootimgProperties{
   Ramdisk_module: proptools.StringPtr(generatedModuleNameForPartition(ctx.Config(), "ramdisk")),
   Stem:           proptools.StringPtr("init_boot.img"),
  },
  &filesystem.CommonBootimgProperties{
   Boot_image_type:             proptools.StringPtr("init_boot"),
   Partition_name:              proptools.StringPtr("init_boot"),
   Header_version:              proptools.StringPtr(partitionVariables.BoardInitBootHeaderVersion),
   Partition_size:              partitionSize,
   Use_avb:                     avbInfo.avbEnable,
   Avb_mode:                    avbInfo.avbMode,
   Avb_private_key:             avbInfo.avbkeyFilegroup,
   Avb_rollback_index:          avbInfo.avbRollbackIndex,
   Avb_rollback_index_location: avbInfo.avbRollbackIndexLocation,
   Avb_algorithm:               avbInfo.avbAlgorithm,
   Security_patch:              securityPatch,
  },
  &struct {
   Name       *string
   Visibility []string
  }{
   Name:       proptools.StringPtr(bootImageName),
   Visibility: []string{"//visibility:public"},
  },
 )
 return true
}

// Returns true if the product contains a boot image (built from source or prebuilt)
func buildingBootImage(partitionVars android.PartitionVariables) bool {
 if partitionVars.BoardUsesRecoveryAsBoot {
  return false
 }

 if partitionVars.ProductBuildBootImage {
  return true
 }

 if len(partitionVars.BoardBootimagePartitionSize) > 0 {
  return true
 }

 // TODO: return true if BOARD_KERNEL_BINARIES is set and has a *_BOOTIMAGE_PARTITION_SIZE
 // variable. However, I don't think BOARD_KERNEL_BINARIES is ever set in practice.

 return false
}

// Returns the equivalent of the BUILDING_VENDOR_BOOT_IMAGE variable in make. Derived from this logic:
// https://cs.android.com/android/platform/superproject/main/+/main:build/make/core/board_config.mk;l=518;drc=5b55f926830963c02ab1d2d91e46442f04ba3af0
func buildingVendorBootImage(partitionVars android.PartitionVariables) bool {
 if v, exists := boardBootHeaderVersion(partitionVars); exists && v >= 3 {
  x := partitionVars.ProductBuildVendorBootImage
  if x == "" || x == "true" {
   return true
  }
 }

 return false
}

func buildingDebugVendorBootImage(partitionVars android.PartitionVariables) bool {
 return buildingVendorBootImage(partitionVars) && partitionVars.BuildingDebugVendorBootImage
}

func buildingDebugRamdiskImage(partitionVars android.PartitionVariables) bool {
 return partitionVars.BuildingDebugBootImage || partitionVars.BuildingDebugVendorBootImage
}

func buildingVendorKernelBootImage(partitionVars android.PartitionVariables) bool {
 vendorKernelBootVariables, exists := partitionVars.PartitionQualifiedVariables["vendor_kernel_boot"]
 return exists && vendorKernelBootVariables.BuildingImage
}

func buildingVendorRamdiskFragmentDlkm(ctx android.EarlyModuleContext, partitionVars android.PartitionVariables) bool {
 if len(partitionVars.BoardVendorRamdiskFragments) == 0 {
  return false
 }
 if len(partitionVars.BoardVendorRamdiskFragments) > 1 || partitionVars.BoardVendorRamdiskFragments[0] != "dlkm" {
  ctx.ModuleErrorf("Multiple vendor ramdisk fragments is currently not supported in soong only builds")
 }
 return true
}

// Derived from: https://cs.android.com/android/platform/superproject/main/+/main:build/make/core/board_config.mk;l=480;drc=5b55f926830963c02ab1d2d91e46442f04ba3af0
func buildingInitBootImage(partitionVars android.PartitionVariables) bool {
 if !partitionVars.ProductBuildInitBootImage {
  if partitionVars.BoardUsesRecoveryAsBoot || len(partitionVars.BoardPrebuiltInitBootimage) > 0 {
   return false
  } else if len(partitionVars.BoardInitBootimagePartitionSize) > 0 {
   return true
  }
 } else {
  if partitionVars.BoardUsesRecoveryAsBoot {
   panic("PRODUCT_BUILD_INIT_BOOT_IMAGE is true, but so is BOARD_USES_RECOVERY_AS_BOOT. Use only one option.")
  }
  return true
 }
 return false
}

func boardBootHeaderVersion(partitionVars android.PartitionVariables) (int, bool) {
 if len(partitionVars.BoardBootHeaderVersion) == 0 {
  return 0, false
 }
 v, err := strconv.ParseInt(partitionVars.BoardBootHeaderVersion, 10, 32)
 if err != nil {
  panic(fmt.Sprintf("BOARD_BOOT_HEADER_VERSION must be an int, got: %q", partitionVars.BoardBootHeaderVersion))
 }
 return int(v), true
}

type dtbImg struct {
 // whether to include the dtb image in boot image
 include bool

 // name of the generated dtb image filegroup name
 name string

 // type of the boot image that the dtb image argument should be specified
 imgType string
}

func createDtbImgFilegroup(ctx android.LoadHookContext) dtbImg {
 partitionVars := ctx.Config().ProductVariables().PartitionVarsForSoongMigrationOnlyDoNotUse
 if !partitionVars.BoardIncludeDtbInBootimg {
  return dtbImg{include: false}
 }
 moduleName := generatedModuleName(ctx.Config(), "dtb_img_filegroup")
 imgType := "vendor_boot"
 if !buildingVendorBootImage(partitionVars) {
  imgType = "boot"
 }
 if buildingVendorKernelBootImage(partitionVars) {
  // https://cs.android.com/android/platform/superproject/main/+/main:build/make/core/Makefile;l=1655-1658?q=INTERNAL_VENDOR_BOOTIMAGE_ARGS&ss=android%>2Fplatform%2Fsuperproject%2Fmain
  // If we have vendor_kernel_boot partition, we migrate dtb image to that image
  // and allow dtb in vendor_boot to be empty.
  imgType = "vendor_kernel_boot"
 }
 if partitionVars.BoardPrebuiltDtbDir != "" {
  // https://cs.android.com/android/platform/superproject/main/+/main:build/make/core/Makefile;l=1019-1022?q=BOARD_PREBUILT_DTBIMAGE_DIR&ss=android%2Fplatform%2Fsuperproject%2Fmaini
  ctx.CreateModuleInDirectory(
   genrule.GenRuleFactory,
   ".",
   &struct {
    Name *string
    Srcs []string
    Out  []string
    Cmd  *string
   }{
    Name: proptools.StringPtr(moduleName),
    Srcs: []string{fmt.Sprintf("%s/*.dtb", partitionVars.BoardPrebuiltDtbDir)},
    Out:  []string{"dtb.img"},
    Cmd:  proptools.StringPtr("cat $(in) > $(out)"),
   },
  )
  return dtbImg{include: true, name: moduleName, imgType: imgType}
 }
 for _, copyFilePair := range partitionVars.ProductCopyFiles {
  srcDestList := strings.Split(copyFilePair, ":")
  if len(srcDestList) < 2 {
   ctx.ModuleErrorf("PRODUCT_COPY_FILES must follow the format \"src:dest\", got: %s", copyFilePair)
  }
  if srcDestList[1] == "dtb.img" {
   ctx.CreateModuleInDirectory(
    android.FileGroupFactory,
    filepath.Dir(srcDestList[0]),
    &struct {
     Name *string
     Srcs []string
    }{
     Name: proptools.StringPtr(moduleName),
     Srcs: []string{filepath.Base(srcDestList[1])},
    },
   )
   return dtbImg{include: true, name: moduleName, imgType: imgType}
  }
 }
 return dtbImg{include: false}
}

func getVendorBootConfigImgName(ctx android.LoadHookContext) string {
 partitionVars := ctx.Config().ProductVariables().PartitionVarsForSoongMigrationOnlyDoNotUse
 bootconfig := partitionVars.InternalBootconfig
 bootconfigFile := partitionVars.InternalBootconfigFile
 if len(bootconfig) == 0 && len(bootconfigFile) == 0 {
  return ""
 }

 return generatedModuleName(ctx.Config(), "vendor_bootconfig_image")
}

func createVendorBootConfigImg(ctx android.LoadHookContext) (string, bool) {
 vendorBootconfigImgModuleName := getVendorBootConfigImgName(ctx)
 if vendorBootconfigImgModuleName == "" {
  return "", false
 }
 partitionVars := ctx.Config().ProductVariables().PartitionVarsForSoongMigrationOnlyDoNotUse
 bootconfig := partitionVars.InternalBootconfig
 bootconfigFile := partitionVars.InternalBootconfigFile
 ctx.CreateModule(
  filesystem.BootconfigModuleFactory,
  &struct {
   Name             *string
   Boot_config      []string
   Boot_config_file *string
  }{
   Name:             proptools.StringPtr(vendorBootconfigImgModuleName),
   Boot_config:      bootconfig,
   Boot_config_file: proptools.StringPtr(bootconfigFile),
  },
 )

 return vendorBootconfigImgModuleName, true
}

func createPrebuiltDtboImages(ctx android.LoadHookContext) (string, string) {
 partitionVars := ctx.Config().ProductVariables().PartitionVarsForSoongMigrationOnlyDoNotUse

 dtboModuleName := getDtboModuleName(ctx)
 dtbo16kModuleName := getDtbo16kModuleName(ctx)

 if dtboModuleName != "" {
  size, _ := strconv.ParseInt(partitionVars.BoardDtboPartitionSize, 0, 64)
  ctx.CreateModuleInDirectory(
   filesystem.PrebuiltDtboImgFactory,
   ".",
   &struct {
    Name           *string
    Src            *string
    Partition_size *int64
   }{
    Name:           proptools.StringPtr(dtboModuleName),
    Src:            proptools.StringPtr(partitionVars.BoardPrebuiltDtboImage),
    Partition_size: proptools.Int64Ptr(size),
   },
  )
 }

 if dtbo16kModuleName != "" {
  size, _ := strconv.ParseInt(partitionVars.BoardDtboPartitionSize, 0, 64)
  ctx.CreateModuleInDirectory(
   filesystem.PrebuiltDtboImgFactory,
   ".",
   &struct {
    Name           *string
    Src            *string
    Partition_size *int64
    Stem           *string
   }{
    Name:           proptools.StringPtr(dtbo16kModuleName),
    Src:            proptools.StringPtr(partitionVars.BoardPrebuiltDtboImage16kb),
    Partition_size: proptools.Int64Ptr(size),
    Stem:           proptools.StringPtr("dtbo_16k.img"),
   },
  )
 }

 return dtboModuleName, dtbo16kModuleName
}

func getDtboModuleName(ctx android.LoadHookContext) string {
 partitionVars := ctx.Config().ProductVariables().PartitionVarsForSoongMigrationOnlyDoNotUse
 if partitionVars.BoardPrebuiltDtboImage != "" {
  file := android.ExistentPathForSource(ctx, partitionVars.BoardPrebuiltDtboImage)
  if file.Valid() {
   return generatedModuleNameForPartition(ctx.Config(), "dtbo")
  }
 }
 return ""
}

func getDtbo16kModuleName(ctx android.LoadHookContext) string {
 partitionVars := ctx.Config().ProductVariables().PartitionVarsForSoongMigrationOnlyDoNotUse
 if partitionVars.BoardPrebuiltDtboImage16kb != "" {
  return generatedModuleNameForPartition(ctx.Config(), "dtbo_16k")
 }
 return ""
}

func createBootOtas16kModules(ctx android.LoadHookContext, dtboModuleName, dtbo16kModuleName string) string {
 partitionVars := ctx.Config().ProductVariables().PartitionVarsForSoongMigrationOnlyDoNotUse
 if partitionVars.BoardKernelPath16k == "" {
  return ""
 }

 name := generatedModuleName(ctx.Config(), "boot_otas_16k")
 props := filesystem.BootOtas16kProperties{
  Boot_image:          proptools.StringPtr(":" + generatedModuleName(ctx.Config(), "boot_image")),
  Boot_image_16k:      proptools.StringPtr(":" + generatedModuleName(ctx.Config(), "boot_16k_image")),
  Use_ota_incremental: proptools.BoolPtr(partitionVars.Board16kOtaUseIncremental),
 }
 if dtboModuleName != "" {
  props.Dtbo_image = proptools.StringPtr(":" + dtboModuleName)
 }
 if dtbo16kModuleName != "" {
  props.Dtbo_image_16k = proptools.StringPtr(":" + dtbo16kModuleName)

 }
 ctx.CreateModuleInDirectory(
  filesystem.BootOtas16kFactory,
  ".",
  &struct {
   Name   *string
   Vendor *bool
  }{
   Name:   proptools.StringPtr(name),
   Vendor: proptools.BoolPtr(true),
  },
  &props,
 )
 return name
}