import { Form, redirect, useLoaderData, useActionData, useNavigation } from 'react-router';
import type { Route } from './+types/admin.sports-seasons.$id.snooker-elo';

import { logger } from '~/lib/logger';
import { findSportsSeasonById, updateSportsSeason } from '~/models/sports-season';
import { findParticipantsBySportsSeasonId } from '~/models/participant';
import {
  getAllParticipantEVsForSeason,
  batchSaveSourceElos,
  batchUpsertParticipantEVs,
} from '~/models/participant-expected-value';
import { batchUpsertParticipantEvSnapshots } from '~/models/ev-snapshot';
import { getSimulator, type SimulatorType } from '~/services/simulations/registry';
import { calculateEV } from '~/services/ev-calculator';
import { DEFAULT_SCORING_RULES } from '~/lib/scoring-types';
import { recalculateStandings } from '~/models/scoring-calculator';
import { database } from '~/database/context';
import * as schema from '~/database/schema';
import { eq } from 'drizzle-orm';
import { Button } from '~/components/ui/button';
import { Input } from '~/components/ui/input';
import { Label } from '~/components/ui/label';
import { Textarea } from '~/components/ui/textarea';
import {
  Card,
  CardContent,
  CardDescription,
  CardHeader,
  CardTitle,
} from '~/components/ui/card';
import { useState } from 'react';
import { Loader2, CheckCircle2, AlertCircle } from 'lucide-react';
import { normalizeName } from '~/lib/fuzzy-match';

export function meta({ data }: Route.MetaArgs): Route.MetaDescriptors {
  return [{ title: `Snooker Elo & Rankings — ${data?.sportsSeason?.name ?? "Sports Season"} - Brackt Admin` }];
}

export async function loader({ params }: Route.LoaderArgs) {
  const sportsSeasonId = params.id;

  const sportsSeason = await findSportsSeasonById(sportsSeasonId);
  if (!sportsSeason) {
    throw new Response('Sports season not found', { status: 404 });
  }

  const participants = await findParticipantsBySportsSeasonId(sportsSeasonId);
  const existingEVs = await getAllParticipantEVsForSeason(sportsSeasonId);

  const existingData: Record<string, { elo: number | null; ranking: number | null }> = {};
  for (const ev of existingEVs) {
    existingData[ev.participantId] = {
      elo: ev.sourceElo ?? null,
      ranking: ev.worldRanking ?? null,
    };
  }

  return { sportsSeason, participants, existingData };
}

interface ActionData {
  success?: boolean;
  message?: string;
}

