'use client'

import { useState } from 'react'
import Link from 'next/link'
import type { Route } from 'next'
import { trpc } from '@/lib/trpc/client'
import { Badge } from '@/components/ui/badge'
import { Button } from '@/components/ui/button'
import {
  Card,
  CardContent,
  CardHeader,
  CardTitle,
} from '@/components/ui/card'
import { Skeleton } from '@/components/ui/skeleton'
import { Input } from '@/components/ui/input'
import { Label } from '@/components/ui/label'
import { Switch } from '@/components/ui/switch'
import {
  Select,
  SelectContent,
  SelectItem,
  SelectTrigger,
  SelectValue,
} from '@/components/ui/select'
import {
  Dialog,
  DialogContent,
  DialogDescription,
  DialogFooter,
  DialogHeader,
  DialogTitle,
} from '@/components/ui/dialog'
import {
  Collapsible,
  CollapsibleContent,
  CollapsibleTrigger,
} from '@/components/ui/collapsible'
import { toast } from 'sonner'
import { cn } from '@/lib/utils'
import {
  Plus,
  Layers,
  Calendar,
  ChevronDown,
  ChevronRight,
  Settings,
  Users,
  FileBox,
  Save,
  Loader2,
} from 'lucide-react'
import { useEdition } from '@/contexts/edition-context'

const ROUND_TYPES = [
  { value: 'INTAKE', label: 'Intake' },
  { value: 'FILTERING', label: 'Filtering' },
  { value: 'EVALUATION', label: 'Evaluation' },
  { value: 'SUBMISSION', label: 'Submission' },
  { value: 'MENTORING', label: 'Mentoring' },
  { value: 'LIVE_FINAL', label: 'Live Final' },
  { value: 'DELIBERATION', label: 'Deliberation' },
] as const

const roundTypeColors: Record<string, string> = {
  INTAKE: 'bg-gray-100 text-gray-700',
  FILTERING: 'bg-amber-100 text-amber-700',
  EVALUATION: 'bg-blue-100 text-blue-700',
  SUBMISSION: 'bg-purple-100 text-purple-700',
  MENTORING: 'bg-teal-100 text-teal-700',
  LIVE_FINAL: 'bg-red-100 text-red-700',
  DELIBERATION: 'bg-indigo-100 text-indigo-700',
}

const statusConfig = {
  DRAFT: { label: 'Draft', bgClass: 'bg-gray-100 text-gray-700', dotClass: 'bg-gray-500' },
  ACTIVE: { label: 'Active', bgClass: 'bg-emerald-100 text-emerald-700', dotClass: 'bg-emerald-500' },
  CLOSED: { label: 'Closed', bgClass: 'bg-blue-100 text-blue-700', dotClass: 'bg-blue-500' },
  ARCHIVED: { label: 'Archived', bgClass: 'bg-muted text-muted-foreground', dotClass: 'bg-muted-foreground' },
} as const

const roundStatusColors: Record<string, string> = {
  ROUND_DRAFT: 'bg-gray-100 text-gray-600',
  ROUND_ACTIVE: 'bg-emerald-100 text-emerald-700',
  ROUND_CLOSED: 'bg-blue-100 text-blue-700',
  ROUND_ARCHIVED: 'bg-muted text-muted-foreground',
}

type RoundWithStats = {
  id: string
  name: string
  slug: string
  roundType: string
  status: string
  sortOrder: number
  windowOpenAt: string | null
  windowCloseAt: string | null
  juryGroup: { id: string; name: string } | null
  _count: { projectRoundStates: number; assignments: number }
}

