import { useState, useEffect } from 'react';
import { Card, CardContent, CardHeader, CardTitle } from '@/components/ui/card';
import { Button } from '@/components/ui/button';
import { Textarea } from '@/components/ui/textarea';
import { Badge } from '@/components/ui/badge';
import { Table, TableBody, TableCell, TableHead, TableHeader, TableRow } from '@/components/ui/table';
import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from '@/components/ui/select';
import { parseTransactionLine, formatISK } from '@/utils/priceUtils';
import { IndTransactionRecordNoId, IndJobStatusOptions } from '@/lib/pbtypes';
import { IndJob } from '@/lib/types';
import { X } from 'lucide-react';

interface BatchTransactionFormProps {
  onClose: () => void;
  onTransactionsAssigned: (assignments: { jobId: string, transactions: IndTransactionRecordNoId[] }[]) => void;
  jobs: IndJob[];
}

interface ParsedTransaction extends IndTransactionRecordNoId {
  assignedJobId?: string;
  isDuplicate?: boolean;
}

interface TransactionGroup {
  itemName: string;
  transactions: ParsedTransaction[];
  totalQuantity: number;
  totalValue: number;
}

const BatchTransactionForm: React.FC<BatchTransactionFormProps> = ({ onClose, onTransactionsAssigned, jobs }) => {
  const [pastedData, setPastedData] = useState('');
  const [transactionGroups, setTransactionGroups] = useState<TransactionGroup[]>([]);
  const [duplicatesFound, setDuplicatesFound] = useState(0);

  // Filter jobs that are either running, selling, or tracked
  const eligibleJobs = jobs.filter(job =>
    job.status === IndJobStatusOptions.Running ||
    job.status === IndJobStatusOptions.Selling ||
    job.status === IndJobStatusOptions.Tracked
  );

  const findMatchingJob = (itemName: string): string | undefined => {
    // First try exact match
    const exactMatch = eligibleJobs.find(job => job.outputItem === itemName);
    if (exactMatch) return exactMatch.id;

    // Then try case-insensitive match
    const caseInsensitiveMatch = eligibleJobs.find(job =>
      job.outputItem.toLowerCase() === itemName.toLowerCase()
    );
    if (caseInsensitiveMatch) return caseInsensitiveMatch.id;

    return undefined;
  };

  const normalizeDate = (dateStr: string): string => {
    // Convert any ISO date string to consistent format with space
    return dateStr.replace('T', ' ');
  };

  const createTransactionKey = (parsed: ReturnType<typeof parseTransactionLine>): string => {
    if (!parsed) return '';
    const key = [
      normalizeDate(parsed.date.toISOString()),
      parsed.itemName,
      parsed.quantity.toString(),
      parsed.totalAmount.toString(),
      parsed.buyer,
      parsed.location
    ].join('|');
    console.log('Created key from parsed transaction:', {
      key,
      date: normalizeDate(parsed.date.toISOString()),
      itemName: parsed.itemName,
      quantity: parsed.quantity,
      totalAmount: parsed.totalAmount,
      buyer: parsed.buyer,
      location: parsed.location
    });
    return key;
  };

  const createTransactionKeyFromRecord = (tx: IndTransactionRecordNoId): string => {
    const key = [
      normalizeDate(tx.date),
      tx.itemName,
      tx.quantity.toString(),
      tx.totalPrice.toString(),
      tx.buyer,
      tx.location
    ].join('|');
    console.log('Created key from existing transaction:', {
      key,
      date: normalizeDate(tx.date),
      itemName: tx.itemName,
      quantity: tx.quantity,
      totalPrice: tx.totalPrice,
      buyer: tx.buyer,
      location: tx.location
    });
    return key;
  };

  const handlePaste = (value: string) => {
    setPastedData(value);
    const lines = value.trim().split('\n');
    const transactions: ParsedTransaction[] = [];
    const seenTransactions = new Set<string>();
    const pasteTransactionMap = new Map<string, ParsedTransaction>();

    // Pre-populate seenTransactions with existing transactions from jobs
    eligibleJobs.forEach(job => {
      job.income.forEach(tx => {
        const key = createTransactionKeyFromRecord(tx);
        seenTransactions.add(key);
      });
    });

    let duplicates = 0;
    lines.forEach((line, index) => {
      const parsed = parseTransactionLine(line);
      if (parsed) {
        const transactionKey = createTransactionKey(parsed);
        const isDuplicate = seenTransactions.has(transactionKey);

        if (isDuplicate) {
          duplicates++;
        }

        // Check if this exact transaction already exists in our paste data
        if (pasteTransactionMap.has(transactionKey)) {
          // Merge with existing transaction in paste
          const existing = pasteTransactionMap.get(transactionKey)!;
          existing.quantity += parsed.quantity;
          existing.totalPrice += Math.abs(parsed.totalAmount);
        } else {
          // Add new transaction
          const newTransaction: ParsedTransaction = {
            date: parsed.date.toISOString(),
            quantity: parsed.quantity,
            itemName: parsed.itemName,
            unitPrice: parsed.unitPrice,
            totalPrice: Math.abs(parsed.totalAmount),
            buyer: parsed.buyer,
            location: parsed.location,
            corporation: parsed.corporation,
            wallet: parsed.wallet,
            assignedJobId: !isDuplicate ? findMatchingJob(parsed.itemName) : undefined,
            isDuplicate
          };
          pasteTransactionMap.set(transactionKey, newTransaction);

          if (!isDuplicate) {
            seenTransactions.add(transactionKey);
          }
        }
      }
    });

    // Convert map to array for display - each transaction is individual
    const transactionList = Array.from(pasteTransactionMap.values());
    setDuplicatesFound(duplicates);

    // Create individual transaction groups (no grouping by item name)
    const groups = transactionList.map(tx => ({
      itemName: tx.itemName,
      transactions: [tx],
      totalQuantity: tx.quantity,
      totalValue: tx.totalPrice
    }));

    setTransactionGroups(groups);
  };

  const handleAssignJob = (groupIndex: number, jobId: string) => {
    setTransactionGroups(prev => {
      const newGroups = [...prev];
      newGroups[groupIndex].transactions.forEach(tx => {
        tx.assignedJobId = jobId;
      });
      return newGroups;
    });
  };

  const handleSubmit = () => {
    // Group transactions by assigned job
    const assignments = transactionGroups
      .flatMap(group => group.transactions)
      .filter(tx => tx.assignedJobId)
      .reduce((acc, tx) => {
        const jobId = tx.assignedJobId!;
        const existing = acc.find(a => a.jobId === jobId);
        if (existing) {
          existing.transactions.push(tx);
        } else {
          acc.push({ jobId, transactions: [tx] });
        }
        return acc;
      }, [] as { jobId: string, transactions: IndTransactionRecordNoId[] }[]);

    onTransactionsAssigned(assignments);
    onClose();
  };

  const allAssigned = transactionGroups.every(group =>
    group.transactions.every(tx => tx.assignedJobId)
  );

  return (
    <div className="fixed inset-0 bg-black/50 flex items-center justify-center p-4 z-50">
      <Card className="bg-gray-900 border-gray-700 text-white w-full max-w-4xl max-h-[90vh] overflow-y-auto">
        <CardHeader className="flex flex-row items-center justify-between sticky top-0 bg-gray-900 border-b border-gray-700 z-10">
          <CardTitle className="text-blue-400">Batch Transaction Assignment</CardTitle>
          <Button
            variant="ghost"
            size="icon"
            onClick={onClose}
            className="text-gray-400 hover:text-white"
          >
            <X className="h-4 w-4" />
          </Button>
        </CardHeader>
        <CardContent className="space-y-4">
          <div className="space-y-2">
            <label className="text-sm font-medium text-gray-300">
              Paste EVE transaction data:
            </label>
            <Textarea
              value={pastedData}
              onChange={(e) => handlePaste(e.target.value)}
              placeholder="Paste your EVE transaction data here..."
              className="min-h-32 bg-gray-800 border-gray-600 text-white"
            />
          </div>

          {transactionGroups.length > 0 && (
            <div className="space-y-4">
              <div className="flex items-center justify-between">
                <div className="flex items-center gap-4">
                  <Badge variant="outline" className="text-blue-400 border-blue-400">
                    {transactionGroups.length} transactions found
                  </Badge>
                  {duplicatesFound > 0 && (
                    <Badge variant="outline" className="text-yellow-400 border-yellow-400">
                      {duplicatesFound} duplicates found
                    </Badge>
                  )}
                </div>
              </div>

              <Table>
                <TableHeader>
                  <TableRow className="border-gray-700">
                    <TableHead className="text-gray-300">Item</TableHead>
                    <TableHead className="text-gray-300">Quantity</TableHead>
                    <TableHead className="text-gray-300">Total Value</TableHead>
                    <TableHead className="text-gray-300">Assign To Job</TableHead>
                  </TableRow>
                </TableHeader>
                <TableBody>
                  {transactionGroups.map((group, index) => {
                    const autoAssigned = group.transactions[0]?.assignedJobId;
                    const isDuplicate = group.transactions[0]?.isDuplicate;
                    const matchingJob = autoAssigned ? jobs.find(j => j.id === autoAssigned) : undefined;

                    return (
                      <TableRow
                        key={group.itemName}
                        className={`border-gray-700 ${isDuplicate ? 'bg-red-900/30' : ''}`}
                      >
                        <TableCell className="text-white flex items-center gap-2">
                          {group.itemName}
                          {isDuplicate && (
                            <Badge variant="destructive" className="bg-red-600">
                              Duplicate
                            </Badge>
                          )}
                        </TableCell>
                        <TableCell className="text-gray-300">
                          {group.totalQuantity.toLocaleString()}
                        </TableCell>
                        <TableCell className="text-green-400">
                          {formatISK(group.totalValue)}
                        </TableCell>
                        <TableCell>
                          {isDuplicate ? (
                            <div className="text-red-400 text-sm">
                              Transaction already exists
                            </div>
                          ) : (
                            <Select
                              value={group.transactions[0]?.assignedJobId || ''}
                              onValueChange={(value) => handleAssignJob(index, value)}
                            >
                              <SelectTrigger
                                className={`bg-gray-800 border-gray-600 text-white ${autoAssigned ? 'border-green-600' : ''}`}
                              >
                                <SelectValue placeholder={autoAssigned ? `Auto-assigned to ${matchingJob?.outputItem}` : 'Select a job'} />
                              </SelectTrigger>
                              <SelectContent className="bg-gray-800 border-gray-600">
                                {eligibleJobs
                                  .filter(job => job.outputItem.includes(group.itemName) || job.status === 'Tracked')
                                  .map(job => (
                                    <SelectItem
                                      key={job.id}
                                      value={job.id}
                                      className="text-white"
                                    >
                                      {job.outputItem} ({job.status})
                                    </SelectItem>
                                  ))}
                              </SelectContent>
                            </Select>
                          )}
                        </TableCell>
                      </TableRow>
                    );
                  })}
                </TableBody>
              </Table>

              <div className="flex justify-end gap-2">
                <Button
                  variant="outline"
                  onClick={onClose}
                  className="border-gray-600 hover:bg-gray-800"
                >
                  Cancel
                </Button>
                <Button
                  onClick={handleSubmit}
                  disabled={!transactionGroups.some(g => g.transactions.some(tx => !tx.isDuplicate && tx.assignedJobId))}
                  className="bg-blue-600 hover:bg-blue-700"
                >
                  Assign Transactions
                </Button>
              </div>
            </div>
          )}
        </CardContent>
      </Card>
    </div>
  );
};

export default BatchTransactionForm;