import { createHash } from 'node:crypto'
import {
  cpSync,
  mkdirSync,
  mkdtempSync,
  readFileSync,
  readdirSync,
  rmSync,
  statSync,
  unlinkSync,
  writeFileSync
} from 'node:fs'
import { tmpdir } from 'node:os'
import { basename, dirname, join, resolve, sep } from 'node:path'
import { fileURLToPath } from 'node:url'
import { inflateSync } from 'node:zlib'

const workspaceRoot = resolve(dirname(fileURLToPath(import.meta.url)), '..', '..')
const featureAssetDirectoryRelative = 'docs/v3/play/assets/feature-graphic'
const mobileIconManifestRelative = 'docs/v3/play/assets/mobile-icon-manifest.json'
const pngSignature = Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a])
const androidLegacyDensities = new Map([
  ['mdpi', 48],
  ['hdpi', 72],
  ['xhdpi', 96],
  ['xxhdpi', 144],
  ['xxxhdpi', 192]
])
const requiredIosSlots = [
  ['iphone', '20x20', '2x', 'AppIcon-iphone-20@2x.png', 40],
  ['iphone', '20x20', '3x', 'AppIcon-iphone-20@3x.png', 60],
  ['iphone', '29x29', '2x', 'AppIcon-iphone-29@2x.png', 58],
  ['iphone', '29x29', '3x', 'AppIcon-iphone-29@3x.png', 87],
  ['iphone', '40x40', '2x', 'AppIcon-iphone-40@2x.png', 80],
  ['iphone', '40x40', '3x', 'AppIcon-iphone-40@3x.png', 120],
  ['iphone', '60x60', '2x', 'AppIcon-iphone-60@2x.png', 120],
  ['iphone', '60x60', '3x', 'AppIcon-iphone-60@3x.png', 180],
  ['ipad', '20x20', '1x', 'AppIcon-ipad-20@1x.png', 20],
  ['ipad', '20x20', '2x', 'AppIcon-ipad-20@2x.png', 40],
  ['ipad', '29x29', '1x', 'AppIcon-ipad-29@1x.png', 29],
  ['ipad', '29x29', '2x', 'AppIcon-ipad-29@2x.png', 58],
  ['ipad', '40x40', '1x', 'AppIcon-ipad-40@1x.png', 40],
  ['ipad', '40x40', '2x', 'AppIcon-ipad-40@2x.png', 80],
  ['ipad', '76x76', '1x', 'AppIcon-ipad-76@1x.png', 76],
  ['ipad', '76x76', '2x', 'AppIcon-ipad-76@2x.png', 152],
  ['ipad', '83.5x83.5', '2x', 'AppIcon-ipad-83.5@2x.png', 167],
  ['ios-marketing', '1024x1024', '1x', 'AppIcon-marketing-1024@1x.png', 1024]
]

function fail(code) {
  throw new Error(`play_store_asset_verification_failed:${code}`)
}

function assert(condition, code) {
  if (!condition) fail(code)
}

function comparablePath(path) {
  return process.platform === 'win32' ? path.toLowerCase() : path
}

function resolveInside(baseDirectory, relativePath, code = 'invalid_asset_path') {
  assert(typeof relativePath === 'string' && relativePath.length > 0, 'invalid_asset_path')
  const absolutePath = resolve(baseDirectory, relativePath)
  const comparableBase = comparablePath(baseDirectory)
  const comparableAbsolute = comparablePath(absolutePath)
  assert(
    comparableAbsolute.startsWith(`${comparableBase}${sep}`),
    `${code}_outside_allowed_directory`
  )
  return absolutePath
}

function sha256(buffer) {
  return createHash('sha256').update(buffer).digest('hex').toUpperCase()
}

function readRequired(baseDirectory, relativePath, code) {
  const absolutePath = resolveInside(baseDirectory, relativePath, code)
  try {
    const file = readFileSync(absolutePath)
    assert(statSync(absolutePath).isFile(), `${code}_not_file`)
    return { absolutePath, file }
  } catch (error) {
    if (error?.code === 'ENOENT') fail(`${code}_missing`)
    throw error
  }
}

