import { Head, router, useForm } from '@inertiajs/react';
import {
    MoreVertical,
    ShieldOff,
    UserPlus,
    UserX,
    Users as UsersIcon,
} 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 { Badge } from '@/components/ui/badge';
import { Button } from '@/components/ui/button';
import { Card, CardContent } from '@/components/ui/card';
import {
    Dialog,
    DialogContent,
    DialogDescription,
    DialogFooter,
    DialogHeader,
    DialogTitle,
} from '@/components/ui/dialog';
import {
    DropdownMenu,
    DropdownMenuContent,
    DropdownMenuItem,
    DropdownMenuTrigger,
} from '@/components/ui/dropdown-menu';
import { Input } from '@/components/ui/input';
import { Label } from '@/components/ui/label';
import {
    Table,
    TableBody,
    TableCell,
    TableHead,
    TableHeader,
    TableRow,
} from '@/components/ui/table';
import {
    forceLogout,
    reinstate,
    resetTwoFactor,
    store,
    suspend,
} from '@/routes/users';

type ManagedUser = {
    id: string;
    name: string;
    email: string;
    status: string;
    roles: string[];
    two_factor: boolean;
    last_login_at: string | null;
    is_self: boolean;
};

export default function UsersIndex({
    users,
    roles,
}: {
    users: ManagedUser[];
    roles: string[];
}) {
    const [inviteOpen, setInviteOpen] = useState(false);
    const [resetUser, setResetUser] = useState<ManagedUser | null>(null);

    const invite = useForm({ name: '', email: '', roles: [] as string[] });
    const reset = useForm({ reason: '' });

    const toggleRole = (role: string) => {
        invite.setData(
            'roles',
            invite.data.roles.includes(role)
                ? invite.data.roles.filter((r) => r !== role)
                : [...invite.data.roles, role],
        );
    };

    const submitInvite = (e: React.FormEvent) => {
        e.preventDefault();
        invite.post(store().url, {
            preserveScroll: true,
            onSuccess: () => {
                invite.reset();
                setInviteOpen(false);
            },
        });
    };

    const submitReset = (e: React.FormEvent) => {
        e.preventDefault();

        if (!resetUser) {
            return;
        }

        reset.post(resetTwoFactor(resetUser.id).url, {
            preserveScroll: true,
            onSuccess: () => {
                reset.reset();
                setResetUser(null);
            },
        });
    };

    return (
        <>
            <Head title="Users" />
            <div className="flex flex-col gap-6 p-4">
                <PageHeader
                    title="Users"
                    subtitle="Invite teammates and manage their access."
                    action={
                        <Button onClick={() => setInviteOpen(true)}>
                            <UserPlus /> Invite user
                        </Button>
                    }
                />

                <Card>
                    <CardContent className="p-0">
                        {users.length === 0 ? (
                            <EmptyState
                                icon={UsersIcon}
                                title="No users yet"
                                description="Invite your first teammate to the firm."
                            />
                        ) : (
                            <Table>
                                <TableHeader>
                                    <TableRow>
                                        <TableHead>Name</TableHead>
                                        <TableHead>Roles</TableHead>
                                        <TableHead>2FA</TableHead>
                                        <TableHead>Status</TableHead>
                                        <TableHead className="text-right">
                                            Actions
                                        </TableHead>
                                    </TableRow>
                                </TableHeader>
                                <TableBody>
                                    {users.map((user) => (
                                        <TableRow key={user.id}>
                                            <TableCell>
                                                <p className="font-medium text-foreground">
                                                    {user.name}
                                                </p>
                                                <p className="text-xs text-muted-foreground">
                                                    {user.email}
                                                </p>
                                            </TableCell>
                                            <TableCell>
                                                <div className="flex flex-wrap gap-1">
                                                    {user.roles.length ? (
                                                        user.roles.map((r) => (
                                                            <Badge
                                                                key={r}
                                                                variant="secondary"
                                                            >
                                                                {r}
                                                            </Badge>
                                                        ))
                                                    ) : (
                                                        <span className="text-muted-foreground">
                                                            —
                                                        </span>
                                                    )}
                                                </div>
                                            </TableCell>
                                            <TableCell>
                                                <StatusBadge
                                                    tone={
                                                        user.two_factor
                                                            ? 'success'
                                                            : 'warning'
                                                    }
                                                >
                                                    {user.two_factor
                                                        ? 'Enabled'
                                                        : 'Off'}
                                                </StatusBadge>
                                            </TableCell>
                                            <TableCell>
                                                <StatusBadge
                                                    tone={
                                                        user.status === 'active'
                                                            ? 'success'
                                                            : 'danger'
                                                    }
                                                >
                                                    {user.status === 'active'
                                                        ? 'Active'
                                                        : 'Suspended'}
                                                </StatusBadge>
                                            </TableCell>
                                            <TableCell className="text-right">
                                                <DropdownMenu>
                                                    <DropdownMenuTrigger
                                                        asChild
                                                    >
                                                        <Button
                                                            variant="ghost"
                                                            size="icon-sm"
                                                            disabled={
                                                                user.is_self
                                                            }
                                                        >
                                                            <MoreVertical />
                                                        </Button>
                                                    </DropdownMenuTrigger>
                                                    <DropdownMenuContent align="end">
                                                        {user.status ===
                                                        'active' ? (
                                                            <DropdownMenuItem
                                                                onSelect={() =>
                                                                    router.post(
                                                                        suspend(
                                                                            user.id,
                                                                        ).url,
                                                                    )
                                                                }
                                                            >
                                                                <UserX />{' '}
                                                                Suspend
                                                            </DropdownMenuItem>
                                                        ) : (
                                                            <DropdownMenuItem
                                                                onSelect={() =>
                                                                    router.post(
                                                                        reinstate(
                                                                            user.id,
                                                                        ).url,
                                                                    )
                                                                }
                                                            >
                                                                Reinstate
                                                            </DropdownMenuItem>
                                                        )}
                                                        <DropdownMenuItem
                                                            onSelect={() =>
                                                                router.post(
                                                                    forceLogout(
                                                                        user.id,
                                                                    ).url,
                                                                )
                                                            }
                                                        >
                                                            Force logout
                                                        </DropdownMenuItem>
                                                        <DropdownMenuItem
                                                            onSelect={() =>
                                                                setResetUser(
                                                                    user,
                                                                )
                                                            }
                                                        >
                                                            <ShieldOff /> Reset
                                                            2FA
                                                        </DropdownMenuItem>
                                                    </DropdownMenuContent>
                                                </DropdownMenu>
                                            </TableCell>
                                        </TableRow>
                                    ))}
                                </TableBody>
                            </Table>
                        )}
                    </CardContent>
                </Card>
            </div>

            {/* Invite dialog */}
            <Dialog open={inviteOpen} onOpenChange={setInviteOpen}>
                <DialogContent>
                    <form onSubmit={submitInvite}>
                        <DialogHeader>
                            <DialogTitle>Invite a user</DialogTitle>
                            <DialogDescription>
                                They'll receive a secure link to set their
                                password.
                            </DialogDescription>
                        </DialogHeader>
                        <div className="grid gap-4 py-4">
                            <div className="grid gap-2">
                                <Label htmlFor="invite-name">Name</Label>
                                <Input
                                    id="invite-name"
                                    value={invite.data.name}
                                    onChange={(e) =>
                                        invite.setData('name', e.target.value)
                                    }
                                    required
                                />
                                <InputError message={invite.errors.name} />
                            </div>
                            <div className="grid gap-2">
                                <Label htmlFor="invite-email">Email</Label>
                                <Input
                                    id="invite-email"
                                    type="email"
                                    value={invite.data.email}
                                    onChange={(e) =>
                                        invite.setData('email', e.target.value)
                                    }
                                    required
                                />
                                <InputError message={invite.errors.email} />
                            </div>
                            <div className="grid gap-2">
                                <Label>Roles</Label>
                                <div className="grid grid-cols-2 gap-2">
                                    {roles.map((role) => (
                                        <label
                                            key={role}
                                            className="flex items-center gap-2 text-sm"
                                        >
                                            <input
                                                type="checkbox"
                                                checked={invite.data.roles.includes(
                                                    role,
                                                )}
                                                onChange={() =>
                                                    toggleRole(role)
                                                }
                                            />
                                            {role}
                                        </label>
                                    ))}
                                </div>
                                <InputError message={invite.errors.roles} />
                            </div>
                        </div>
                        <DialogFooter>
                            <Button type="submit" disabled={invite.processing}>
                                Send invitation
                            </Button>
                        </DialogFooter>
                    </form>
                </DialogContent>
            </Dialog>

            {/* Reset 2FA dialog (reason required + logged) */}
            <Dialog
                open={resetUser !== null}
                onOpenChange={(o) => !o && setResetUser(null)}
            >
                <DialogContent>
                    <form onSubmit={submitReset}>
                        <DialogHeader>
                            <DialogTitle>
                                Reset two-factor for {resetUser?.name}
                            </DialogTitle>
                            <DialogDescription>
                                Provide a reason — this action is recorded in
                                the security log.
                            </DialogDescription>
                        </DialogHeader>
                        <div className="grid gap-2 py-4">
                            <Label htmlFor="reset-reason">Reason</Label>
                            <Input
                                id="reset-reason"
                                value={reset.data.reason}
                                onChange={(e) =>
                                    reset.setData('reason', e.target.value)
                                }
                                required
                            />
                            <InputError message={reset.errors.reason} />
                        </div>
                        <DialogFooter>
                            <ConfirmDialog
                                title="Reset two-factor authentication?"
                                description="The user will need to set up 2FA again on next login."
                                confirmLabel="Reset 2FA"
                                onConfirm={() =>
                                    submitReset({
                                        preventDefault: () => {},
                                    } as React.FormEvent)
                                }
                                trigger={
                                    <Button
                                        type="button"
                                        variant="destructive"
                                        disabled={
                                            reset.processing ||
                                            reset.data.reason.length < 5
                                        }
                                    >
                                        Reset 2FA
                                    </Button>
                                }
                            />
                        </DialogFooter>
                    </form>
                </DialogContent>
            </Dialog>
        </>
    );
}
