import { useCallback, useMemo, useRef, useState } from "react";
import { useListContext, useStore } from "react-admin";
import request from "@/utils/request";
import {
    DEFAULT_PRINT_PREVIEW_FETCH_PAGE_SIZE,
    downloadBlobFile,
    resolveReportMeta,
    resolveVisibleColumns,
} from "./listReportUtils";

const getPreferencePath = (preferenceKey, field) =>
    `preferences.${preferenceKey || "__listReport__"}.${field}`;

export const useListReportActionParams = (reportConfig, options = {}) => {
    const { ids: explicitIds } = options;
    const { filter, filterValues, resource, selectedIds, sort, total } = useListContext();
    const [storedColumns] = useStore(
        getPreferencePath(reportConfig?.preferenceKey, "columns"),
        []
    );
    const [availableColumns] = useStore(
        getPreferencePath(reportConfig?.preferenceKey, "availableColumns"),
        []
    );
    const [storedOmit] = useStore(
        getPreferencePath(reportConfig?.preferenceKey, "omit"),
        []
    );

    const visibleColumns = useMemo(
        () =>
            resolveVisibleColumns({
                columnDefs: reportConfig?.columns,
                storedColumns,
                availableColumns,
                storedOmit,
                omit: reportConfig?.omit,
            }),
        [availableColumns, reportConfig?.columns, reportConfig?.omit, storedColumns, storedOmit]
    );

    return {
        visibleColumns,
        params: {
            filter,
            filterValues,
            ids: explicitIds ?? selectedIds,
            resource: reportConfig?.resource || resource,
            sort,
            total,
        },
    };
};