function readJson(baseDirectory, relativePath, code) {
  const { file } = readRequired(baseDirectory, relativePath, code)
  try {
    return JSON.parse(file.toString('utf8'))
  } catch {
    fail(`${code}_invalid_json`)
  }
}

function readPngHeader(buffer, filename) {
  assert(buffer.length >= 33, `truncated_png_${filename}`)
  assert(buffer.subarray(0, 8).equals(pngSignature), `invalid_png_signature_${filename}`)
  assert(buffer.readUInt32BE(8) === 13, `invalid_ihdr_length_${filename}`)
  assert(buffer.subarray(12, 16).toString('ascii') === 'IHDR', `missing_ihdr_${filename}`)
  return {
    width: buffer.readUInt32BE(16),
    height: buffer.readUInt32BE(20),
    bitDepth: buffer[24],
    colorType: buffer[25],
    compression: buffer[26],
    filter: buffer[27],
    interlace: buffer[28]
  }
}

function parsePng(buffer, filename) {
  const header = readPngHeader(buffer, filename)
  const idat = []
  let hasTransparencyChunk = false
  let sawIend = false
  let offset = 8
  while (offset < buffer.length) {
    assert(offset + 12 <= buffer.length, `truncated_png_chunk_${filename}`)
    const length = buffer.readUInt32BE(offset)
    const type = buffer.subarray(offset + 4, offset + 8).toString('ascii')
    const dataStart = offset + 8
    const dataEnd = dataStart + length
    assert(dataEnd + 4 <= buffer.length, `truncated_png_chunk_${filename}`)
    if (type === 'IDAT') idat.push(buffer.subarray(dataStart, dataEnd))
    if (type === 'tRNS') hasTransparencyChunk = true
    offset = dataEnd + 4
    if (type === 'IEND') {
      sawIend = true
      break
    }
  }
  assert(sawIend, `missing_png_iend_${filename}`)
  return { ...header, idat, hasTransparencyChunk }
}

function paethPredictor(left, up, upperLeft) {
  const predictor = left + up - upperLeft
  const leftDistance = Math.abs(predictor - left)
  const upDistance = Math.abs(predictor - up)
  const upperLeftDistance = Math.abs(predictor - upperLeft)
  if (leftDistance <= upDistance && leftDistance <= upperLeftDistance) return left
  if (upDistance <= upperLeftDistance) return up
  return upperLeft
}

function rgba8AlphaRange(png, filename) {
  assert(png.bitDepth === 8 && png.colorType === 6, `unsupported_alpha_png_${filename}`)
  assert(png.compression === 0 && png.filter === 0, `unsupported_png_encoding_${filename}`)
  assert(png.interlace === 0, `interlaced_png_${filename}`)
  assert(png.idat.length > 0, `missing_png_idat_${filename}`)

  const bytesPerPixel = 4
  const rowBytes = png.width * bytesPerPixel
  const inflated = inflateSync(Buffer.concat(png.idat))
  assert(inflated.length === (rowBytes + 1) * png.height, `unexpected_png_data_length_${filename}`)

  let minimum = 255
  let maximum = 0
  let previousRow = Buffer.alloc(rowBytes)
  let inputOffset = 0
  for (let y = 0; y < png.height; y += 1) {
    const filterType = inflated[inputOffset]
    inputOffset += 1
    assert(filterType <= 4, `invalid_png_filter_${filename}`)
    const row = Buffer.allocUnsafe(rowBytes)
    for (let x = 0; x < rowBytes; x += 1) {
      const raw = inflated[inputOffset + x]
      const left = x >= bytesPerPixel ? row[x - bytesPerPixel] : 0
      const up = previousRow[x]
      const upperLeft = x >= bytesPerPixel ? previousRow[x - bytesPerPixel] : 0
      let value = raw
      if (filterType === 1) value += left
      if (filterType === 2) value += up
      if (filterType === 3) value += Math.floor((left + up) / 2)
      if (filterType === 4) value += paethPredictor(left, up, upperLeft)
      row[x] = value & 0xff
    }
    for (let x = 3; x < rowBytes; x += bytesPerPixel) {
      minimum = Math.min(minimum, row[x])
      maximum = Math.max(maximum, row[x])
    }
    inputOffset += rowBytes
    previousRow = row
  }
  return { minimum, maximum }
}