export default function RoundsPage() {
  const { currentEdition } = useEdition()
  const programId = currentEdition?.id
  const utils = trpc.useUtils()

  const [addRoundOpen, setAddRoundOpen] = useState(false)
  const [roundForm, setRoundForm] = useState({ name: '', roundType: '', competitionId: '' })
  const [expandedCompetitions, setExpandedCompetitions] = useState<Set<string>>(new Set())
  const [editingCompetition, setEditingCompetition] = useState<string | null>(null)
  const [competitionEdits, setCompetitionEdits] = useState<Record<string, unknown>>({})
  const [filterType, setFilterType] = useState<string>('all')

  const { data: competitions, isLoading } = trpc.competition.list.useQuery(
    { programId: programId! },
    { enabled: !!programId }
  )

  const createRoundMutation = trpc.round.create.useMutation({
    onSuccess: () => {
      utils.competition.list.invalidate()
      toast.success('Round created')
      setAddRoundOpen(false)
      setRoundForm({ name: '', roundType: '', competitionId: '' })
    },
    onError: (err) => toast.error(err.message),
  })

  const updateCompMutation = trpc.competition.update.useMutation({
    onSuccess: () => {
      utils.competition.list.invalidate()
      toast.success('Competition settings saved')
      setEditingCompetition(null)
      setCompetitionEdits({})
    },
    onError: (err) => toast.error(err.message),
  })

  const toggleExpanded = (id: string) => {
    setExpandedCompetitions((prev) => {
      const next = new Set(prev)
      if (next.has(id)) next.delete(id)
      else next.add(id)
      return next
    })
  }

  const handleCreateRound = () => {
    if (!roundForm.name.trim() || !roundForm.roundType || !roundForm.competitionId) {
      toast.error('All fields are required')
      return
    }
    const slug = roundForm.name.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '')
    const comp = competitions?.find((c) => c.id === roundForm.competitionId)
    const nextOrder = comp ? (comp as any).rounds?.length ?? comp._count.rounds : 0
    createRoundMutation.mutate({
      competitionId: roundForm.competitionId,
      name: roundForm.name.trim(),
      slug,
      roundType: roundForm.roundType as any,
      sortOrder: nextOrder,
    })
  }

  const startEditCompetition = (comp: any) => {
    setEditingCompetition(comp.id)
    setCompetitionEdits({
      name: comp.name,
      categoryMode: comp.categoryMode,
      startupFinalistCount: comp.startupFinalistCount,
      conceptFinalistCount: comp.conceptFinalistCount,
      notifyOnDeadlineApproach: comp.notifyOnDeadlineApproach,
    })
  }

  const saveCompetitionEdit = (id: string) => {
    updateCompMutation.mutate({ id, ...competitionEdits } as any)
  }

  if (!programId) {
    return (
      <div className="space-y-6">
        <h1 className="text-xl font-bold">Rounds</h1>
        <Card className="border-dashed">
          <CardContent className="flex flex-col items-center justify-center py-12 text-center">
            <Calendar className="h-12 w-12 text-muted-foreground/50" />
            <p className="mt-2 font-medium">No Edition Selected</p>
            <p className="text-sm text-muted-foreground">Select an edition from the sidebar</p>
          </CardContent>
        </Card>
      </div>
    )
  }

  return (
    <div className="space-y-6">
      {/* Header */}
      <div className="flex flex-col gap-4 sm:flex-row sm:items-start sm:justify-between">
        <div>
          <h1 className="text-3xl font-bold tracking-tight text-[#053d57]">Competition Rounds</h1>
          <p className="text-base text-muted-foreground mt-1.5">
            Configure and manage evaluation rounds for {currentEdition?.name}
          </p>
        </div>
        <Button size="default" onClick={() => setAddRoundOpen(true)} className="bg-[#de0f1e] hover:bg-[#de0f1e]/90">
          <Plus className="h-4 w-4 mr-2" />
          Add Round
        </Button>
      </div>

      {/* Filter */}
      <Card className="p-4 shadow-sm">
        <div className="flex items-center gap-3">
          <Label className="text-sm font-medium shrink-0">Filter:</Label>
          <Select value={filterType} onValueChange={setFilterType}>
            <SelectTrigger className="w-48">
              <SelectValue placeholder="Filter by type" />
            </SelectTrigger>
            <SelectContent>
              <SelectItem value="all">All Types</SelectItem>
              {ROUND_TYPES.map((rt) => (
                <SelectItem key={rt.value} value={rt.value}>{rt.label}</SelectItem>
              ))}
            </SelectContent>
          </Select>
        </div>
      </Card>

      {/* Loading */}
      {isLoading && (
        <div className="space-y-4">
          {[1, 2].map((i) => (
            <Card key={i}>
              <CardHeader>
                <Skeleton className="h-5 w-48" />
              </CardHeader>
              <CardContent className="space-y-2">
                <Skeleton className="h-12 w-full" />
                <Skeleton className="h-12 w-full" />
              </CardContent>
            </Card>
          ))}
        </div>
      )}

      {/* Empty State */}
      {!isLoading && (!competitions || competitions.length === 0) && (
        <Card className="border-2 border-dashed shadow-sm">
          <CardContent className="flex flex-col items-center justify-center py-20 text-center">
            <div className="rounded-full bg-gradient-to-br from-[#de0f1e]/10 to-[#053d57]/10 p-6 mb-6">
              <Layers className="h-12 w-12 text-[#de0f1e]" />
            </div>
            <h3 className="text-xl font-semibold mb-2 text-[#053d57]">No Competitions Yet</h3>
            <p className="text-sm text-muted-foreground max-w-md mb-6 leading-relaxed">
              Create a competition first, then add rounds to define the evaluation flow.
            </p>
            <Link href={`/admin/competitions/new?programId=${programId}` as Route}>
              <Button className="bg-[#de0f1e] hover:bg-[#de0f1e]/90">
                <Plus className="h-4 w-4 mr-2" />
                Create Competition
              </Button>
            </Link>
          </CardContent>
        </Card>
      )}

      {/* Competition Groups with Rounds */}
      {competitions && competitions.length > 0 && (
        <div className="space-y-4">
          {competitions.map((comp) => {
            const status = comp.status as keyof typeof statusConfig
            const cfg = statusConfig[status] || statusConfig.DRAFT
            const isExpanded = expandedCompetitions.has(comp.id) || competitions.length === 1
            const isEditing = editingCompetition === comp.id

            return (
              <CompetitionGroup
                key={comp.id}
                competition={comp}
                statusConfig={cfg}
                isExpanded={isExpanded}
                isEditing={isEditing}
                competitionEdits={competitionEdits}
                filterType={filterType}
                updateCompMutation={updateCompMutation}
                onToggle={() => toggleExpanded(comp.id)}
                onStartEdit={() => startEditCompetition(comp)}
                onCancelEdit={() => { setEditingCompetition(null); setCompetitionEdits({}) }}
                onSaveEdit={() => saveCompetitionEdit(comp.id)}
                onEditChange={setCompetitionEdits}
              />
            )
          })}
        </div>
      )}

      {/* Add Round Dialog */}
      <Dialog open={addRoundOpen} onOpenChange={setAddRoundOpen}>
        <DialogContent>
          <DialogHeader>
            <DialogTitle>Add Round</DialogTitle>
            <DialogDescription>
              Create a new round in a competition.
            </DialogDescription>
          </DialogHeader>
          <div className="space-y-4">
            <div className="space-y-2">
              <Label>Competition *</Label>
              <Select
                value={roundForm.competitionId}
                onValueChange={(v) => setRoundForm({ ...roundForm, competitionId: v })}
              >
                <SelectTrigger>
                  <SelectValue placeholder="Select competition" />
                </SelectTrigger>
                <SelectContent>
                  {competitions?.filter((c) => c.status !== 'ARCHIVED').map((c) => (
                    <SelectItem key={c.id} value={c.id}>{c.name}</SelectItem>
                  ))}
                </SelectContent>
              </Select>
            </div>
            <div className="space-y-2">
              <Label>Round Name *</Label>
              <Input
                placeholder="e.g. Initial Screening"
                value={roundForm.name}
                onChange={(e) => setRoundForm({ ...roundForm, name: e.target.value })}
              />
            </div>
            <div className="space-y-2">
              <Label>Round Type *</Label>
              <Select
                value={roundForm.roundType}
                onValueChange={(v) => setRoundForm({ ...roundForm, roundType: v })}
              >
                <SelectTrigger>
                  <SelectValue placeholder="Select type" />
                </SelectTrigger>
                <SelectContent>
                  {ROUND_TYPES.map((rt) => (
                    <SelectItem key={rt.value} value={rt.value}>{rt.label}</SelectItem>
                  ))}
                </SelectContent>
              </Select>
            </div>
          </div>
          <DialogFooter>
            <Button variant="outline" onClick={() => setAddRoundOpen(false)}>Cancel</Button>
            <Button onClick={handleCreateRound} disabled={createRoundMutation.isPending}>
              {createRoundMutation.isPending ? 'Creating...' : 'Create Round'}
            </Button>
          </DialogFooter>
        </DialogContent>
      </Dialog>
    </div>
  )
}

