param(
  [Parameter(Mandatory = $true, Position = 0)]
  [ValidateSet('export', 'import')]
  [string]$Action,
  [string]$JsonPath,
  [string]$XlsxPath,
  [string]$OutJsonPath
)

$ErrorActionPreference = 'Stop'
Add-Type -AssemblyName System.IO.Compression.FileSystem
Add-Type -AssemblyName System.IO.Compression

$repoRoot = (Resolve-Path (Join-Path $PSScriptRoot '..\..')).Path
if ([string]::IsNullOrWhiteSpace($JsonPath)) { $JsonPath = Join-Path $repoRoot 'data\cards.json' }
if ([string]::IsNullOrWhiteSpace($XlsxPath)) { $XlsxPath = Join-Path $repoRoot 'data\cards.xlsx' }
if ([string]::IsNullOrWhiteSpace($OutJsonPath)) { $OutJsonPath = $JsonPath }

$utf8NoBom = [System.Text.UTF8Encoding]::new($false)

function Escape-Xml([string]$Text) {
  if ($null -eq $Text) { return '' }
  return [System.Security.SecurityElement]::Escape($Text)
}

function Get-ColumnName([int]$Index) {
  $n = $Index
  $name = ''
  while ($n -gt 0) {
    $n--
    $name = [char][int](65 + ($n % 26)) + $name
    $n = [math]::Floor($n / 26)
  }
  return $name
}

function Get-ColumnIndex([string]$Name) {
  $n = 0
  foreach ($ch in $Name.ToCharArray()) {
    if ($ch -match '[A-Z]') {
      $n = $n * 26 + ([int][char]$ch - 64)
    }
  }
  return $n
}

function Get-CellRef([int]$Col, [int]$Row) {
  return (Get-ColumnName $Col) + $Row
}

function Has-MapKey($Map, $Key) {
  if ($null -eq $Map) { return $false }
  if ($null -eq $Key) { return $false }
  if ($Key -is [string] -and [string]::IsNullOrWhiteSpace($Key)) { return $false }
  foreach ($existingKey in $Map.Keys) {
    if ($existingKey -eq $Key) { return $true }
  }
  return $false
}

function Get-ScalarType($Value) {
  if ($null -eq $Value) { return 'null' }
  if ($Value -is [bool]) { return 'boolean' }
  if ($Value -is [byte] -or $Value -is [sbyte] -or
      $Value -is [int16] -or $Value -is [uint16] -or
      $Value -is [int32] -or $Value -is [uint32] -or
      $Value -is [int64] -or $Value -is [uint64] -or
      $Value -is [single] -or $Value -is [double] -or $Value -is [decimal]) { return 'number' }
  if ($Value -is [string]) { return 'string' }
  return 'string'
}

function Get-CardSchema($Cards) {
  $schema = [ordered]@{}
  foreach ($cardEntry in $Cards.PSObject.Properties) {
    $card = $cardEntry.Value
    foreach ($prop in $card.PSObject.Properties) {
      $kind = Get-ScalarType $prop.Value
      if (-not (Has-MapKey $schema $prop.Name)) {
        $schema[$prop.Name] = $kind
      } elseif ($schema[$prop.Name] -ne $kind -and $kind -ne 'null') {
        $schema[$prop.Name] = 'string'
      }
    }
  }
  return $schema
}

function Get-ColumnWidth([string]$Header, [string]$Type) {
  switch ($Header) {
    'id' { return 18 }
    'name' { return 24 }
    'desc' { return 48 }
    'image' { return 36 }
    'fx' { return 36 }
    'kind' { return 12 }
    'class' { return 12 }
    'rarity' { return 12 }
    default {
      if ($Type -eq 'boolean') { return 10 }
      if ($Type -eq 'number') { return 12 }
      return 16
    }
  }
}

function To-InvariantNumber($Value) {
  return [string]::Format([System.Globalization.CultureInfo]::InvariantCulture, '{0}', $Value)
}

function New-HeaderCellXml([string]$Ref, [string]$Text) {
  $escaped = Escape-Xml $Text
  return "<c r=""$Ref"" s=""1"" t=""inlineStr""><is><t xml:space=""preserve"">$escaped</t></is></c>"
}

function New-TextCellXml([string]$Ref, [string]$Text) {
  $escaped = Escape-Xml $Text
  return "<c r=""$Ref"" t=""inlineStr""><is><t xml:space=""preserve"">$escaped</t></is></c>"
}