function verifyPng(baseDirectory, relativePath, expected, code) {
  const { file } = readRequired(baseDirectory, relativePath, code)
  assert(sha256(file) === expected.sha256, `${code}_hash`)
  const png = parsePng(file, basename(relativePath))
  assert(png.width === expected.width, `${code}_width`)
  assert(png.height === expected.height, `${code}_height`)
  assert(png.bitDepth === expected.bitDepth, `${code}_bit_depth`)
  assert(png.colorType === expected.colorType, `${code}_color_type`)

  if (expected.alpha === 'opaque') {
    if (png.colorType === 6) {
      const alpha = rgba8AlphaRange(png, basename(relativePath))
      assert(alpha.minimum === 255 && alpha.maximum === 255, `${code}_not_opaque`)
    } else {
      assert(!png.hasTransparencyChunk, `${code}_transparency_chunk`)
    }
  }
  if (expected.alpha === 'has_transparency') {
    const alpha = rgba8AlphaRange(png, basename(relativePath))
    assert(alpha.minimum < 255 && alpha.maximum === 255, `${code}_transparency_range`)
  }
  if (expected.alpha === 'no_alpha_channel') {
    assert(png.colorType !== 4 && png.colorType !== 6, `${code}_alpha_channel`)
    assert(!png.hasTransparencyChunk, `${code}_transparency_chunk`)
  }
}

function escapeRegExp(value) {
  return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
}

function verifySvg(baseDirectory, asset, code) {
  const { file } = readRequired(baseDirectory, asset.path, code)
  assert(sha256(file) === asset.sha256, `${code}_hash`)
  const text = file.toString('utf8')
  assert(/<svg\b/.test(text), `${code}_not_svg`)
  assert(new RegExp(`viewBox=["']${escapeRegExp(asset.viewBox)}["']`).test(text), `${code}_viewbox`)
}

function verifyFeatureGraphics(root) {
  const assetDirectory = resolveInside(
    root,
    featureAssetDirectoryRelative,
    'feature_asset_directory'
  )
  const manifest = readJson(assetDirectory, 'manifest.json', 'feature_manifest')
  assert(manifest.schemaVersion === 2, 'manifest_schema')
  assert(Array.isArray(manifest.candidates) && manifest.candidates.length === 4, 'candidate_count')
  assert(manifest.selection?.status === 'selected_console_preview_verified', 'selection_status')

  const candidateIds = new Set()
  for (const candidate of manifest.candidates) {
    assert(!candidateIds.has(candidate.id), `duplicate_candidate_${candidate.id}`)
    candidateIds.add(candidate.id)

    const source = readRequired(assetDirectory, candidate.source, `source_${candidate.id}`)
    const output = readRequired(assetDirectory, candidate.output, `output_${candidate.id}`)

    assert(
      statSync(source.absolutePath).size === candidate.sourceBytes,
      `source_size_${candidate.id}`
    )
    assert(
      statSync(output.absolutePath).size === candidate.outputBytes,
      `output_size_${candidate.id}`
    )
    assert(sha256(source.file) === candidate.sourceSha256, `source_hash_${candidate.id}`)
    assert(sha256(output.file) === candidate.outputSha256, `output_hash_${candidate.id}`)

    const sourceText = source.file.toString('utf8')
    assert(/<svg\b/.test(sourceText), `source_not_svg_${candidate.id}`)
    assert(/viewBox="0 0 1024 500"/.test(sourceText), `source_viewbox_${candidate.id}`)

    const png = readPngHeader(output.file, candidate.output)
    assert(png.width === manifest.export.width, `png_width_${candidate.id}`)
    assert(png.height === manifest.export.height, `png_height_${candidate.id}`)
    assert(png.bitDepth === manifest.export.bitDepth, `png_bit_depth_${candidate.id}`)
    assert(png.colorType === manifest.export.pngColorType, `png_color_type_${candidate.id}`)
  }

  const canonical = manifest.canonical
  assert(canonical?.id === manifest.selection.recommended, 'canonical_selection')
  assert(!candidateIds.has(canonical.id), 'canonical_id_conflict')

  const canonicalSource = readRequired(assetDirectory, canonical.source, 'feature_canonical_source')
  const canonicalPrompt = readRequired(assetDirectory, canonical.prompt, 'feature_canonical_prompt')
  const canonicalOutput = readRequired(assetDirectory, canonical.output, 'feature_canonical_output')
  assert(
    statSync(canonicalSource.absolutePath).size === canonical.sourceBytes,
    'feature_canonical_source_size'
  )
  assert(
    statSync(canonicalPrompt.absolutePath).size === canonical.promptBytes,
    'feature_canonical_prompt_size'
  )
  assert(
    statSync(canonicalOutput.absolutePath).size === canonical.outputBytes,
    'feature_canonical_output_size'
  )
  assert(sha256(canonicalSource.file) === canonical.sourceSha256, 'feature_canonical_source_hash')
  assert(sha256(canonicalPrompt.file) === canonical.promptSha256, 'feature_canonical_prompt_hash')
  verifyPng(
    assetDirectory,
    canonical.output,
    {
      sha256: canonical.outputSha256,
      width: manifest.export.width,
      height: manifest.export.height,
      bitDepth: manifest.export.bitDepth,
      colorType: manifest.export.pngColorType,
      alpha: 'no_alpha_channel'
    },
    'feature_canonical'
  )

  return {
    candidateCount: manifest.candidates.length,
    canonicalId: canonical.id
  }
}