// ─── Competition Group Component ─────────────────────────────────────────────

type CompetitionGroupProps = {
  competition: any
  statusConfig: { label: string; bgClass: string; dotClass: string }
  isExpanded: boolean
  isEditing: boolean
  competitionEdits: Record<string, unknown>
  filterType: string
  updateCompMutation: any
  onToggle: () => void
  onStartEdit: () => void
  onCancelEdit: () => void
  onSaveEdit: () => void
  onEditChange: (edits: Record<string, unknown>) => void
}

function CompetitionGroup({
  competition: comp,
  statusConfig: cfg,
  isExpanded,
  isEditing,
  competitionEdits,
  filterType,
  updateCompMutation,
  onToggle,
  onStartEdit,
  onCancelEdit,
  onSaveEdit,
  onEditChange,
}: CompetitionGroupProps) {
  // We need to fetch rounds for this competition
  const { data: compDetail } = trpc.competition.getById.useQuery(
    { id: comp.id },
    { enabled: isExpanded }
  )

  const rounds = (compDetail?.rounds ?? []) as RoundWithStats[]
  const filteredRounds = filterType === 'all'
    ? rounds
    : rounds.filter((r: RoundWithStats) => r.roundType === filterType)

  return (
    <Card className="shadow-sm border-l-4 transition-shadow hover:shadow-md" style={{ borderLeftColor: cfg.dotClass.includes('emerald') ? '#10b981' : cfg.dotClass.includes('blue') ? '#3b82f6' : '#9ca3af' }}>
      {/* Competition Header */}
      <CardHeader className="pb-4">
        <div className="flex items-center gap-4">
          <button
            onClick={onToggle}
            className="shrink-0 rounded-lg p-2 hover:bg-muted transition-colors"
          >
            {isExpanded ? (
              <ChevronDown className="h-5 w-5 text-muted-foreground" />
            ) : (
              <ChevronRight className="h-5 w-5 text-muted-foreground" />
            )}
          </button>

          <div className="flex-1 min-w-0">
            <div className="flex flex-wrap items-center gap-3 mb-1">
              <CardTitle className="text-lg font-semibold cursor-pointer text-[#053d57]" onClick={onToggle}>
                {comp.name}
              </CardTitle>
              <Badge variant="secondary" className={cn('text-xs font-medium px-2.5 py-0.5', cfg.bgClass)}>
                {cfg.label}
              </Badge>
            </div>
            <div className="flex flex-wrap items-center gap-3 text-sm text-muted-foreground">
              <div className="flex items-center gap-1.5">
                <Layers className="h-3.5 w-3.5" />
                <span>{comp._count.rounds} rounds</span>
              </div>
              <span className="text-muted-foreground/40">·</span>
              <div className="flex items-center gap-1.5">
                <Users className="h-3.5 w-3.5" />
                <span>{comp._count.juryGroups} juries</span>
              </div>
            </div>
          </div>

          <Button
            variant="ghost"
            size="icon"
            className="h-9 w-9 shrink-0"
            onClick={(e) => { e.stopPropagation(); onStartEdit() }}
          >
            <Settings className="h-4 w-4" />
          </Button>
        </div>
      </CardHeader>

      {/* Inline Competition Settings Editor */}
      {isEditing && (
        <CardContent className="border-t bg-gradient-to-br from-muted/30 to-muted/10 pt-6">
          <div className="space-y-6">
            <div>
              <h3 className="text-sm font-semibold text-[#053d57] mb-4">Competition Settings</h3>
              <div className="grid gap-4 sm:grid-cols-2 lg:grid-cols-3">
                <div className="space-y-2">
                  <Label className="text-xs font-medium">Competition Name</Label>
                  <Input
                    value={(competitionEdits.name as string) ?? ''}
                    onChange={(e) => onEditChange({ ...competitionEdits, name: e.target.value })}
                    className="h-9"
                  />
                </div>
                <div className="space-y-2">
                  <Label className="text-xs font-medium">Category Mode</Label>
                  <Input
                    value={(competitionEdits.categoryMode as string) ?? ''}
                    onChange={(e) => onEditChange({ ...competitionEdits, categoryMode: e.target.value })}
                    className="h-9"
                  />
                </div>
                <div className="space-y-2">
                  <Label className="text-xs font-medium">Startup Finalists</Label>
                  <Input
                    type="number"
                    min={1}
                    className="h-9"
                    value={(competitionEdits.startupFinalistCount as number) ?? 10}
                    onChange={(e) => onEditChange({ ...competitionEdits, startupFinalistCount: parseInt(e.target.value, 10) || 10 })}
                  />
                </div>
                <div className="space-y-2">
                  <Label className="text-xs font-medium">Concept Finalists</Label>
                  <Input
                    type="number"
                    min={1}
                    className="h-9"
                    value={(competitionEdits.conceptFinalistCount as number) ?? 10}
                    onChange={(e) => onEditChange({ ...competitionEdits, conceptFinalistCount: parseInt(e.target.value, 10) || 10 })}
                  />
                </div>
                <div className="flex items-center gap-3 pt-6">
                  <Switch
                    checked={(competitionEdits.notifyOnDeadlineApproach as boolean) ?? false}
                    onCheckedChange={(v) => onEditChange({ ...competitionEdits, notifyOnDeadlineApproach: v })}
                  />
                  <Label className="text-xs font-medium">Deadline Reminders</Label>
                </div>
              </div>
            </div>
            <div className="flex items-center gap-2 pt-2">
              <Button
                size="default"
                onClick={onSaveEdit}
                disabled={updateCompMutation.isPending}
                className="bg-[#de0f1e] hover:bg-[#de0f1e]/90"
              >
                {updateCompMutation.isPending ? (
                  <Loader2 className="h-4 w-4 mr-2 animate-spin" />
                ) : (
                  <Save className="h-4 w-4 mr-2" />
                )}
                Save Changes
              </Button>
              <Button size="default" variant="outline" onClick={onCancelEdit}>Cancel</Button>
            </div>
          </div>
        </CardContent>
      )}

      {/* Rounds List */}
      {isExpanded && (
        <CardContent className={cn(isEditing ? 'pt-6' : 'pt-2')}>
          {!compDetail ? (
            <div className="space-y-3">
              <Skeleton className="h-20 w-full" />
              <Skeleton className="h-20 w-full" />
            </div>
          ) : filteredRounds.length === 0 ? (
            <div className="py-12 text-center">
              <FileBox className="h-10 w-10 text-muted-foreground/50 mx-auto mb-3" />
              <p className="text-sm text-muted-foreground">
                {filterType !== 'all' ? 'No rounds match the filter.' : 'No rounds configured.'}
              </p>
            </div>
          ) : (
            <div className="relative space-y-3">
              {filteredRounds.map((round: RoundWithStats, index: number) => {
                const isLast = index === filteredRounds.length - 1
                const projectCount = round._count.projectRoundStates
                const progressPercent = projectCount > 0 ? Math.min((round._count.assignments / (projectCount * 3)) * 100, 100) : 0
                
                return (
                  <div key={round.id} className="relative">
                    <Link href={`/admin/rounds/${round.id}` as Route}>
                      <div className="flex items-start gap-4 rounded-xl border-2 border-border bg-card p-4 transition-all duration-200 hover:-translate-y-1 hover:shadow-lg hover:border-[#de0f1e]/30 cursor-pointer group">
                        {/* Round Number Circle */}
                        <div className="flex flex-col items-center gap-2 shrink-0">
                          <div className="flex h-10 w-10 items-center justify-center rounded-full bg-gradient-to-br from-[#053d57] to-[#557f8c] text-sm font-bold text-white shadow-md">
                            {round.sortOrder + 1}
                          </div>
                          {!isLast && (
                            <div className="h-8 w-0.5 bg-gradient-to-b from-[#053d57]/30 to-transparent" />
                          )}
                        </div>

                        {/* Round Content */}
                        <div className="min-w-0 flex-1">
                          <div className="flex flex-wrap items-start justify-between gap-3 mb-2">
                            <div className="min-w-0 flex-1">
                              <h4 className="text-base font-semibold truncate text-[#053d57] group-hover:text-[#de0f1e] transition-colors">
                                {round.name}
                              </h4>
                              <div className="flex flex-wrap items-center gap-3 text-xs text-muted-foreground mt-1.5">
                                <div className="flex items-center gap-1.5">
                                  <FileBox className="h-3.5 w-3.5" />
                                  <span className="font-medium">{projectCount}</span>
                                  <span>projects</span>
                                </div>
                                <span className="text-muted-foreground/40">·</span>
                                <div className="flex items-center gap-1.5">
                                  <Users className="h-3.5 w-3.5" />
                                  <span className="font-medium">{round._count.assignments}</span>
                                  <span>assignments</span>
                                </div>
                                {round.juryGroup && (
                                  <>
                                    <span className="text-muted-foreground/40">·</span>
                                    <span className="truncate">Jury: {round.juryGroup.name}</span>
                                  </>
                                )}
                                {(round.windowOpenAt || round.windowCloseAt) && (
                                  <>
                                    <span className="text-muted-foreground/40">·</span>
                                    <div className="flex items-center gap-1">
                                      <Calendar className="h-3.5 w-3.5" />
                                      <span className="truncate">
                                        {round.windowOpenAt && new Date(round.windowOpenAt).toLocaleDateString()}
                                        {round.windowOpenAt && round.windowCloseAt && ' - '}
                                        {round.windowCloseAt && new Date(round.windowCloseAt).toLocaleDateString()}
                                      </span>
                                    </div>
                                  </>
                                )}
                              </div>
                            </div>
                            <div className="flex items-center gap-2 shrink-0">
                              <Badge
                                variant="secondary"
                                className={cn('text-xs font-medium px-2.5 py-1', roundTypeColors[round.roundType])}
                              >
                                {round.roundType.replace('_', ' ')}
                              </Badge>
                              <Badge
                                variant="outline"
                                className={cn('text-xs font-medium px-2.5 py-1 hidden sm:inline-flex', roundStatusColors[round.status])}
                              >
                                {round.status.replace('ROUND_', '')}
                              </Badge>
                            </div>
                          </div>

                          {/* Progress Bar */}
                          {projectCount > 0 && (
                            <div className="mt-3">
                              <div className="h-1.5 w-full bg-muted rounded-full overflow-hidden">
                                <div 
                                  className="h-full bg-gradient-to-r from-[#557f8c] to-[#053d57] transition-all duration-500"
                                  style={{ width: `${progressPercent}%` }}
                                />
                              </div>
                            </div>
                          )}
                        </div>
                      </div>
                    </Link>
                  </div>
                )
              })}
            </div>
          )}
        </CardContent>
      )}
    </Card>
  )
}
