"use client"

import {
  rowHasUnmapped,
  UNDERLYING_SLOTS,
  type StructureQueueRow,
} from "@/components/deepdex/utils/structure-underlying-alias"
import { ACCUMULATOR_TABLE_COLUMNS } from "@/components/deepdex/utils/accumulator-queue-fields"
import { accumulatorRowHasUnmapped, type AccumulatorQueueRow } from "@/components/deepdex/utils/accumulator-underlying-alias"
import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card"
import { Table, TableBody, TableCell, TableHead, TableHeader, TableRow } from "@/components/ui/table"

import {
  renderAccumulatorUnderlyingCell,
  renderStatusCell,
  renderUnderlyingCell,
} from "./deepdex-upload-queue-review-cells"
import type { ReviewData } from "./deepdex-upload-queue-review-types"

export function DeepdexUploadQueueReviewTable({
  module,
  queueRows,
  reviewData,
  selected,
  onSelectedChange,
  onEdit,
  onView,
  onRemove,
  onAddUnderlying,
  onMapStructure,
  onMapAccumulator,
}: {
  module: string
  queueRows: Array<Record<string, unknown>>
  reviewData: ReviewData | null
  selected: number[]
  onSelectedChange: (next: number[]) => void
  onEdit: (row: Record<string, unknown>, index: number) => void
  onView: (index: number) => void
  onRemove: (index: number) => void
  onAddUnderlying: (row: Record<string, unknown>, index: number) => void
  onMapStructure: (queueIndex: number, slot: number, row: StructureQueueRow) => void
  onMapAccumulator: (queueIndex: number, row: AccumulatorQueueRow) => void
}) {
  return (
    <Card>
      <CardHeader>
        <CardTitle className="text-base">Review records</CardTitle>
      </CardHeader>
      <CardContent className="overflow-x-auto p-0">
        <Table>
          <TableHeader>
            <TableRow>
              <TableHead className="w-10" />
              <TableHead className="w-10">#</TableHead>
              <TableHead className="min-w-[12rem]">Status</TableHead>
              {module === "accumulator"
                ? ACCUMULATOR_TABLE_COLUMNS.map((column) => (
                    <TableHead key={column.key}>{column.label}</TableHead>
                  ))
                : (
                  <>
                    <TableHead>ISIN</TableHead>
                    <TableHead>Name</TableHead>
                    <TableHead>Coupon</TableHead>
                    <TableHead>Expiry</TableHead>
                    <TableHead>Observation</TableHead>
                    <TableHead>KO Barrier</TableHead>
                    <TableHead>Product</TableHead>
                    <TableHead>Non-call</TableHead>
                    <TableHead>Strike</TableHead>
                    <TableHead>Issuer</TableHead>
                    <TableHead>Settlement</TableHead>
                    <TableHead>Trade</TableHead>
                    <TableHead>Final Valuation</TableHead>
                    {UNDERLYING_SLOTS.map((slot) => (
                      <TableHead key={`u-head-${slot}`}>Underlying {slot}</TableHead>
                    ))}
                  </>
                )}
            </TableRow>
          </TableHeader>
          <TableBody>
            {queueRows.map((row, index) => (
              <TableRow
                key={`review-row-${index}`}
                className={
                  (module === "structure" && rowHasUnmapped(row)) ||
                  (module === "accumulator" && accumulatorRowHasUnmapped(row))
                    ? "bg-amber-50/40"
                    : undefined
                }
              >
                <TableCell>
                  <input
                    type="checkbox"
                    checked={selected.includes(index)}
                    onChange={(event) => {
                      onSelectedChange(
                        event.target.checked
                          ? Array.from(new Set([...selected, index])).sort((a, b) => a - b)
                          : selected.filter((v) => v !== index),
                      )
                    }}
                  />
                </TableCell>
                <TableCell>{index + 1}</TableCell>
                <TableCell>
                  {renderStatusCell(
                    module,
                    row as StructureQueueRow,
                    index,
                    reviewData,
                    onEdit,
                    onView,
                    onRemove,
                    onAddUnderlying,
                  )}
                </TableCell>
                {module === "accumulator"
                  ? ACCUMULATOR_TABLE_COLUMNS.map((column) => (
                      <TableCell
                        key={`${column.key}-${index}`}
                        className={column.key === "Name" ? "max-w-[22rem] truncate" : undefined}
                        title={column.key === "Name" ? String(row[column.key] ?? "") : undefined}
                      >
                        {column.key === "UnderlyingISIN"
                          ? renderAccumulatorUnderlyingCell(row as AccumulatorQueueRow, index, onMapAccumulator)
                          : String(row[column.key] ?? "—")}
                      </TableCell>
                    ))
                  : (
                    <>
                      <TableCell>{String(row.ISIN ?? "—")}</TableCell>
                      <TableCell className="max-w-[22rem] truncate" title={String(row.Name ?? "")}>
                        {String(row.Name ?? "—")}
                      </TableCell>
                      <TableCell>{String(row.Coupon ?? "—")}</TableCell>
                      <TableCell>{String(row.Expiry ?? "—")}</TableCell>
                      <TableCell>{String(row.Observations ?? "—")}</TableCell>
                      <TableCell>{String(row.KO_Barrier ?? "—")}</TableCell>
                      <TableCell>{String(row.Product_Type ?? "—")}</TableCell>
                      <TableCell>{String(row.Non_Call_Period ?? "—")}</TableCell>
                      <TableCell>{String(row.Strike ?? "—")}</TableCell>
                      <TableCell>{String(row.Issuer ?? "—")}</TableCell>
                      <TableCell>{String(row.settlement_date ?? "—")}</TableCell>
                      <TableCell>{String(row.trade_date ?? "—")}</TableCell>
                      <TableCell>{String(row.final_valuation_date ?? "—")}</TableCell>
                      {UNDERLYING_SLOTS.map((slot) => (
                        <TableCell key={`u-cell-${index}-${slot}`}>
                          {renderUnderlyingCell(
                            module,
                            row as StructureQueueRow,
                            index,
                            slot,
                            onMapStructure,
                          )}
                        </TableCell>
                      ))}
                    </>
                  )}
              </TableRow>
            ))}
          </TableBody>
        </Table>
      </CardContent>
    </Card>
  )
}