function New-NumberCellXml([string]$Ref, $Value) {
  if ($null -eq $Value) { return $null }
  if ($Value -is [string] -and $Value -eq '') { return $null }
  return "<c r=""$Ref""><v>$(To-InvariantNumber $Value)</v></c>"
}

function New-BoolCellXml([string]$Ref, $Value) {
  if ($null -eq $Value) { return $null }
  if ($Value -is [string] -and $Value -eq '') { return $null }
  $bool = $false
  if ($Value -is [bool]) {
    $bool = $Value
  } else {
    $text = [string]$Value
    if ($text -match '^(?i:true|1|yes|y)$') { $bool = $true }
    elseif ($text -match '^(?i:false|0|no|n)$') { $bool = $false }
    else { return $null }
  }
  $n = if ($bool) { 1 } else { 0 }
  return "<c r=""$Ref"" t=""b""><v>$n</v></c>"
}

function New-CellXml([string]$Ref, $Value, [string]$Type) {
  switch ($Type) {
    'number' { return New-NumberCellXml $Ref $Value }
    'boolean' { return New-BoolCellXml $Ref $Value }
    default {
      if ($null -eq $Value) {
        return New-TextCellXml $Ref ''
      }
      return New-TextCellXml $Ref ([string]$Value)
    }
  }
}

function Get-WorksheetXml([string]$SheetName, [string[]]$Headers, [object[]]$Rows, [hashtable]$TypeMap) {
  $maxCol = $Headers.Count
  $lastCol = Get-ColumnName $maxCol
  $rowCount = $Rows.Count + 1
  $colsXml = New-Object System.Collections.Generic.List[string]
  for ($i = 0; $i -lt $Headers.Count; $i++) {
    $header = $Headers[$i]
    $type = if (Has-MapKey $TypeMap $header) { [string]$TypeMap[$header] } else { 'string' }
    $width = Get-ColumnWidth $header $type
    $colsXml.Add("<col min=""$($i + 1)"" max=""$($i + 1)"" width=""$width"" customWidth=""1"" />")
  }

  $rowsXml = New-Object System.Collections.Generic.List[string]
  $headerCells = New-Object System.Collections.Generic.List[string]
  for ($i = 0; $i -lt $Headers.Count; $i++) {
    $headerCells.Add((New-HeaderCellXml (Get-CellRef ($i + 1) 1) $Headers[$i]))
  }
  $rowsXml.Add("<row r=""1"" spans=""1:$maxCol"" ht=""20"" customHeight=""1"">$($headerCells -join '')</row>")

  for ($r = 0; $r -lt $Rows.Count; $r++) {
    $row = $Rows[$r]
    $cells = New-Object System.Collections.Generic.List[string]
    for ($c = 0; $c -lt $Headers.Count; $c++) {
      $header = $Headers[$c]
      $type = if (Has-MapKey $TypeMap $header) { [string]$TypeMap[$header] } else { 'string' }
      $value = $null
      if (Has-MapKey $row $header) { $value = $row[$header] }
      $cellXml = New-CellXml (Get-CellRef ($c + 1) ($r + 2)) $value $type
      if ($null -ne $cellXml) { $cells.Add($cellXml) }
    }
    $rowsXml.Add("<row r=""$($r + 2)"" spans=""1:$maxCol"">$($cells -join '')</row>")
  }

  $sheetView = '<sheetViews><sheetView workbookViewId="0"><pane ySplit="1" topLeftCell="A2" activePane="bottomLeft" state="frozen"/><selection pane="bottomLeft" activeCell="A2" sqref="A2"/></sheetView></sheetViews>'
  $cols = '<cols>' + ($colsXml -join '') + '</cols>'
  $sheetData = '<sheetData>' + ($rowsXml -join '') + '</sheetData>'
  $autoFilter = "<autoFilter ref=""A1:$lastCol$rowCount""/>"
  return @"
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<worksheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main"
 xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships">
  $sheetView
  <sheetFormatPr defaultRowHeight="18"/>
  $cols
  $sheetData
  $autoFilter
  <pageMargins left="0.25" right="0.25" top="0.5" bottom="0.5" header="0.3" footer="0.3"/>
</worksheet>
"@
}

