import { Head } from '@inertiajs/react';
import { Key, Plus, Trash2 } from 'lucide-react';
import { useState } from 'react';

import { type BreadcrumbItem } from '@/types';
import AppLayout from '@/layouts/app-layout';
import { Button } from '@/components/ui/button';
import { Card, CardContent, CardDescription, CardHeader, CardTitle } from '@/components/ui/card';
import { Input } from '@/components/ui/input';
import { Label } from '@/components/ui/label';
import { Badge } from '@/components/ui/badge';
import { Table, TableBody, TableCell, TableHead, TableHeader, TableRow } from '@/components/ui/table';
import { usePage } from '@inertiajs/react';
import { SharedData } from '@/types';

const breadcrumbs: BreadcrumbItem[] = [
    { title: 'Dashboard', href: '/' },
    { title: 'API Tokens', href: '/api-tokens' },
];

interface Token {
    id: number;
    name: string;
    abilities: string[];
    last_used_at: string | null;
    created_at: string;
}

export default function ApiTokensIndex() {
    const [tokens, setTokens] = useState<Token[]>([]);
    const [loading, setLoading] = useState(false);
    const [tokenName, setTokenName] = useState('');
    const [newToken, setNewToken] = useState<string | null>(null);
    const { auth } = usePage<SharedData>().props;

    const fetchTokens = async () => {
        setLoading(true);
        try {
            const res = await fetch('/api/v1/auth/tokens', {
                headers: { 'Accept': 'application/json' },
                credentials: 'same-origin',
            });
            const json = await res.json();
            setTokens(json.data || []);
        } catch {
            // ignore
        }
        setLoading(false);
    };

    const createToken = async (e: React.FormEvent) => {
        e.preventDefault();
        try {
            const res = await fetch('/api/v1/auth/tokens', {
                method: 'POST',
                headers: { 'Content-Type': 'application/json', 'Accept': 'application/json' },
                credentials: 'same-origin',
                body: JSON.stringify({ name: tokenName }),
            });
            const json = await res.json();
            if (json.data?.token) {
                setNewToken(json.data.token);
                setTokenName('');
                fetchTokens();
            }
        } catch {
            // ignore
        }
    };

    const revokeToken = async (id: number) => {
        if (!confirm('Révoquer ce token ?')) return;
        try {
            await fetch(`/api/v1/auth/tokens/${id}`, {
                method: 'DELETE',
                headers: { 'Accept': 'application/json' },
                credentials: 'same-origin',
            });
            fetchTokens();
        } catch {
            // ignore
        }
    };

    return (
        <AppLayout breadcrumbs={breadcrumbs}>
            <Head title="API Tokens" />
            <div className="flex h-full flex-1 flex-col gap-6 p-6">
                <div>
                    <h1 className="text-2xl font-bold tracking-tight">API Tokens</h1>
                    <p className="text-muted-foreground text-sm mt-1">
                        Tokens Sanctum pour les intégrations externes (accès longue durée)
                    </p>
                </div>

                {/* Create token */}
                <Card>
                    <CardHeader>
                        <CardTitle className="text-lg">Créer un token</CardTitle>
                        <CardDescription>
                            Le token ne sera affiché qu'une seule fois. Copiez-le immédiatement.
                        </CardDescription>
                    </CardHeader>
                    <CardContent>
                        <form onSubmit={createToken} className="flex items-end gap-3">
                            <div className="flex-1">
                                <Label htmlFor="token-name">Nom du token</Label>
                                <Input
                                    id="token-name"
                                    placeholder="Ex: Integration ERP"
                                    value={tokenName}
                                    onChange={(e) => setTokenName(e.target.value)}
                                    required
                                />
                            </div>
                            <Button type="submit" className="gap-2">
                                <Plus className="size-4" />
                                Créer
                            </Button>
                        </form>

                        {newToken && (
                            <div className="mt-4 rounded-lg border border-green-200 bg-green-50 dark:border-green-800 dark:bg-green-950 p-4">
                                <p className="text-sm font-medium text-green-800 dark:text-green-200 mb-2">
                                    ✓ Token créé ! Copiez-le maintenant (ne sera plus affiché) :
                                </p>
                                <code className="block text-xs bg-white dark:bg-black rounded p-2 break-all select-all">
                                    {newToken}
                                </code>
                                <Button
                                    variant="ghost"
                                    size="sm"
                                    className="mt-2"
                                    onClick={() => navigator.clipboard.writeText(newToken)}
                                >
                                    Copier
                                </Button>
                            </div>
                        )}
                    </CardContent>
                </Card>

                {/* Token list */}
                <Card>
                    <CardHeader className="flex flex-row items-center justify-between">
                        <CardTitle className="text-lg">Tokens actifs</CardTitle>
                        <Button variant="ghost" size="sm" onClick={fetchTokens} disabled={loading}>
                            {loading ? 'Chargement...' : 'Rafraîchir'}
                        </Button>
                    </CardHeader>
                    <CardContent>
                        <Table>
                            <TableHeader>
                                <TableRow>
                                    <TableHead>Nom</TableHead>
                                    <TableHead>Abilities</TableHead>
                                    <TableHead>Dernière utilisation</TableHead>
                                    <TableHead>Créé le</TableHead>
                                    <TableHead className="w-12"></TableHead>
                                </TableRow>
                            </TableHeader>
                            <TableBody>
                                {tokens.length === 0 ? (
                                    <TableRow>
                                        <TableCell colSpan={5} className="text-center text-muted-foreground py-12">
                                            <Key className="size-8 mx-auto mb-2 opacity-50" />
                                            Aucun token. Cliquez sur « Rafraîchir » pour charger.
                                        </TableCell>
                                    </TableRow>
                                ) : (
                                    tokens.map((token) => (
                                        <TableRow key={token.id}>
                                            <TableCell className="font-medium">{token.name}</TableCell>
                                            <TableCell>
                                                {token.abilities?.map((a) => (
                                                    <Badge key={a} variant="secondary" className="text-xs mr-1">
                                                        {a}
                                                    </Badge>
                                                ))}
                                            </TableCell>
                                            <TableCell className="text-sm text-muted-foreground">
                                                {token.last_used_at
                                                    ? new Date(token.last_used_at).toLocaleString('fr-FR')
                                                    : 'Jamais'}
                                            </TableCell>
                                            <TableCell className="text-sm text-muted-foreground">
                                                {new Date(token.created_at).toLocaleDateString('fr-FR')}
                                            </TableCell>
                                            <TableCell>
                                                <Button
                                                    variant="ghost"
                                                    size="icon"
                                                    onClick={() => revokeToken(token.id)}
                                                    className="text-destructive hover:text-destructive"
                                                >
                                                    <Trash2 className="size-4" />
                                                </Button>
                                            </TableCell>
                                        </TableRow>
                                    ))
                                )}
                            </TableBody>
                        </Table>
                    </CardContent>
                </Card>
            </div>
        </AppLayout>
    );
}