export async function action({ request, params }: Route.ActionArgs) {
  const sportsSeasonId = params.id;
  const formData = await request.formData();

  const sportsSeason = await findSportsSeasonById(sportsSeasonId);
  if (!sportsSeason) {
    return { success: false, message: 'Sports season not found' };
  }

  const participants = await findParticipantsBySportsSeasonId(sportsSeasonId);

  // Parse Elo ratings and world rankings from form
  const eloInputs: Array<{ participantId: string; sportsSeasonId: string; sourceElo: number; worldRanking?: number | null }> = [];
  for (const participant of participants) {
    const eloVal = formData.get(`elo_${participant.id}`) as string;
    const rankVal = formData.get(`rank_${participant.id}`) as string;

    if (eloVal && eloVal.trim() !== '') {
      const elo = Number(eloVal);
      if (!isNaN(elo) && elo > 0) {
        const ranking = rankVal && rankVal.trim() !== '' ? Number(rankVal) : null;
        eloInputs.push({
          participantId: participant.id,
          sportsSeasonId,
          sourceElo: elo,
          worldRanking: ranking && !isNaN(ranking) && ranking > 0 ? ranking : null,
        });
      }
    }
  }

  if (eloInputs.length === 0) {
    return { success: false, message: 'Please enter an Elo rating for at least one participant' };
  }

  if (!sportsSeason.sport?.simulatorType) {
    return { success: false, message: 'This sport has no simulator type configured. Set one on the sport in the admin panel.' };
  }

  if (sportsSeason.simulationStatus === 'running') {
    return { success: false, message: 'A simulation is already running. Please wait.' };
  }

  // Persist Elo ratings and world rankings
  await batchSaveSourceElos(eloInputs);

  // Auto-run simulation
  await updateSportsSeason(sportsSeasonId, { simulationStatus: 'running' });

  try {
    const simulator = getSimulator(sportsSeason.sport.simulatorType as SimulatorType);
    const results = await simulator.simulate(sportsSeasonId);

    if (results.length === 0) {
      throw new Error('Simulation returned no results.');
    }

    // Zero out any participants not in simulation results
    const simulatedIds = new Set(results.map(r => r.participantId));
    const ZERO_PROBS = {
      probFirst: 0, probSecond: 0, probThird: 0, probFourth: 0,
      probFifth: 0, probSixth: 0, probSeventh: 0, probEighth: 0,
    };
    const evInputs = [
      ...results.map(r => ({
        participantId: r.participantId,
        sportsSeasonId,
        probabilities: r.probabilities,
        scoringRules: DEFAULT_SCORING_RULES,
        source: 'elo_simulation' as const,
      })),
      ...participants
        .filter(p => !simulatedIds.has(p.id))
        .map(p => ({
          participantId: p.id,
          sportsSeasonId,
          probabilities: ZERO_PROBS,
          scoringRules: DEFAULT_SCORING_RULES,
          source: 'elo_simulation' as const,
        })),
    ];

    await batchUpsertParticipantEVs(evInputs);

    // Refresh projected points in team standings
    const seasonSports = await database().query.seasonSports.findMany({
      where: eq(schema.seasonSports.sportsSeasonId, sportsSeasonId),
    });
    await Promise.all(seasonSports.map(({ seasonId }) => recalculateStandings(seasonId)));

    // EV snapshot
    const today = new Date().toISOString().slice(0, 10);
    await batchUpsertParticipantEvSnapshots(
      results.map(r => ({
        participantId: r.participantId,
        sportsSeasonId,
        snapshotDate: today,
        probFirst: r.probabilities.probFirst,
        probSecond: r.probabilities.probSecond,
        probThird: r.probabilities.probThird,
        probFourth: r.probabilities.probFourth,
        probFifth: r.probabilities.probFifth,
        probSixth: r.probabilities.probSixth,
        probSeventh: r.probabilities.probSeventh,
        probEighth: r.probabilities.probEighth,
        calculatedEV: calculateEV(r.probabilities, DEFAULT_SCORING_RULES),
        source: r.source,
      }))
    );

    await updateSportsSeason(sportsSeasonId, { simulationStatus: 'idle' });
  } catch (error) {
    await updateSportsSeason(sportsSeasonId, { simulationStatus: 'failed' });
    logger.error('Error running snooker simulation:', error);
    return {
      success: false,
      message: error instanceof Error ? error.message : 'Simulation failed',
    };
  }

  return redirect(`/admin/sports-seasons/${sportsSeasonId}/expected-values`);
}