function Get-StylesXml {
  return @"
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<styleSheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main">
  <fonts count="2">
    <font>
      <sz val="11"/>
      <color rgb="FF000000"/>
      <name val="Calibri"/>
      <family val="2"/>
      <scheme val="minor"/>
    </font>
    <font>
      <b/>
      <sz val="11"/>
      <color rgb="FFFFFFFF"/>
      <name val="Calibri"/>
      <family val="2"/>
      <scheme val="minor"/>
    </font>
  </fonts>
  <fills count="2">
    <fill><patternFill patternType="none"/></fill>
    <fill><patternFill patternType="solid"><fgColor rgb="FF2D3748"/><bgColor indexed="64"/></patternFill></fill>
  </fills>
  <borders count="1">
    <border>
      <left/><right/><top/><bottom/><diagonal/>
    </border>
  </borders>
  <cellStyleXfs count="1">
    <xf numFmtId="0" fontId="0" fillId="0" borderId="0"/>
  </cellStyleXfs>
  <cellXfs count="2">
    <xf numFmtId="0" fontId="0" fillId="0" borderId="0" xfId="0"/>
    <xf numFmtId="0" fontId="1" fillId="1" borderId="0" xfId="0" applyFont="1" applyFill="1"/>
  </cellXfs>
  <cellStyles count="1">
    <cellStyle name="Normal" xfId="0" builtinId="0"/>
  </cellStyles>
</styleSheet>
"@
}

function Get-WorkbookXml([string[]]$SheetNames) {
  $sheetsXml = New-Object System.Collections.Generic.List[string]
  for ($i = 0; $i -lt $SheetNames.Count; $i++) {
    $sheetsXml.Add("<sheet name=""$(Escape-Xml $SheetNames[$i])"" sheetId=""$($i + 1)"" r:id=""rId$($i + 1)""/>")
  }
  return @"
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<workbook xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main"
 xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships">
  <sheets>
    $($sheetsXml -join '')
  </sheets>
</workbook>
"@
}

function Get-WorkbookRelsXml([int]$SheetCount) {
  $rels = New-Object System.Collections.Generic.List[string]
  for ($i = 1; $i -le $SheetCount; $i++) {
    $rels.Add("<Relationship Id=""rId$i"" Type=""http://schemas.openxmlformats.org/officeDocument/2006/relationships/worksheet"" Target=""worksheets/sheet$i.xml""/>")
  }
  $rels.Add("<Relationship Id=""rId$($SheetCount + 1)"" Type=""http://schemas.openxmlformats.org/officeDocument/2006/relationships/styles"" Target=""styles.xml""/>")
  return @"
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">
  $($rels -join '')
</Relationships>
"@
}

function Get-RootRelsXml {
  return @"
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">
  <Relationship Id="rId1" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument" Target="xl/workbook.xml"/>
</Relationships>
"@
}

function Get-ContentTypesXml([int]$SheetCount) {
  $overrides = New-Object System.Collections.Generic.List[string]
  for ($i = 1; $i -le $SheetCount; $i++) {
    $overrides.Add("<Override PartName=""/xl/worksheets/sheet$i.xml"" ContentType=""application/vnd.openxmlformats-officedocument.spreadsheetml.worksheet+xml""/>")
  }
  $overrides.Add('<Override PartName="/xl/workbook.xml" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet.main+xml"/>')
  $overrides.Add('<Override PartName="/xl/styles.xml" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.styles+xml"/>')
  return @"
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<Types xmlns="http://schemas.openxmlformats.org/package/2006/content-types">
  <Default Extension="rels" ContentType="application/vnd.openxmlformats-package.relationships+xml"/>
  <Default Extension="xml" ContentType="application/xml"/>
  $($overrides -join '')
</Types>
"@
}

function Write-Xlsx([string]$Path, [hashtable]$Parts) {
  $dir = Split-Path -Parent $Path
  if (-not [string]::IsNullOrWhiteSpace($dir) -and -not (Test-Path $dir)) {
    New-Item -ItemType Directory -Path $dir -Force | Out-Null
  }
  if (Test-Path $Path) {
    Remove-Item -LiteralPath $Path -Force
  }
  $file = [System.IO.File]::Open($Path, [System.IO.FileMode]::Create, [System.IO.FileAccess]::ReadWrite)
  try {
    $zip = New-Object System.IO.Compression.ZipArchive($file, [System.IO.Compression.ZipArchiveMode]::Create, $false)
    try {
      foreach ($entryName in $Parts.Keys) {
        $entry = $zip.CreateEntry($entryName)
        $stream = $entry.Open()
        $writer = New-Object System.IO.StreamWriter($stream, $utf8NoBom)
        try {
          $writer.Write([string]$Parts[$entryName])
        } finally {
          $writer.Dispose()
          $stream.Dispose()
        }
      }
    } finally {
      $zip.Dispose()
    }
  } finally {
    $file.Dispose()
  }
}