function verifyAndroidIcons(root, android) {
  assert(android.icon === '@mipmap/ic_launcher', 'android_icon_contract')
  assert(android.roundIcon === '@mipmap/ic_launcher_round', 'android_round_icon_contract')
  const manifest = readRequired(
    root,
    android.applicationManifest,
    'android_manifest'
  ).file.toString('utf8')
  assert(
    new RegExp(`android:icon\\s*=\\s*["']${escapeRegExp(android.icon)}["']`).test(manifest),
    'android_manifest_icon'
  )
  assert(
    new RegExp(`android:roundIcon\\s*=\\s*["']${escapeRegExp(android.roundIcon)}["']`).test(
      manifest
    ),
    'android_manifest_round_icon'
  )

  const colors = readRequired(
    root,
    android.background.path,
    'android_launcher_colors'
  ).file.toString('utf8')
  const backgroundPattern = new RegExp(
    `<color\\s+name=["']${escapeRegExp(android.background.resource)}["']\\s*>\\s*${escapeRegExp(android.background.value)}\\s*</color>`,
    'i'
  )
  assert(backgroundPattern.test(colors), 'android_launcher_background')

  assert(
    Array.isArray(android.sourceAssets) && android.sourceAssets.length === 2,
    'android_source_count'
  )
  android.sourceAssets.forEach((asset, index) => verifySvg(root, asset, `android_source_${index}`))

  for (const [role, expectedPath] of [
    ['foreground', 'apps/mobile-rn/android/app/src/main/res/drawable/d3ro_launcher_foreground.xml'],
    ['monochrome', 'apps/mobile-rn/android/app/src/main/res/drawable/d3ro_launcher_monochrome.xml']
  ]) {
    const vector = android.vectors?.[role]
    assert(vector?.path === expectedPath, `android_${role}_vector_path`)
    const { file } = readRequired(root, vector.path, `android_${role}_vector`)
    assert(sha256(file) === vector.sha256, `android_${role}_vector_hash`)
    const text = file.toString('utf8')
    assert(/<vector\b/.test(text), `android_${role}_vector_root`)
    assert(/android:viewportWidth="108"/.test(text), `android_${role}_vector_width`)
    assert(/android:viewportHeight="108"/.test(text), `android_${role}_vector_height`)
  }

  assert(
    Array.isArray(android.adaptiveIcons) && android.adaptiveIcons.length === 4,
    'android_adaptive_icon_count'
  )
  const requiredAdaptivePaths = new Map([
    ['apps/mobile-rn/android/app/src/main/res/mipmap-anydpi-v26/ic_launcher.xml', false],
    ['apps/mobile-rn/android/app/src/main/res/mipmap-anydpi-v26/ic_launcher_round.xml', false],
    ['apps/mobile-rn/android/app/src/main/res/mipmap-anydpi-v33/ic_launcher.xml', true],
    ['apps/mobile-rn/android/app/src/main/res/mipmap-anydpi-v33/ic_launcher_round.xml', true]
  ])
  const adaptivePaths = new Set()
  for (const adaptive of android.adaptiveIcons) {
    assert(!adaptivePaths.has(adaptive.path), 'android_adaptive_icon_duplicate')
    adaptivePaths.add(adaptive.path)
    assert(requiredAdaptivePaths.has(adaptive.path), 'android_adaptive_icon_path')
    assert(
      adaptive.monochrome === requiredAdaptivePaths.get(adaptive.path),
      'android_adaptive_icon_api_contract'
    )
    const text = readRequired(root, adaptive.path, 'android_adaptive_icon').file.toString('utf8')
    assert(/<adaptive-icon\b/.test(text), 'android_adaptive_icon_root')
    assert(
      /<background\s+android:drawable="@color\/d3ro_launcher_background"\s*\/>/.test(text),
      'android_adaptive_icon_background'
    )
    assert(
      /<foreground\s+android:drawable="@drawable\/d3ro_launcher_foreground"\s*\/>/.test(text),
      'android_adaptive_icon_foreground'
    )
    const hasMonochrome =
      /<monochrome\s+android:drawable="@drawable\/d3ro_launcher_monochrome"\s*\/>/.test(text)
    assert(hasMonochrome === adaptive.monochrome, 'android_adaptive_icon_monochrome')
    assert(adaptive.path.includes(adaptive.monochrome ? '-v33/' : '-v26/'), 'android_adaptive_api')
  }
  for (const requiredPath of requiredAdaptivePaths.keys()) {
    assert(
      adaptivePaths.has(requiredPath),
      `android_adaptive_icon_missing_${basename(requiredPath)}`
    )
  }

  assert(
    Array.isArray(android.legacyIcons) &&
      android.legacyIcons.length === androidLegacyDensities.size,
    'android_legacy_icon_count'
  )
  const densities = new Set()
  for (const legacy of android.legacyIcons) {
    const expectedPixels = androidLegacyDensities.get(legacy.density)
    assert(expectedPixels !== undefined, `android_density_${legacy.density}`)
    assert(!densities.has(legacy.density), `android_density_duplicate_${legacy.density}`)
    densities.add(legacy.density)
    assert(legacy.pixels === expectedPixels, `android_density_pixels_${legacy.density}`)
    const basePath = `apps/mobile-rn/android/app/src/main/res/mipmap-${legacy.density}`
    assert(legacy.iconPath === `${basePath}/ic_launcher.png`, `android_icon_path_${legacy.density}`)
    assert(
      legacy.roundPath === `${basePath}/ic_launcher_round.png`,
      `android_round_path_${legacy.density}`
    )
    const expected = {
      width: expectedPixels,
      height: expectedPixels,
      bitDepth: 8,
      colorType: 6,
      alpha: 'has_transparency'
    }
    verifyPng(
      root,
      legacy.iconPath,
      { ...expected, sha256: legacy.iconSha256 },
      `android_icon_${legacy.density}`
    )
    verifyPng(
      root,
      legacy.roundPath,
      { ...expected, sha256: legacy.roundSha256 },
      `android_round_icon_${legacy.density}`
    )
  }
}

