import { router } from '@inertiajs/react';
import type { ColumnDef } from '@tanstack/react-table';
import { useMemo, useState } from 'react';
import { IconButton } from '@/components/common/IconButton';
import {
    AlertDialog,
    AlertDialogAction,
    AlertDialogBody,
    AlertDialogCancel,
    AlertDialogContent,
    AlertDialogDescription,
    AlertDialogFooter,
    AlertDialogHeader,
    AlertDialogTitle,
    AlertDialogTrigger,
} from '@/components/ui/alert-dialog';
import { Badge } from '@/components/ui/badge';
import { tableRowIconButtonClass } from '@/lib/icon-button-classes';
import { SortableColumnHeader } from '@/components/ui/sortable-column-header';
import type {
    AccountingDocumentTypeListItem,
    AccountingDocumentTypesSortColumn,
} from '@/features/accounting-document-types/types';
import { useI18n } from '@/hooks/use-i18n';

type SortHandler = (column: AccountingDocumentTypesSortColumn) => void;

function AccountingDocumentTypeRowActions({
    row,
    canManage,
    onEdit,
}: {
    row: AccountingDocumentTypeListItem;
    canManage: boolean;
    onEdit: (id: number) => void;
}) {
    const { t } = useI18n();
    const [busy, setBusy] = useState(false);

    const destroy = () => {
        setBusy(true);
        router.delete(`/settings/accounting-document-types/${row.id}`, {
            preserveScroll: true,
            onFinish: () => setBusy(false),
        });
    };

    if (!canManage) {
        return null;
    }

    return (
        <div className="flex justify-end gap-1">
            <IconButton
                type="button"
                variant="text"
                color="ghost"
                size="sm"
                className={tableRowIconButtonClass}
                aria-label={t('settings.accounting_document_types.row_actions.edit')}
                disabled={busy}
                onClick={() => onEdit(row.id)}
                icon="solar:pen-bold-duotone"
            />

            {!row.is_system ? (
                <AlertDialog>
                    <AlertDialogTrigger asChild>
                        <IconButton
                            type="button"
                            variant="text"
                            color="danger"
                            size="sm"
                            className={tableRowIconButtonClass}
                            aria-label={t('settings.accounting_document_types.row_actions.delete')}
                            disabled={busy}
                            icon="solar:trash-bin-minimalistic-bold-duotone"
                        />
                    </AlertDialogTrigger>
                    <AlertDialogContent>
                        <AlertDialogHeader>
                            <AlertDialogTitle>
                                {t('settings.accounting_document_types.row_actions.delete_confirm_title')}
                            </AlertDialogTitle>
                        </AlertDialogHeader>
                        <AlertDialogBody>
                            <AlertDialogDescription>
                                {t('settings.accounting_document_types.row_actions.delete_confirm_message', {
                                    name: row.name,
                                })}
                            </AlertDialogDescription>
                        </AlertDialogBody>
                        <AlertDialogFooter>
                            <AlertDialogCancel>
                                {t('settings.accounting_document_types.row_actions.delete_confirm_cancel')}
                            </AlertDialogCancel>
                            <AlertDialogAction
                                className="bg-destructive text-destructive-foreground hover:bg-destructive/90"
                                onClick={destroy}
                            >
                                {t('settings.accounting_document_types.row_actions.delete_confirm_submit')}
                            </AlertDialogAction>
                        </AlertDialogFooter>
                    </AlertDialogContent>
                </AlertDialog>
            ) : null}
        </div>
    );
}

function buildAccountingDocumentTypesColumns(
    t: (key: string, replacements?: Record<string, string | number>) => string,
    onSort: SortHandler,
    canManage: boolean,
    onEdit: (id: number) => void,
): ColumnDef<AccountingDocumentTypeListItem>[] {
    return [
        {
            accessorKey: 'sort_order',
            header: () => (
                <SortableColumnHeader
                    label={t('settings.accounting_document_types.table.columns.sort_order')}
                    onSort={() => onSort('sort_order')}
                />
            ),
            cell: ({ row }) => <span className="font-mono text-sm tabular-nums">{row.original.sort_order}</span>,
        },
        {
            accessorKey: 'code',
            header: () => (
                <SortableColumnHeader
                    label={t('settings.accounting_document_types.table.columns.code')}
                    onSort={() => onSort('code')}
                />
            ),
            cell: ({ row }) => <span className="font-mono text-xs font-medium">{row.original.code}</span>,
        },
        {
            accessorKey: 'name',
            header: () => (
                <SortableColumnHeader
                    label={t('settings.accounting_document_types.table.columns.name')}
                    onSort={() => onSort('name')}
                />
            ),
            cell: ({ row }) => (
                <div className="flex max-w-xs items-center gap-2">
                    <span className="truncate font-medium" title={row.original.name}>
                        {row.original.name}
                    </span>
                    {row.original.is_system ? (
                        <Badge variant="secondary" className="shrink-0 text-[10px] uppercase">
                            {t('settings.accounting_document_types.table.system_badge')}
                        </Badge>
                    ) : null}
                </div>
            ),
        },
        {
            accessorKey: 'is_active',
            header: () => (
                <SortableColumnHeader
                    label={t('settings.accounting_document_types.table.columns.status')}
                    onSort={() => onSort('is_active')}
                />
            ),
            cell: ({ row }) =>
                row.original.is_active ? (
                    <Badge variant="successSoft">{t('settings.accounting_document_types.table.status_active')}</Badge>
                ) : (
                    <Badge variant="secondary">{t('settings.accounting_document_types.table.status_inactive')}</Badge>
                ),
        },
        {
            id: 'actions',
            header: () => (
                <span className="sr-only">{t('settings.accounting_document_types.table.columns.actions')}</span>
            ),
            cell: ({ row }) => (
                <AccountingDocumentTypeRowActions row={row.original} canManage={canManage} onEdit={onEdit} />
            ),
        },
    ];
}

export function useAccountingDocumentTypesColumns(
    onSort: SortHandler,
    canManage: boolean,
    onEdit: (id: number) => void,
) {
    const { t } = useI18n();

    return useMemo(
        () => buildAccountingDocumentTypesColumns(t, onSort, canManage, onEdit),
        [t, onSort, canManage, onEdit],
    );
}