function Read-XlsxXml([string]$Path, [string]$EntryName) {
  $zip = [System.IO.Compression.ZipFile]::OpenRead($Path)
  try {
    $entry = $zip.GetEntry($EntryName)
    if ($null -eq $entry) { throw "Missing XLSX entry: $EntryName" }
    $stream = $entry.Open()
    try {
      $reader = New-Object System.IO.StreamReader($stream, $utf8NoBom)
      try { return $reader.ReadToEnd() } finally { $reader.Dispose() }
    } finally {
      $stream.Dispose()
    }
  } finally {
    $zip.Dispose()
  }
}

function Read-SharedStrings([string]$Path) {
  try {
    $xmlText = Read-XlsxXml $Path 'xl/sharedStrings.xml'
  } catch {
    return @()
  }
  [xml]$xml = $xmlText
  $ns = New-Object System.Xml.XmlNamespaceManager($xml.NameTable)
  $ns.AddNamespace('x', 'http://schemas.openxmlformats.org/spreadsheetml/2006/main')
  $items = $xml.SelectNodes('/x:sst/x:si', $ns)
  $values = New-Object System.Collections.Generic.List[string]
  foreach ($item in $items) {
    $values.Add([string]$item.InnerText)
  }
  return $values.ToArray()
}

function Read-WorksheetRows([string]$XmlText, [string[]]$SharedStrings) {
  [xml]$xml = $XmlText
  $ns = New-Object System.Xml.XmlNamespaceManager($xml.NameTable)
  $ns.AddNamespace('x', 'http://schemas.openxmlformats.org/spreadsheetml/2006/main')
  $rows = $xml.SelectNodes('/x:worksheet/x:sheetData/x:row', $ns)
  $parsed = @()
  foreach ($row in $rows) {
    $cells = @{}
    foreach ($cell in @($row.ChildNodes)) {
      if ($cell.Name -ne 'c') { continue }
      $ref = [string]$cell.Attributes['r'].Value
      $col = Get-ColumnIndex (($ref -replace '\d+$', ''))
      $type = [string]$cell.Attributes['t'].Value
      $text = [string]$cell.InnerText
      if ($type -eq 's' -and $text -match '^\d+$') {
        $index = [int]$text
        if ($index -ge 0 -and $index -lt $SharedStrings.Count) {
          $text = [string]$SharedStrings[$index]
        }
      }
      $cells[$col] = $text
    }
    $parsed += ,$cells
  }
  return $parsed
}

function Convert-CellValue([string]$Text, [string]$Type) {
  if ($null -eq $Text -or $Text -eq '') { return $null }
  switch ($Type) {
    'number' {
      $num = 0
      if ([double]::TryParse($Text, [System.Globalization.NumberStyles]::Any, [System.Globalization.CultureInfo]::InvariantCulture, [ref]$num)) {
        if ([math]::Abs($num - [math]::Round($num)) -lt 0.0000001) { return [int64][math]::Round($num) }
        return $num
      }
      return $null
    }
    'boolean' {
      if ($Text -match '^(?i:true|1|yes|y)$') { return $true }
      if ($Text -match '^(?i:false|0|no|n)$') { return $false }
      return $null
    }
    default {
      return $Text
    }
  }
}

