import { Head, router, setLayoutProps, usePage } from '@inertiajs/react';
import {
    KeyRound,
    MoreHorizontal,
    Network,
    Search,
    ShieldCheck,
    UserCog,
    UserPlus,
    UserRoundCheck,
    UserRoundX,
} from 'lucide-react';
import { useEffect, useRef, useState } from 'react';

import {
    index as adminUsersIndex,
    resetPasswordRequirement,
    toggleActivation,
} from '@/actions/App/Domains/Shared/Http/Controllers/Admin/UserController';

import { UserCreateDialog } from '@/components/admin/UserCreateDialog';
import { UserMembershipsDialog } from '@/components/admin/UserMembershipsDialog';
import { UserPasswordDialog } from '@/components/admin/UserPasswordDialog';
import { UserProfileDialog } from '@/components/admin/UserProfileDialog';
import { ConfirmActionDialog } from '@/components/ConfirmActionDialog';
import { DataPagination } from '@/components/DataPagination';
import { Badge } from '@/components/ui/badge';
import { Button } from '@/components/ui/button';
import {
    DropdownMenu,
    DropdownMenuContent,
    DropdownMenuItem,
    DropdownMenuSeparator,
    DropdownMenuTrigger,
} from '@/components/ui/dropdown-menu';
import { Input } from '@/components/ui/input';
import {
    Select,
    SelectContent,
    SelectItem,
    SelectTrigger,
    SelectValue,
} from '@/components/ui/select';
import {
    Table,
    TableBody,
    TableCell,
    TableHead,
    TableHeader,
    TableRow,
} from '@/components/ui/table';
import type { AdminUser, DivisionOption } from '@/types/admin';
import type { PaginationData } from '@/types/pagination';

const FILTER_DEBOUNCE_MS = 300;

const ALL = 'all';

interface AdminUsersPageProps {
    users: AdminUser[];
    pagination: PaginationData;
    filters: {
        search: string;
        status: string;
    };
    divisions: DivisionOption[];
    divisionRoleOptions: string[];
}