export const useListReportOutput = ({
    reportConfig,
    buildRequestPayload,
    notify,
}) => {
    const [exportLoading, setExportLoading] = useState(false);
    const [previewOpen, setPreviewOpen] = useState(false);
    const [previewRows, setPreviewRows] = useState([]);
    const [previewColumns, setPreviewColumns] = useState([]);
    const [previewMeta, setPreviewMeta] = useState(null);
    const [previewDataset, setPreviewDataset] = useState({
        loadedPages: 0,
        transportPages: 0,
        pageSize: reportConfig?.previewPageSize || DEFAULT_PRINT_PREVIEW_FETCH_PAGE_SIZE,
        total: 0,
        fullyLoaded: false,
    });
    const [previewLoading, setPreviewLoading] = useState(false);
    const [previewPrefetching, setPreviewPrefetching] = useState(false);
    const requestIdRef = useRef(0);
    const cacheRef = useRef(new Map());

    const previewPageSize = reportConfig?.previewPageSize || DEFAULT_PRINT_PREVIEW_FETCH_PAGE_SIZE;

    const buildPayload = useCallback(
        params => {
            const payload = typeof buildRequestPayload === "function"
                ? buildRequestPayload(params)
                : {};
            if (payload.reportMeta) {
                return payload;
            }
            return {
                ...payload,
                reportMeta: resolveReportMeta(reportConfig, params),
            };
        },
        [buildRequestPayload, reportConfig]
    );

    const resetPreviewCache = useCallback(() => {
        cacheRef.current = new Map();
        setPreviewRows([]);
        setPreviewColumns([]);
        setPreviewMeta(null);
        setPreviewDataset({
            loadedPages: 0,
            transportPages: 0,
            pageSize: previewPageSize,
            total: 0,
            fullyLoaded: false,
        });
    }, [previewPageSize]);

    const fetchPreviewPage = useCallback(
        async ({ payload, current }) => {
            const { data: { code, data, msg } } = await request.post(
                `/${reportConfig.resource}/print/query`,
                {
                    ...payload,
                    current,
                    pageSize: previewPageSize,
                }
            );

            if (code !== 200) {
                throw new Error(msg || "Print preview query failed");
            }

            return data || {};
        },
        [previewPageSize, reportConfig.resource]
    );

    const syncPreviewCache = useCallback(
        ({ totalPages, totalRows }) => {
            const nextRows = [];
            for (let pageIndex = 1; pageIndex <= totalPages; pageIndex += 1) {
                const pageRows = cacheRef.current.get(pageIndex);
                if (Array.isArray(pageRows)) {
                    nextRows.push(...pageRows);
                }
            }

            setPreviewRows(nextRows);
            setPreviewDataset({
                loadedPages: cacheRef.current.size,
                transportPages: totalPages,
                pageSize: previewPageSize,
                total: totalRows,
                fullyLoaded: cacheRef.current.size >= totalPages,
            });
        },
        [previewPageSize]
    );

    const applyPreviewPage = useCallback(
        ({ data, payload, openPreview = false }) => {
            const current = Number(data.current) || 1;
            const totalPages = Number(data.pages) || 0;
            const totalRows = Number(data.total) || 0;

            setPreviewColumns(payload.columns || []);
            setPreviewMeta(payload.reportMeta || null);
            cacheRef.current.set(current, Array.isArray(data.records) ? data.records : []);
            syncPreviewCache({ totalPages, totalRows });

            if (openPreview) {
                setPreviewOpen(true);
            }
        },
        [syncPreviewCache]
    );

    const prefetchPreviewPages = useCallback(
        async ({ payload, totalPages, totalRows, requestId }) => {
            if (totalPages <= 1) {
                setPreviewPrefetching(false);
                return;
            }

            setPreviewPrefetching(true);
            const pendingPages = Array.from({ length: totalPages - 1 }, (_, index) => index + 2);
            const workerCount = Math.min(3, pendingPages.length);
            let hasErrored = false;

            const worker = async () => {
                while (pendingPages.length > 0 && requestIdRef.current === requestId) {
                    const nextPage = pendingPages.shift();
                    if (!nextPage) {
                        return;
                    }

                    try {
                        const data = await fetchPreviewPage({ payload, current: nextPage });
                        if (requestIdRef.current !== requestId) {
                            return;
                        }
                        cacheRef.current.set(nextPage, Array.isArray(data.records) ? data.records : []);
                        syncPreviewCache({ totalPages, totalRows });
                    } catch (error) {
                        if (!hasErrored && requestIdRef.current === requestId) {
                            hasErrored = true;
                            console.error(error);
                            notify(error.message || "ra.notification.http_error", { type: "error" });
                        }
                        return;
                    }
                }
            };

            await Promise.all(Array.from({ length: workerCount }, () => worker()));
            if (requestIdRef.current === requestId) {
                setPreviewPrefetching(false);
            }
        },
        [fetchPreviewPage, notify, syncPreviewCache]
    );

    const openPrintPreview = useCallback(
        async params => {
            if (!reportConfig?.enablePrint) {
                return;
            }
            setPreviewLoading(true);
            try {
                requestIdRef.current += 1;
                const requestId = requestIdRef.current;
                resetPreviewCache();
                const payload = buildPayload(params);
                const data = await fetchPreviewPage({ payload, current: 1 });
                applyPreviewPage({ data, payload, openPreview: true });
                prefetchPreviewPages({
                    payload,
                    totalPages: Number(data.pages) || 0,
                    totalRows: Number(data.total) || 0,
                    requestId,
                });
            } catch (error) {
                console.error(error);
                notify(error.message || "ra.notification.http_error", { type: "error" });
            } finally {
                setPreviewLoading(false);
            }
        },
        [
            applyPreviewPage,
            buildPayload,
            fetchPreviewPage,
            notify,
            prefetchPreviewPages,
            reportConfig?.enablePrint,
            resetPreviewCache,
        ]
    );

    const closePrintPreview = useCallback(() => {
        requestIdRef.current += 1;
        setPreviewPrefetching(false);
        setPreviewOpen(false);
    }, []);

    const exportReport = useCallback(
        async params => {
            setExportLoading(true);
            try {
                const payload = buildPayload(params);
                const response = await request.post(`/${reportConfig.resource}/export`, payload, {
                    responseType: "blob",
                });
                downloadBlobFile(
                    response,
                    reportConfig.exportFileName || `${reportConfig.resource}.xlsx`
                );
            } catch (error) {
                console.error(error);
                notify("ra.notification.http_error", { type: "error" });
            } finally {
                setExportLoading(false);
            }
        },
        [buildPayload, notify, reportConfig.exportFileName, reportConfig.resource]
    );

    return {
        exportLoading,
        previewOpen,
        previewRows,
        previewColumns,
        previewMeta,
        previewDataset,
        previewLoading,
        previewPrefetching,
        openPrintPreview,
        closePrintPreview,
        exportReport,
    };
};