export default function AdminSportsSeasonSnookerElo() {
  const { sportsSeason, participants, existingData } = useLoaderData<typeof loader>();
  const actionData = useActionData<ActionData>();
  const navigation = useNavigation();

  const [eloValues, setEloValues] = useState<Record<string, string>>(() => {
    const initial: Record<string, string> = {};
    participants.forEach(p => {
      const d = existingData[p.id];
      if (d?.elo !== null && d?.elo !== undefined) initial[p.id] = d.elo.toString();
    });
    return initial;
  });

  const [rankValues, setRankValues] = useState<Record<string, string>>(() => {
    const initial: Record<string, string> = {};
    participants.forEach(p => {
      const d = existingData[p.id];
      if (d?.ranking !== null && d?.ranking !== undefined) initial[p.id] = d.ranking.toString();
    });
    return initial;
  });

  // Bulk import state: "Player Name, 1800, 1" format (name, elo, optional world ranking)
  const [bulkText, setBulkText] = useState('');
  const [parseResults, setParseResults] = useState<{
    matched: Array<{ participantId: string; name: string; elo: number; ranking: number | null; inputName: string }>;
    unmatched: Array<{ inputName: string; elo: number; ranking: number | null }>;
  } | null>(null);

  function findParticipantMatch(inputName: string) {
    const normalizedInput = normalizeName(inputName);
    const normalized = participants.map(p => ({ p, n: normalizeName(p.name) }));

    const exact = normalized.find(({ n }) => n === normalizedInput);
    if (exact) return exact.p;

    const contains = normalized.find(({ n }) => n.includes(normalizedInput) || normalizedInput.includes(n));
    if (contains) return contains.p;

    const inputWords = normalizedInput.split(' ').filter(w => w.length > 2);
    const overlap = normalized.find(({ n }) => {
      const pWords = n.split(' ').filter(w => w.length > 2);
      const shared = inputWords.filter(w => pWords.includes(w));
      return shared.length > 0 && shared.length >= Math.min(inputWords.length, pWords.length) * 0.5;
    });

    return overlap?.p ?? null;
  }

  function parseBulkText() {
    // Formats supported:
    //   "Player Name, 1800, 1"   (name, elo, world ranking)
    //   "Player Name, 1800"      (name, elo — ranking omitted)
    //   "Player Name: 1800: 1"   (colon-separated)
    const lines = bulkText.split('\n');
    const matched: typeof parseResults extends null ? never : NonNullable<typeof parseResults>['matched'] = [];
    const unmatched: typeof parseResults extends null ? never : NonNullable<typeof parseResults>['unmatched'] = [];
    const seen = new Set<string>();

    for (const line of lines) {
      const trimmed = line.trim();
      if (!trimmed) continue;

      // Match "Name, Elo" or "Name, Elo, Ranking" (comma, colon, or tab separated)
      const match = /^(.+?)[\s,:\t]+(\d{3,5})(?:[\s,:\t]+(\d{1,3}))?\s*$/.exec(trimmed);
      if (!match) continue;

      const inputName = match[1].trim();
      const elo = parseInt(match[2], 10);
      const ranking = match[3] ? parseInt(match[3], 10) : null;

      if (isNaN(elo) || elo < 500 || elo > 5000) continue;
      if (ranking !== null && (isNaN(ranking) || ranking < 1 || ranking > 256)) continue;

      const participant = findParticipantMatch(inputName);
      if (participant && !seen.has(participant.id)) {
        seen.add(participant.id);
        matched.push({ participantId: participant.id, name: participant.name, elo, ranking, inputName });
      } else if (!participant) {
        unmatched.push({ inputName, elo, ranking });
      }
    }

    setParseResults({ matched, unmatched });
  }

  function applyMatches() {
    if (!parseResults) return;
    const newElos = { ...eloValues };
    const newRanks = { ...rankValues };
    for (const m of parseResults.matched) {
      newElos[m.participantId] = m.elo.toString();
      if (m.ranking !== null) {
        newRanks[m.participantId] = m.ranking.toString();
      }
    }
    setEloValues(newElos);
    setRankValues(newRanks);
    setParseResults(null);
    setBulkText('');
  }

  const isSubmitting = navigation.state === 'submitting';

  // Sort participants for display: by current rank (ascending), then unranked alphabetically
  const sortedParticipants = [...participants].toSorted((a, b) => {
    const rankA = rankValues[a.id] ? parseInt(rankValues[a.id], 10) : null;
    const rankB = rankValues[b.id] ? parseInt(rankValues[b.id], 10) : null;
    if (rankA !== null && rankB !== null) return rankA - rankB;
    if (rankA !== null) return -1;
    if (rankB !== null) return 1;
    return a.name.localeCompare(b.name);
  });

  return (
    <div className="container mx-auto py-8">
      <div className="mb-8">
        <h1 className="text-3xl font-bold mb-2">Snooker Elo &amp; World Rankings</h1>
        <p className="text-muted-foreground">
          {sportsSeason.sport.name} — {sportsSeason.name}
        </p>
      </div>

      {/* Bulk Import */}
      <Card className="mb-6">
        <CardHeader>
          <CardTitle>Bulk Import</CardTitle>
          <CardDescription>
            Paste one player per line. Format:{' '}
            <code>Player Name, 1800, 1</code> (name, Elo, world ranking).
            The world ranking is required for bracket seeding — the top 16 ranked players
            are seeded, the rest are drawn as qualifiers. Omit the ranking and the simulator
            will seed by Elo order instead.
            Player names are fuzzy-matched to participants.
          </CardDescription>
        </CardHeader>
        <CardContent className="space-y-4">
          <Textarea
            placeholder={`Judd Trump, 2050, 1\nKyren Wilson, 1980, 2\nNeil Robertson, 1960, 3`}
            value={bulkText}
            onChange={e => { setBulkText(e.target.value); setParseResults(null); }}
            rows={10}
            className="font-mono text-sm"
          />
          <Button type="button" variant="outline" onClick={parseBulkText} disabled={!bulkText.trim()}>
            Parse
          </Button>

          {parseResults && (
            <div className="space-y-3">
              {parseResults.matched.length > 0 && (
                <div>
                  <div className="flex items-center gap-2 text-sm font-medium text-emerald-400 mb-2">
                    <CheckCircle2 className="h-4 w-4" />
                    Matched ({parseResults.matched.length})
                  </div>
                  <div className="rounded-md border border-emerald-500/30 bg-emerald-500/10 divide-y divide-emerald-500/20 text-sm">
                    {parseResults.matched.map(m => (
                      <div key={m.participantId} className="flex justify-between px-3 py-1.5">
                        <span className="text-muted-foreground">{m.inputName}</span>
                        <span className="font-medium">
                          {m.name} &rarr; Elo {m.elo}{m.ranking !== null ? `, Rank #${m.ranking}` : ''}
                        </span>
                      </div>
                    ))}
                  </div>
                </div>
              )}

              {parseResults.unmatched.length > 0 && (
                <div>
                  <div className="flex items-center gap-2 text-sm font-medium text-amber-700 mb-2">
                    <AlertCircle className="h-4 w-4" />
                    Not matched ({parseResults.unmatched.length}) — enter manually below
                  </div>
                  <div className="rounded-md border border-amber-200 bg-amber-50 divide-y divide-amber-100 text-sm">
                    {parseResults.unmatched.map(u => (
                      <div key={u.inputName} className="flex justify-between px-3 py-1.5">
                        <span>{u.inputName}</span>
                        <span className="font-medium">
                          Elo {u.elo}{u.ranking !== null ? `, Rank #${u.ranking}` : ''}
                        </span>
                      </div>
                    ))}
                  </div>
                </div>
              )}

              {parseResults.matched.length > 0 && (
                <Button type="button" onClick={applyMatches}>
                  Apply {parseResults.matched.length} matched entries to form
                </Button>
              )}
            </div>
          )}
        </CardContent>
      </Card>

      <div className="grid gap-6 lg:grid-cols-2">
        <Card>
          <CardHeader>
            <CardTitle>Player Elo &amp; Rankings</CardTitle>
            <CardDescription>
              Enter each player's Snooker Elo and world ranking. World ranking determines bracket
              seeding (top 16 seeded, rest randomly drawn). Saving will automatically run the
              simulation and update expected values.
            </CardDescription>
          </CardHeader>
          <CardContent>
            <Form method="post" className="space-y-4">
              <div className="grid grid-cols-[1fr_100px_80px] gap-x-3 gap-y-2 items-center text-xs font-medium text-muted-foreground mb-1">
                <span>Player</span>
                <span>Elo</span>
                <span>Rank #</span>
              </div>
              <div className="space-y-2">
                {sortedParticipants.map(participant => (
                  <div key={participant.id} className="grid grid-cols-[1fr_100px_80px] gap-x-3 items-center">
                    <Label htmlFor={`elo_${participant.id}`} className="truncate text-sm">
                      {participant.name}
                    </Label>
                    <Input
                      type="number"
                      id={`elo_${participant.id}`}
                      name={`elo_${participant.id}`}
                      placeholder="1600"
                      value={eloValues[participant.id] ?? ''}
                      onChange={e =>
                        setEloValues(prev => ({ ...prev, [participant.id]: e.target.value }))
                      }
                      className="h-8 text-sm"
                    />
                    <Input
                      type="number"
                      name={`rank_${participant.id}`}
                      placeholder="—"
                      value={rankValues[participant.id] ?? ''}
                      onChange={e =>
                        setRankValues(prev => ({ ...prev, [participant.id]: e.target.value }))
                      }
                      className="h-8 text-sm"
                    />
                  </div>
                ))}
              </div>

              {actionData && !actionData.success && actionData.message && (
                <div className="text-sm text-destructive">{actionData.message}</div>
              )}

              <Button type="submit" disabled={isSubmitting}>
                {isSubmitting && <Loader2 className="mr-2 h-4 w-4 animate-spin" />}
                {isSubmitting ? 'Saving & Running Simulation...' : 'Save & Run Simulation'}
              </Button>
            </Form>
          </CardContent>
        </Card>

        <Card>
          <CardHeader>
            <CardTitle>How It Works</CardTitle>
          </CardHeader>
          <CardContent className="text-sm space-y-2">
            <ol className="list-decimal list-inside space-y-2">
              <li>Save Elo ratings and world rankings for all players</li>
              <li>Top 16 seeds placed in fixed bracket positions; remaining players randomly drawn as qualifiers per simulation</li>
              <li>Qualifiers (seeds 17+) play best-of-19 qualifying rounds to fill the 32-player bracket if more than 16 are present</li>
              <li>Per-frame win probability: p = 1 / (1 + e^(−ΔElo/700))</li>
              <li>Match win probability via Bernoulli frames model for each round's best-of length</li>
              <li>Run 50,000 Monte Carlo simulations of the full bracket</li>
              <li>Distribute probabilities across 1st–8th place buckets</li>
            </ol>
            <div className="mt-4 text-muted-foreground text-xs space-y-1">
              <div>Round formats: R32 best-of-19, R16/QF best-of-25, SF best-of-33, Final best-of-35</div>
              <div>If world ranking is omitted, players are seeded by Elo order.</div>
              <div>Once the bracket draw is announced, add players to the bracket event for live simulation.</div>
            </div>
          </CardContent>
        </Card>
      </div>
    </div>
  );
}