export default function AdminUsersIndex({
    users,
    pagination,
    filters,
    divisions,
    divisionRoleOptions,
}: AdminUsersPageProps) {
    const currentUserId = usePage().props.auth.user.id;

    const [searchQuery, setSearchQuery] = useState(filters.search);
    const [statusFilter, setStatusFilter] = useState(filters.status);

    const [creatingUser, setCreatingUser] = useState(false);
    const [editingUser, setEditingUser] = useState<AdminUser | null>(null);
    const [passwordUser, setPasswordUser] = useState<AdminUser | null>(null);
    const [membershipsUser, setMembershipsUser] = useState<AdminUser | null>(
        null,
    );
    const [activationUser, setActivationUser] = useState<AdminUser | null>(
        null,
    );
    const [requirementUser, setRequirementUser] = useState<AdminUser | null>(
        null,
    );
    const [processingAction, setProcessingAction] = useState(false);

    const isInitialFilterSync = useRef(true);

    useEffect(() => {
        if (isInitialFilterSync.current) {
            isInitialFilterSync.current = false;

            return;
        }

        const request = window.setTimeout(() => {
            router.get(
                adminUsersIndex().url,
                {
                    search: searchQuery || undefined,
                    status: statusFilter !== ALL ? statusFilter : undefined,
                },
                { preserveScroll: true, preserveState: true, replace: true },
            );
        }, FILTER_DEBOUNCE_MS);

        return () => window.clearTimeout(request);
    }, [searchQuery, statusFilter]);

    setLayoutProps({
        breadcrumbs: [{ title: 'User Management' }],
    });

    /** Aksi satu-klik (aktivasi & reset password requirement) lewat konfirmasi. */
    const submitAction = (url: string, onDone: () => void) => {
        setProcessingAction(true);

        router.patch(
            url,
            {},
            {
                preserveScroll: true,
                onFinish: () => {
                    setProcessingAction(false);
                    onDone();
                },
            },
        );
    };

    return (
        <>
            <Head title="User Management" />

            <div className="flex min-h-full flex-col gap-4 p-4 md:p-6">
                <div className="flex flex-col gap-2 sm:flex-row sm:items-center sm:justify-between">
                    <div>
                        <h1 className="text-xl font-bold tracking-tight text-foreground">
                            User Management
                        </h1>
                        <p className="text-sm text-muted-foreground">
                            {pagination.total} user
                            {pagination.total === 1 ? '' : 's'} registered
                        </p>
                    </div>

                    <div className="flex flex-col gap-2 sm:flex-row">
                        <div className="relative w-full sm:w-72">
                            <Search
                                className="absolute top-1/2 left-3 h-4 w-4 -translate-y-1/2 text-muted-foreground"
                                size={16}
                            />
                            <Input
                                placeholder="Search name, NIK, or email..."
                                className="h-9 rounded-lg bg-background pl-9"
                                value={searchQuery}
                                onChange={(e) => setSearchQuery(e.target.value)}
                            />
                        </div>

                        <Select
                            value={statusFilter}
                            onValueChange={setStatusFilter}
                        >
                            <SelectTrigger className="h-9 w-full sm:w-36">
                                <SelectValue />
                            </SelectTrigger>
                            <SelectContent>
                                <SelectItem value={ALL}>All status</SelectItem>
                                <SelectItem value="active">Active</SelectItem>
                                <SelectItem value="inactive">
                                    Inactive
                                </SelectItem>
                            </SelectContent>
                        </Select>

                        <Button
                            className="h-9"
                            onClick={() => setCreatingUser(true)}
                        >
                            <UserPlus className="mr-1 h-4 w-4" />
                            Add User
                        </Button>
                    </div>
                </div>

                <div className="overflow-x-auto rounded-lg border bg-background">
                    <Table>
                        <TableHeader>
                            <TableRow className="hover:bg-transparent">
                                <TableHead className="w-12 text-center">
                                    NO.
                                </TableHead>
                                <TableHead>User</TableHead>
                                <TableHead>System Role</TableHead>
                                <TableHead>Divisions</TableHead>
                                <TableHead>Status</TableHead>
                                <TableHead className="w-12" />
                            </TableRow>
                        </TableHeader>
                        <TableBody>
                            {users.length === 0 && (
                                <TableRow>
                                    <TableCell
                                        colSpan={6}
                                        className="py-10 text-center text-sm text-muted-foreground"
                                    >
                                        No user matches the current filter.
                                    </TableCell>
                                </TableRow>
                            )}

                            {users.map((user, index) => (
                                <TableRow key={user.id}>
                                    <TableCell className="text-center text-muted-foreground">
                                        {(pagination.from ?? 0) + index}
                                    </TableCell>

                                    <TableCell>
                                        <div className="font-medium text-foreground">
                                            {user.name}
                                            {user.id === currentUserId && (
                                                <span className="ml-2 text-xs font-normal text-muted-foreground">
                                                    (you)
                                                </span>
                                            )}
                                        </div>
                                        <div className="text-xs text-muted-foreground">
                                            {user.nik ?? 'No NIK'} ·{' '}
                                            {user.email}
                                        </div>
                                    </TableCell>

                                    <TableCell>
                                        <Badge
                                            variant={
                                                user.role === 'super_admin'
                                                    ? 'default'
                                                    : 'secondary'
                                            }
                                        >
                                            {user.role === 'super_admin' && (
                                                <ShieldCheck className="mr-1 h-3 w-3" />
                                            )}
                                            {user.role_label}
                                        </Badge>
                                    </TableCell>

                                    <TableCell>
                                        <div className="flex flex-wrap gap-1">
                                            {user.memberships.length === 0 ? (
                                                <span className="text-xs text-muted-foreground">
                                                    —
                                                </span>
                                            ) : (
                                                user.memberships.map(
                                                    (membership) => (
                                                        <Badge
                                                            key={
                                                                membership.division_id
                                                            }
                                                            variant="outline"
                                                            className="font-normal"
                                                        >
                                                            {
                                                                membership.division_name
                                                            }
                                                            <span className="ml-1 text-muted-foreground capitalize">
                                                                {
                                                                    membership.role_type
                                                                }
                                                            </span>
                                                        </Badge>
                                                    ),
                                                )
                                            )}
                                        </div>
                                    </TableCell>

                                    <TableCell>
                                        <div className="flex flex-col gap-1">
                                            <Badge
                                                variant={
                                                    user.is_active
                                                        ? 'outline'
                                                        : 'destructive'
                                                }
                                                className="w-fit"
                                            >
                                                {user.is_active
                                                    ? 'Active'
                                                    : 'Inactive'}
                                            </Badge>
                                            {user.must_change_password && (
                                                <span className="text-xs text-muted-foreground">
                                                    Must change password
                                                </span>
                                            )}
                                        </div>
                                    </TableCell>

                                    <TableCell>
                                        <DropdownMenu>
                                            <DropdownMenuTrigger asChild>
                                                <Button
                                                    variant="ghost"
                                                    size="icon"
                                                    aria-label={`Actions for ${user.name}`}
                                                >
                                                    <MoreHorizontal className="h-4 w-4" />
                                                </Button>
                                            </DropdownMenuTrigger>
                                            <DropdownMenuContent align="end">
                                                <DropdownMenuItem
                                                    onSelect={() =>
                                                        setEditingUser(user)
                                                    }
                                                >
                                                    <UserCog className="mr-2 h-4 w-4" />
                                                    Edit user
                                                </DropdownMenuItem>
                                                <DropdownMenuItem
                                                    onSelect={() =>
                                                        setMembershipsUser(user)
                                                    }
                                                >
                                                    <Network className="mr-2 h-4 w-4" />
                                                    Division memberships
                                                </DropdownMenuItem>
                                                <DropdownMenuItem
                                                    onSelect={() =>
                                                        setPasswordUser(user)
                                                    }
                                                >
                                                    <KeyRound className="mr-2 h-4 w-4" />
                                                    Change password
                                                </DropdownMenuItem>
                                                <DropdownMenuSeparator />
                                                <DropdownMenuItem
                                                    disabled={
                                                        user.must_change_password
                                                    }
                                                    onSelect={() =>
                                                        setRequirementUser(user)
                                                    }
                                                >
                                                    <KeyRound className="mr-2 h-4 w-4" />
                                                    Require password change
                                                </DropdownMenuItem>
                                                <DropdownMenuItem
                                                    disabled={
                                                        user.id ===
                                                        currentUserId
                                                    }
                                                    onSelect={() =>
                                                        setActivationUser(user)
                                                    }
                                                >
                                                    {user.is_active ? (
                                                        <>
                                                            <UserRoundX className="mr-2 h-4 w-4" />
                                                            Deactivate
                                                        </>
                                                    ) : (
                                                        <>
                                                            <UserRoundCheck className="mr-2 h-4 w-4" />
                                                            Activate
                                                        </>
                                                    )}
                                                </DropdownMenuItem>
                                            </DropdownMenuContent>
                                        </DropdownMenu>
                                    </TableCell>
                                </TableRow>
                            ))}
                        </TableBody>
                    </Table>
                </div>

                <DataPagination
                    pagination={pagination}
                    only={['users', 'pagination']}
                />
            </div>

            <UserCreateDialog
                divisions={divisions}
                divisionRoleOptions={divisionRoleOptions}
                open={creatingUser}
                onOpenChange={setCreatingUser}
            />

            <UserProfileDialog
                user={editingUser}
                open={editingUser !== null}
                onOpenChange={(open) => !open && setEditingUser(null)}
            />

            <UserPasswordDialog
                user={passwordUser}
                open={passwordUser !== null}
                onOpenChange={(open) => !open && setPasswordUser(null)}
            />

            <UserMembershipsDialog
                user={membershipsUser}
                divisions={divisions}
                divisionRoleOptions={divisionRoleOptions}
                open={membershipsUser !== null}
                onOpenChange={(open) => !open && setMembershipsUser(null)}
            />

            <ConfirmActionDialog
                open={activationUser !== null}
                onOpenChange={(open) => !open && setActivationUser(null)}
                onConfirm={() =>
                    activationUser &&
                    submitAction(
                        toggleActivation({ user: activationUser.id }).url,
                        () => setActivationUser(null),
                    )
                }
                processing={processingAction}
                title={
                    activationUser?.is_active
                        ? 'Deactivate this user?'
                        : 'Activate this user?'
                }
                description={
                    activationUser?.is_active ? (
                        <>
                            <span className="font-medium text-foreground">
                                {activationUser?.name}
                            </span>{' '}
                            will no longer be able to sign in. Their tasks and
                            memberships stay untouched.
                        </>
                    ) : (
                        <>
                            <span className="font-medium text-foreground">
                                {activationUser?.name}
                            </span>{' '}
                            will be able to sign in again.
                        </>
                    )
                }
                confirmLabel={
                    activationUser?.is_active ? 'Deactivate' : 'Activate'
                }
                cancelLabel="Cancel"
                tone={activationUser?.is_active ? 'danger' : 'neutral'}
                icon={activationUser?.is_active ? UserRoundX : UserRoundCheck}
            />

            <ConfirmActionDialog
                open={requirementUser !== null}
                onOpenChange={(open) => !open && setRequirementUser(null)}
                onConfirm={() =>
                    requirementUser &&
                    submitAction(
                        resetPasswordRequirement({ user: requirementUser.id })
                            .url,
                        () => setRequirementUser(null),
                    )
                }
                processing={processingAction}
                title="Require password change?"
                description={
                    <>
                        <span className="font-medium text-foreground">
                            {requirementUser?.name}
                        </span>{' '}
                        will be forced to set a new password on their next
                        login.
                    </>
                }
                confirmLabel="Require change"
                cancelLabel="Cancel"
                tone="warning"
                icon={KeyRound}
            />
        </>
    );
}