function slotKey(icon) {
  return `${icon.idiom}|${icon.size}|${icon.scale}`
}

function verifyIosIcons(root, ios) {
  assert(
    ios.source === 'docs/v3/play/assets/d3ro-voice-play-icon-source.svg',
    'ios_canonical_source'
  )
  assert(JSON.stringify(ios.targetedDeviceFamilies) === '[1,2]', 'ios_targeted_families_contract')
  assert(
    ios.bitDepth === 8 && ios.colorType === 2 && ios.alphaChannel === false,
    'ios_png_contract'
  )
  assert(Array.isArray(ios.icons) && ios.icons.length === requiredIosSlots.length, 'ios_icon_count')

  const requiredBySlot = new Map(
    requiredIosSlots.map(([idiom, size, scale, filename, pixels]) => [
      `${idiom}|${size}|${scale}`,
      { idiom, size, scale, filename, pixels }
    ])
  )
  const manifestBySlot = new Map()
  for (const icon of ios.icons) {
    const key = slotKey(icon)
    assert(!manifestBySlot.has(key), `ios_icon_duplicate_${key}`)
    manifestBySlot.set(key, icon)
    const required = requiredBySlot.get(key)
    assert(required, `ios_icon_unexpected_${key}`)
    assert(icon.filename === required.filename, `ios_icon_filename_${key}`)
    assert(icon.pixels === required.pixels, `ios_icon_pixels_${key}`)
    assert(
      typeof icon.sha256 === 'string' && icon.sha256.length === 64,
      `ios_icon_hash_contract_${key}`
    )
  }
  for (const key of requiredBySlot.keys()) {
    assert(manifestBySlot.has(key), `ios_icon_missing_${key}`)
  }

  const contents = readJson(root, ios.contents, 'ios_appicon_contents')
  assert(contents.info?.author === 'xcode' && contents.info?.version === 1, 'ios_contents_info')
  assert(
    Array.isArray(contents.images) && contents.images.length === requiredIosSlots.length,
    'ios_contents_count'
  )
  const contentsBySlot = new Map()
  for (const entry of contents.images) {
    const key = slotKey(entry)
    assert(!contentsBySlot.has(key), `ios_contents_duplicate_${key}`)
    contentsBySlot.set(key, entry)
    const icon = manifestBySlot.get(key)
    assert(icon, `ios_contents_unexpected_${key}`)
    assert(entry.filename === icon.filename, `ios_contents_filename_${key}`)
  }
  for (const key of manifestBySlot.keys()) {
    assert(contentsBySlot.has(key), `ios_contents_missing_${key}`)
  }

  const contentsDirectory = dirname(resolveInside(root, ios.contents, 'ios_contents_path'))
  const expectedPngFiles = new Set(ios.icons.map((icon) => icon.filename))
  const actualPngFiles = new Set(
    readdirSync(contentsDirectory).filter((name) => name.endsWith('.png'))
  )
  assert(actualPngFiles.size === expectedPngFiles.size, 'ios_unassigned_png_count')
  for (const filename of actualPngFiles) {
    assert(expectedPngFiles.has(filename), `ios_unassigned_png_${filename}`)
  }

  for (const icon of ios.icons) {
    assert(basename(icon.filename) === icon.filename, `ios_icon_filename_path_${icon.filename}`)
    verifyPng(
      contentsDirectory,
      icon.filename,
      {
        width: icon.pixels,
        height: icon.pixels,
        bitDepth: ios.bitDepth,
        colorType: ios.colorType,
        alpha: 'no_alpha_channel',
        sha256: icon.sha256
      },
      `ios_icon_${icon.idiom}_${icon.size}_${icon.scale}`
    )
  }

  const project = readRequired(root, ios.project, 'ios_xcode_project').file.toString('utf8')
  assert(
    (project.match(/ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon;/g) ?? []).length >= 2,
    'ios_xcode_appicon_binding'
  )
  assert(
    (project.match(/TARGETED_DEVICE_FAMILY = "1,2";/g) ?? []).length >= 2,
    'ios_xcode_targeted_families'
  )
}

