import { Head, Link, router, useForm } from '@inertiajs/react';
import { Library, Pencil, Plus, Trash2 } from 'lucide-react';
import { useState } from 'react';
import { ConfirmDialog } from '@/components/confirm-dialog';
import { EmptyState } from '@/components/empty-state';
import InputError from '@/components/input-error';
import { PageHeader } from '@/components/page-header';
import { StatusBadge } from '@/components/status-badge';
import { Button } from '@/components/ui/button';
import { Card, CardContent } from '@/components/ui/card';
import {
    Dialog,
    DialogContent,
    DialogFooter,
    DialogHeader,
    DialogTitle,
} from '@/components/ui/dialog';
import { Input } from '@/components/ui/input';
import { Label } from '@/components/ui/label';
import {
    Select,
    SelectContent,
    SelectItem,
    SelectTrigger,
    SelectValue,
} from '@/components/ui/select';
import { cn } from '@/lib/utils';
import { destroy, index, store, update } from '@/routes/reference';

type Item = {
    id: string;
    name: string;
    sort_order: number;
    is_active: boolean;
    type?: string | null;
    type_label?: string | null;
    location?: string | null;
};

type CourtType = { value: string; label: string };

type Props = {
    type: string;
    label: string;
    isCourts: boolean;
    courtTypes: CourtType[];
    items: Item[];
};

const TABS: { slug: string; label: string }[] = [
    { slug: 'courts', label: 'Courts' },
    { slug: 'practice-areas', label: 'Practice Areas' },
    { slug: 'matter-stages', label: 'Matter Stages' },
    { slug: 'contact-categories', label: 'Contact Categories' },
    { slug: 'document-types', label: 'Document Types' },
];