function Export-Cards {
  $source = Get-Content -LiteralPath $JsonPath -Raw -Encoding utf8 | ConvertFrom-Json
  $schema = Get-CardSchema $source.cards
  $cardCore = @('id', 'name', 'cost', 'kind', 'rarity', 'class', 'desc', 'image', 'fx')
  $cardExtras = @($schema.Keys | Where-Object { $_ -notin $cardCore } | Sort-Object)
  $cardHeaders = @($cardCore + $cardExtras)

  $maxDeckSize = 0
  foreach ($deckEntry in $source.starterDecks.PSObject.Properties) {
    $deckSize = @($deckEntry.Value).Count
    if ($deckSize -gt $maxDeckSize) {
      $maxDeckSize = $deckSize
    }
  }
  if ($maxDeckSize -lt 1) { $maxDeckSize = 1 }

  $starterDeckHeaders = New-Object System.Collections.Generic.List[string]
  $starterDeckHeaders.Add('class')
  for ($i = 1; $i -le $maxDeckSize; $i++) {
    $starterDeckHeaders.Add("slot$i")
  }

  $cardRows = New-Object System.Collections.Generic.List[object]
  foreach ($cardEntry in $source.cards.PSObject.Properties) {
    $cardId = $cardEntry.Name
    $card = $cardEntry.Value
    $row = [ordered]@{ id = $cardId }
    foreach ($header in $cardHeaders) {
      if ($header -eq 'id') { continue }
      if ($card.PSObject.Properties.Name -contains $header) {
        $row[$header] = $card.$header
      } else {
        $row[$header] = $null
      }
    }
    $cardRows.Add($row)
  }

  $deckRows = New-Object System.Collections.Generic.List[object]
  foreach ($deckEntry in $source.starterDecks.PSObject.Properties) {
    $cls = $deckEntry.Name
    $deck = @($deckEntry.Value)
    $row = [ordered]@{ class = $cls }
    for ($i = 1; $i -le $maxDeckSize; $i++) {
      $key = "slot$i"
      $row[$key] = if ($i -le $deck.Count) { $deck[$i - 1] } else { $null }
    }
    $deckRows.Add($row)
  }

  $cardSheet = Get-WorksheetXml 'Cards' $cardHeaders $cardRows $schema
  $deckTypeMap = [ordered]@{ class = 'string' }
  for ($i = 1; $i -le $maxDeckSize; $i++) { $deckTypeMap["slot$i"] = 'string' }
  $deckSheet = Get-WorksheetXml 'StarterDecks' $starterDeckHeaders $deckRows $deckTypeMap

  $parts = [ordered]@{
    '[Content_Types].xml' = (Get-ContentTypesXml 2)
    '_rels/.rels' = (Get-RootRelsXml)
    'xl/workbook.xml' = (Get-WorkbookXml @('Cards', 'StarterDecks'))
    'xl/_rels/workbook.xml.rels' = (Get-WorkbookRelsXml 2)
    'xl/styles.xml' = (Get-StylesXml)
    'xl/worksheets/sheet1.xml' = $cardSheet
    'xl/worksheets/sheet2.xml' = $deckSheet
  }

  Write-Host "Source JSON: $JsonPath"
  Write-Host "Target XLSX: $XlsxPath"
  Write-Xlsx $XlsxPath $parts
  Write-Host "Excel export complete: $XlsxPath"
}