function verifyMobileIcons(root) {
  const manifest = readJson(root, mobileIconManifestRelative, 'mobile_icon_manifest')
  assert(manifest.schemaVersion === 1, 'mobile_icon_manifest_schema')
  assert(
    manifest.canonicalSource?.path === 'docs/v3/play/assets/d3ro-voice-play-icon-source.svg',
    'canonical_icon_source_path'
  )
  verifySvg(root, manifest.canonicalSource, 'canonical_icon_source')
  assert(
    manifest.playStoreIcon?.path === 'docs/v3/play/assets/d3ro-voice-play-icon-512.png',
    'play_icon_path'
  )
  verifyPng(root, manifest.playStoreIcon.path, manifest.playStoreIcon, 'play_icon')
  verifyAndroidIcons(root, manifest.android)
  verifyIosIcons(root, manifest.ios)
  verifyPng(
    root,
    manifest.pixelLauncherProof.path,
    {
      ...manifest.pixelLauncherProof,
      bitDepth: 8,
      colorType: 6,
      alpha: 'opaque'
    },
    'pixel_launcher_proof'
  )
  return {
    androidLegacyIconCount: manifest.android.legacyIcons.length * 2,
    iosIconCount: manifest.ios.icons.length
  }
}

function verifyAll(root, printSummary = true) {
  const feature = verifyFeatureGraphics(root)
  const mobile = verifyMobileIcons(root)
  if (printSummary) {
    console.log(
      `Play store assets verified: ${feature.candidateCount} historical feature candidates + canonical ${feature.canonicalId}, canonical 512 icon, ${mobile.androidLegacyIconCount} Android legacy icons + adaptive/monochrome, ${mobile.iosIconCount} iOS/iPad icons, hashes and alpha contracts GREEN`
    )
  }
}