export default function ReferenceIndex({
    type,
    label,
    isCourts,
    courtTypes,
    items,
}: Props) {
    const [editing, setEditing] = useState<Item | null>(null);
    const [open, setOpen] = useState(false);

    const form = useForm({
        name: '',
        sort_order: 0,
        is_active: true,
        type: '' as string,
        location: '' as string,
    });

    const openCreate = () => {
        setEditing(null);
        form.setDefaults();
        form.reset();
        form.clearErrors();
        setOpen(true);
    };

    const openEdit = (item: Item) => {
        setEditing(item);
        form.setData({
            name: item.name,
            sort_order: item.sort_order,
            is_active: item.is_active,
            type: item.type ?? '',
            location: item.location ?? '',
        });
        form.clearErrors();
        setOpen(true);
    };

    const submit = (e: React.FormEvent) => {
        e.preventDefault();
        const opts = {
            preserveScroll: true,
            onSuccess: () => setOpen(false),
        };

        if (editing) {
            form.put(update({ type, reference: editing.id }).url, opts);
        } else {
            form.post(store(type).url, opts);
        }
    };

    return (
        <>
            <Head title={`Reference · ${label}`} />
            <div className="flex flex-col gap-6 p-4">
                <PageHeader
                    title="Reference Data"
                    subtitle="Firm-editable lists used across the system."
                    action={
                        <Button onClick={openCreate}>
                            <Plus /> Add {label.replace(/s$/, '')}
                        </Button>
                    }
                />

                <div className="flex flex-wrap gap-1 border-b border-border">
                    {TABS.map((tab) => (
                        <Link
                            key={tab.slug}
                            href={index(tab.slug)}
                            className={cn(
                                '-mb-px border-b-2 px-3 py-2 text-sm font-medium transition-colors',
                                tab.slug === type
                                    ? 'border-primary text-primary'
                                    : 'border-transparent text-muted-foreground hover:text-foreground',
                            )}
                        >
                            {tab.label}
                        </Link>
                    ))}
                </div>

                <Card>
                    <CardContent className="p-0">
                        {items.length === 0 ? (
                            <EmptyState
                                icon={Library}
                                title={`No ${label.toLowerCase()} yet`}
                                description="Add the first entry to this list."
                                action={
                                    <Button onClick={openCreate}>
                                        <Plus /> Add {label.replace(/s$/, '')}
                                    </Button>
                                }
                            />
                        ) : (
                            <ul className="divide-y divide-border">
                                {items.map((item) => (
                                    <li
                                        key={item.id}
                                        className="flex items-center justify-between gap-3 px-4 py-3"
                                    >
                                        <div className="min-w-0">
                                            <p className="truncate font-medium text-foreground">
                                                {item.name}
                                            </p>
                                            <p className="text-xs text-muted-foreground">
                                                {isCourts && item.type_label
                                                    ? `${item.type_label}${item.location ? ` · ${item.location}` : ''}`
                                                    : `Order: ${item.sort_order}`}
                                            </p>
                                        </div>
                                        <div className="flex items-center gap-2">
                                            <StatusBadge
                                                tone={
                                                    item.is_active
                                                        ? 'success'
                                                        : 'neutral'
                                                }
                                            >
                                                {item.is_active
                                                    ? 'Active'
                                                    : 'Inactive'}
                                            </StatusBadge>
                                            <Button
                                                variant="ghost"
                                                size="icon-sm"
                                                onClick={() => openEdit(item)}
                                            >
                                                <Pencil />
                                            </Button>
                                            <ConfirmDialog
                                                title={`Delete ${item.name}?`}
                                                confirmLabel="Delete"
                                                onConfirm={() =>
                                                    router.delete(
                                                        destroy({
                                                            type,
                                                            reference: item.id,
                                                        }).url,
                                                    )
                                                }
                                                trigger={
                                                    <Button
                                                        variant="ghost"
                                                        size="icon-sm"
                                                    >
                                                        <Trash2 />
                                                    </Button>
                                                }
                                            />
                                        </div>
                                    </li>
                                ))}
                            </ul>
                        )}
                    </CardContent>
                </Card>
            </div>

            <Dialog open={open} onOpenChange={setOpen}>
                <DialogContent>
                    <form onSubmit={submit}>
                        <DialogHeader>
                            <DialogTitle>
                                {editing ? 'Edit' : 'Add'}{' '}
                                {label.replace(/s$/, '')}
                            </DialogTitle>
                        </DialogHeader>
                        <div className="grid gap-4 py-4">
                            <div className="grid gap-2">
                                <Label htmlFor="ref-name">Name</Label>
                                <Input
                                    id="ref-name"
                                    value={form.data.name}
                                    onChange={(e) =>
                                        form.setData('name', e.target.value)
                                    }
                                    required
                                />
                                <InputError message={form.errors.name} />
                            </div>

                            {isCourts && (
                                <>
                                    <div className="grid gap-2">
                                        <Label>Court type</Label>
                                        <Select
                                            value={form.data.type}
                                            onValueChange={(v) =>
                                                form.setData('type', v)
                                            }
                                        >
                                            <SelectTrigger>
                                                <SelectValue placeholder="Select type" />
                                            </SelectTrigger>
                                            <SelectContent>
                                                {courtTypes.map((ct) => (
                                                    <SelectItem
                                                        key={ct.value}
                                                        value={ct.value}
                                                    >
                                                        {ct.label}
                                                    </SelectItem>
                                                ))}
                                            </SelectContent>
                                        </Select>
                                        <InputError
                                            message={form.errors.type}
                                        />
                                    </div>
                                    <div className="grid gap-2">
                                        <Label htmlFor="ref-location">
                                            Location (optional)
                                        </Label>
                                        <Input
                                            id="ref-location"
                                            value={form.data.location}
                                            onChange={(e) =>
                                                form.setData(
                                                    'location',
                                                    e.target.value,
                                                )
                                            }
                                        />
                                    </div>
                                </>
                            )}

                            <div className="grid gap-2">
                                <Label htmlFor="ref-order">Sort order</Label>
                                <Input
                                    id="ref-order"
                                    type="number"
                                    min={0}
                                    value={form.data.sort_order}
                                    onChange={(e) =>
                                        form.setData(
                                            'sort_order',
                                            Number(e.target.value),
                                        )
                                    }
                                />
                            </div>

                            <label className="flex items-center gap-2 text-sm">
                                <input
                                    type="checkbox"
                                    checked={form.data.is_active}
                                    onChange={(e) =>
                                        form.setData(
                                            'is_active',
                                            e.target.checked,
                                        )
                                    }
                                />
                                Active
                            </label>
                        </div>
                        <DialogFooter>
                            <Button type="submit" disabled={form.processing}>
                                Save
                            </Button>
                        </DialogFooter>
                    </form>
                </DialogContent>
            </Dialog>
        </>
    );
}