function Import-Cards {
  $source = Get-Content -LiteralPath $JsonPath -Raw -Encoding utf8 | ConvertFrom-Json
  $schema = Get-CardSchema $source.cards
  $origCardOrders = @{}
  foreach ($cardEntry in $source.cards.PSObject.Properties) {
    $origCardOrders[$cardEntry.Name] = @($cardEntry.Value.PSObject.Properties.Name)
  }
  $origDeckOrder = @($source.starterDecks.PSObject.Properties.Name)

  $sharedStrings = Read-SharedStrings $XlsxPath
  $cardsXml = Read-XlsxXml $XlsxPath 'xl/worksheets/sheet1.xml'
  $deckXml = Read-XlsxXml $XlsxPath 'xl/worksheets/sheet2.xml'
  $cardRowsRaw = Read-WorksheetRows $cardsXml $sharedStrings
  $deckRowsRaw = Read-WorksheetRows $deckXml $sharedStrings

  if ($cardRowsRaw.Count -lt 2) { throw 'Cards sheet has no data rows.' }
  if ($deckRowsRaw.Count -lt 2) { throw 'StarterDecks sheet has no data rows.' }

  $cardHeaderMap = $cardRowsRaw[0]
  $cardHeaders = @($cardHeaderMap.Keys | Sort-Object)
  $orderedCardHeaders = New-Object System.Collections.Generic.List[string]
  foreach ($col in $cardHeaders) {
    $header = $cardHeaderMap[$col]
    if ([string]::IsNullOrWhiteSpace($header)) { continue }
    $orderedCardHeaders.Add($header)
  }

  $newCards = [ordered]@{}
  for ($r = 1; $r -lt $cardRowsRaw.Count; $r++) {
    $row = $cardRowsRaw[$r]
    $cardId = $null
    $rowValues = @{}
    for ($c = 0; $c -lt $orderedCardHeaders.Count; $c++) {
      $header = $orderedCardHeaders[$c]
      $text = $null
      if (Has-MapKey $row ($c + 1)) { $text = $row[$c + 1] }
      if ($header -eq 'id') {
        $cardId = [string]$text
        continue
      }
      $rowValues[$header] = $text
    }
    if (-not [string]::IsNullOrWhiteSpace($cardId)) {
      $cardObj = [ordered]@{}
      $fieldOrder = New-Object System.Collections.Generic.List[string]
      if ($origCardOrders.ContainsKey($cardId)) {
        foreach ($name in @($origCardOrders[$cardId])) {
          if ($name -ne 'id' -and -not $fieldOrder.Contains($name)) {
            $fieldOrder.Add($name)
          }
        }
      }
      foreach ($name in $orderedCardHeaders) {
        if ($name -ne 'id' -and -not $fieldOrder.Contains($name)) {
          $fieldOrder.Add($name)
        }
      }
      foreach ($header in $fieldOrder) {
        $text = $null
        if (Has-MapKey $rowValues $header) { $text = $rowValues[$header] }
        $type = if (Has-MapKey $schema $header) { [string]$schema[$header] } else { 'string' }
        $value = Convert-CellValue $text $type
        if ($null -eq $value) { continue }
        $cardObj[$header] = $value
      }
      $newCards[$cardId] = $cardObj
    }
  }

  $deckHeaderMap = $deckRowsRaw[0]
  $deckHeaderCols = @($deckHeaderMap.Keys | Sort-Object)
  $orderedDeckHeaders = New-Object System.Collections.Generic.List[string]
  foreach ($col in $deckHeaderCols) {
    $header = $deckHeaderMap[$col]
    if ([string]::IsNullOrWhiteSpace($header)) { continue }
    $orderedDeckHeaders.Add($header)
  }

  $newDecks = [ordered]@{}
  for ($r = 1; $r -lt $deckRowsRaw.Count; $r++) {
    $row = $deckRowsRaw[$r]
    $cls = $null
    $deckValues = @{}
    for ($c = 0; $c -lt $orderedDeckHeaders.Count; $c++) {
      $header = $orderedDeckHeaders[$c]
      $text = $null
      if (Has-MapKey $row ($c + 1)) { $text = $row[$c + 1] }
      if ($header -eq 'class') {
        $cls = [string]$text
        continue
      }
      $deckValues[$header] = $text
    }
    if (-not [string]::IsNullOrWhiteSpace($cls)) {
      $deck = New-Object System.Collections.Generic.List[string]
      foreach ($header in $orderedDeckHeaders) {
        if ($header -eq 'class') { continue }
        $text = $null
        if (Has-MapKey $deckValues $header) { $text = $deckValues[$header] }
        if (-not [string]::IsNullOrWhiteSpace([string]$text)) {
          $deck.Add([string]$text)
        }
      }
      $newDecks[$cls] = $deck.ToArray()
    }
  }

  if ($origDeckOrder.Count -gt 0) {
    $orderedDecks = [ordered]@{}
    foreach ($cls in $origDeckOrder) {
      if (Has-MapKey $newDecks $cls) {
        $orderedDecks[$cls] = $newDecks[$cls]
      }
    }
    foreach ($entry in $newDecks.GetEnumerator()) {
      if (-not (Has-MapKey $orderedDecks $entry.Key)) {
        $orderedDecks[$entry.Key] = $entry.Value
      }
    }
    $newDecks = $orderedDecks
  }

  $out = [ordered]@{
    cards = $newCards
    starterDecks = $newDecks
  }

  $json = $out | ConvertTo-Json -Depth 64
  Write-Host "Source XLSX: $XlsxPath"
  Write-Host "Target JSON: $OutJsonPath"
  [System.IO.File]::WriteAllText($OutJsonPath, $json, $utf8NoBom)
  Write-Host "JSON import complete: $OutJsonPath"
}

switch ($Action) {
  'export' { Export-Cards }
  'import' { Import-Cards }
}