function copyFixture(relativePath, temporaryRoot) {
  const source = resolveInside(workspaceRoot, relativePath, 'self_test_source')
  const destination = resolveInside(temporaryRoot, relativePath, 'self_test_destination')
  mkdirSync(dirname(destination), { recursive: true })
  cpSync(source, destination, { recursive: true })
}

function createSelfTestFixture() {
  const temporaryRoot = mkdtempSync(join(tmpdir(), 'd3ro-mobile-icon-assets-'))
  for (const relativePath of [
    'docs/v3/play/assets',
    'apps/mobile-rn/android/app/src/main/AndroidManifest.xml',
    'apps/mobile-rn/android/app/src/main/res',
    'apps/mobile-rn/ios/D3ROVoice/Images.xcassets/AppIcon.appiconset',
    'apps/mobile-rn/ios/D3ROVoice.xcodeproj/project.pbxproj'
  ]) {
    copyFixture(relativePath, temporaryRoot)
  }
  return temporaryRoot
}

function expectSelfTestFailure(name, mutate, expectedCode) {
  const temporaryRoot = createSelfTestFixture()
  try {
    mutate(temporaryRoot)
    let failure
    try {
      verifyAll(temporaryRoot, false)
    } catch (error) {
      failure = error
    }
    assert(failure instanceof Error, `self_test_${name}_unexpected_green`)
    assert(
      failure.message === `play_store_asset_verification_failed:${expectedCode}`,
      `self_test_${name}_wrong_failure_${failure.message}`
    )
    console.log(`Negative self-test ${name}: ${expectedCode} RED as expected`)
  } finally {
    rmSync(temporaryRoot, { recursive: true, force: true })
  }
}

