import { useMemo } from 'react';
import { TableActiveFilters, type TableActiveFilterItem } from '@/components/common/TableActiveFilters';
import type {
    DocumentAccountantStatus,
    DocumentAiStatus,
    DocumentsFilters,
    ExtractionStatus,
} from '@/features/documents/types';
import { useI18n } from '@/hooks/use-i18n';

type Option = { id: number; name: string };

type DocumentsActiveFiltersProps = {
    search: string;
    filters: Required<DocumentsFilters>;
    clientOptions: Option[];
    uploaderOptions: Option[];
    onClearAll: () => void;
    onRemoveSearch: () => void;
    onRemoveClient: () => void;
    onRemoveUploader: () => void;
    onRemoveAccountantStatus: () => void;
    onRemoveAiStatus: () => void;
    onRemoveExtractionStatus: () => void;
    onRemoveUploadedFrom: () => void;
    onRemoveUploadedTo: () => void;
    onRemoveClientMismatch?: () => void;
    /** Hide AI / extraction chips (e.g. client portal). */
    hidePipelineFilters?: boolean;
};

const accountantStatuses: DocumentAccountantStatus[] = [
    'waiting',
    'in_review',
    'needs_info',
    'error',
    'validated',
    'rejected',
];

const aiStatuses: DocumentAiStatus[] = ['not_processed', 'processing', 'processed', 'failed'];

const extractionStatuses: ExtractionStatus[] = ['pending', 'processing', 'success', 'failed'];

export function DocumentsActiveFilters({
    search,
    filters,
    clientOptions,
    uploaderOptions,
    onClearAll,
    onRemoveSearch,
    onRemoveClient,
    onRemoveUploader,
    onRemoveAccountantStatus,
    onRemoveAiStatus,
    onRemoveExtractionStatus,
    onRemoveUploadedFrom,
    onRemoveUploadedTo,
    onRemoveClientMismatch,
    hidePipelineFilters = false,
}: DocumentsActiveFiltersProps) {
    const { t } = useI18n();

    const accountantStatusLabels = useMemo(
        () =>
            accountantStatuses.reduce(
                (acc, status) => {
                    acc[status] = t(`documents.admin_index.status.accountant.${status}`);

                    return acc;
                },
                {} as Record<DocumentAccountantStatus, string>,
            ),
        [t],
    );

    const aiStatusLabels = useMemo(
        () =>
            aiStatuses.reduce(
                (acc, status) => {
                    acc[status] = t(`documents.admin_index.status.ai.${status}`);

                    return acc;
                },
                {} as Record<DocumentAiStatus, string>,
            ),
        [t],
    );

    const extractionStatusLabels = useMemo(
        () =>
            extractionStatuses.reduce(
                (acc, status) => {
                    acc[status] = t(`documents.admin_index.status.extraction.${status}`);

                    return acc;
                },
                {} as Record<ExtractionStatus, string>,
            ),
        [t],
    );

    const clientLabel = clientOptions.find((client) => client.id === filters.client_id)?.name ?? '-';
    const uploaderLabel =
        uploaderOptions.find((uploader) => uploader.id === filters.uploaded_by_user_id)?.name ?? '-';

    const items = useMemo(() => {
        const chips: TableActiveFilterItem[] = [];

        if (search !== '') {
            chips.push({
                key: 'search',
                label: `${t('documents.admin_index.active_filters.search_prefix')} ${search}`,
                onRemove: onRemoveSearch,
            });
        }

        if (filters.client_id) {
            chips.push({
                key: 'client',
                label: `${t('documents.admin_index.active_filters.client_prefix')} ${clientLabel}`,
                onRemove: onRemoveClient,
            });
        }

        if (filters.uploaded_by_user_id) {
            chips.push({
                key: 'uploader',
                label: `${t('documents.admin_index.active_filters.uploader_prefix')} ${uploaderLabel}`,
                onRemove: onRemoveUploader,
            });
        }

        if (filters.accountant_status) {
            chips.push({
                key: 'accountant',
                label: `${t('documents.admin_index.active_filters.accountant_prefix')} ${accountantStatusLabels[filters.accountant_status]}`,
                onRemove: onRemoveAccountantStatus,
            });
        }

        if (! hidePipelineFilters && filters.ai_status) {
            chips.push({
                key: 'ai',
                label: `${t('documents.admin_index.active_filters.ai_prefix')} ${aiStatusLabels[filters.ai_status]}`,
                onRemove: onRemoveAiStatus,
            });
        }

        if (! hidePipelineFilters && filters.extraction_status) {
            chips.push({
                key: 'extraction',
                label: `${t('documents.admin_index.active_filters.extraction_prefix')} ${extractionStatusLabels[filters.extraction_status]}`,
                onRemove: onRemoveExtractionStatus,
            });
        }

        if (filters.uploaded_from) {
            chips.push({
                key: 'uploaded_from',
                label: `${t('documents.admin_index.active_filters.from_prefix')} ${filters.uploaded_from}`,
                onRemove: onRemoveUploadedFrom,
            });
        }

        if (filters.uploaded_to) {
            chips.push({
                key: 'uploaded_to',
                label: `${t('documents.admin_index.active_filters.to_prefix')} ${filters.uploaded_to}`,
                onRemove: onRemoveUploadedTo,
            });
        }

        if (filters.client_mismatch === true && onRemoveClientMismatch) {
            chips.push({
                key: 'client_mismatch',
                label: 'Mismatch client',
                onRemove: onRemoveClientMismatch,
            });
        }

        return chips;
    }, [
        accountantStatusLabels,
        aiStatusLabels,
        clientLabel,
        extractionStatusLabels,
        filters.accountant_status,
        filters.ai_status,
        filters.client_id,
        filters.client_mismatch,
        filters.extraction_status,
        filters.uploaded_by_user_id,
        filters.uploaded_from,
        filters.uploaded_to,
        hidePipelineFilters,
        onRemoveAccountantStatus,
        onRemoveAiStatus,
        onRemoveClient,
        onRemoveClientMismatch,
        onRemoveExtractionStatus,
        onRemoveSearch,
        onRemoveUploadedFrom,
        onRemoveUploadedTo,
        onRemoveUploader,
        search,
        t,
        uploaderLabel,
    ]);

    return (
        <TableActiveFilters
            heading={t('documents.admin_index.active_filters.heading')}
            clearAllLabel={t('documents.admin_index.active_filters.clear_all')}
            items={items}
            onClearAll={onClearAll}
        />
    );
}