function runSelfTests() {
  verifyAll(workspaceRoot, false)

  expectSelfTestFailure(
    'android_manifest_icon',
    (root) => {
      const path = resolveInside(
        root,
        'apps/mobile-rn/android/app/src/main/AndroidManifest.xml',
        'self_test_android_manifest'
      )
      writeFileSync(
        path,
        readFileSync(path, 'utf8').replace('@mipmap/ic_launcher"', '@mipmap/missing"')
      )
    },
    'android_manifest_icon'
  )

  expectSelfTestFailure(
    'android_density_dimensions',
    (root) => {
      const manifestPath = resolveInside(
        root,
        mobileIconManifestRelative,
        'self_test_mobile_manifest'
      )
      const manifest = JSON.parse(readFileSync(manifestPath, 'utf8'))
      const hdpi = manifest.android.legacyIcons.find((icon) => icon.density === 'hdpi')
      const mdpi = manifest.android.legacyIcons.find((icon) => icon.density === 'mdpi')
      const mdpiBytes = readFileSync(resolveInside(root, mdpi.iconPath, 'self_test_mdpi_icon'))
      writeFileSync(resolveInside(root, hdpi.iconPath, 'self_test_hdpi_icon'), mdpiBytes)
      hdpi.iconSha256 = sha256(mdpiBytes)
      writeFileSync(manifestPath, `${JSON.stringify(manifest, null, 2)}\n`)
    },
    'android_icon_hdpi_width'
  )

  expectSelfTestFailure(
    'android_monochrome_missing',
    (root) => {
      unlinkSync(
        resolveInside(
          root,
          'apps/mobile-rn/android/app/src/main/res/drawable/d3ro_launcher_monochrome.xml',
          'self_test_monochrome'
        )
      )
    },
    'android_monochrome_vector_missing'
  )

  expectSelfTestFailure(
    'ios_icon_missing',
    (root) => {
      unlinkSync(
        resolveInside(
          root,
          'apps/mobile-rn/ios/D3ROVoice/Images.xcassets/AppIcon.appiconset/AppIcon-marketing-1024@1x.png',
          'self_test_ios_marketing_icon'
        )
      )
    },
    'ios_unassigned_png_count'
  )

  expectSelfTestFailure(
    'ios_contents_filename',
    (root) => {
      const path = resolveInside(
        root,
        'apps/mobile-rn/ios/D3ROVoice/Images.xcassets/AppIcon.appiconset/Contents.json',
        'self_test_ios_contents'
      )
      const contents = JSON.parse(readFileSync(path, 'utf8'))
      contents.images[0].filename = 'missing.png'
      writeFileSync(path, `${JSON.stringify(contents, null, 2)}\n`)
    },
    'ios_contents_filename_iphone|20x20|2x'
  )

  expectSelfTestFailure(
    'ios_alpha_channel',
    (root) => {
      const manifestPath = resolveInside(
        root,
        mobileIconManifestRelative,
        'self_test_mobile_manifest'
      )
      const manifest = JSON.parse(readFileSync(manifestPath, 'utf8'))
      const icon = manifest.ios.icons.find(
        (candidate) =>
          candidate.idiom === 'iphone' && candidate.size === '20x20' && candidate.scale === '2x'
      )
      const contentsDirectory = dirname(
        resolveInside(root, manifest.ios.contents, 'self_test_ios_contents')
      )
      const path = resolveInside(contentsDirectory, icon.filename, 'self_test_ios_icon')
      const bytes = readFileSync(path)
      bytes[25] = 6
      writeFileSync(path, bytes)
      icon.sha256 = sha256(bytes)
      writeFileSync(manifestPath, `${JSON.stringify(manifest, null, 2)}\n`)
    },
    'ios_icon_iphone_20x20_2x_color_type'
  )

  expectSelfTestFailure(
    'feature_canonical_hash',
    (root) => {
      const manifestPath = resolveInside(
        root,
        `${featureAssetDirectoryRelative}/manifest.json`,
        'self_test_feature_manifest'
      )
      const manifest = JSON.parse(readFileSync(manifestPath, 'utf8'))
      const path = resolveInside(
        root,
        `${featureAssetDirectoryRelative}/${manifest.canonical.output}`,
        'self_test_feature_canonical'
      )
      const bytes = readFileSync(path)
      bytes[bytes.length - 1] ^= 0xff
      writeFileSync(path, bytes)
    },
    'feature_canonical_hash'
  )

  console.log('Play/mobile icon negative self-tests GREEN: 7 fail-closed cases')
}

const argumentsSet = new Set(process.argv.slice(2))
for (const argument of argumentsSet) {
  assert(argument === '--self-test', `unknown_argument_${argument}`)
}

if (argumentsSet.has('--self-test')) {
  runSelfTests()
} else {
  verifyAll(workspaceRoot)
}