import * as Common from "@/utils/common";

export const DEFAULT_PRINT_PREVIEW_FETCH_PAGE_SIZE = 100;

export const downloadBlobFile = (response, filename) => {
    const blob = new Blob([response.data], { type: response.headers["content-type"] });
    const url = window.URL.createObjectURL(blob);
    const link = document.createElement("a");
    link.href = url;
    link.setAttribute("download", filename);
    document.body.appendChild(link);
    link.click();
    link.remove();
    window.URL.revokeObjectURL(url);
};

export const buildDefaultReportMeta = title => {
    let user = null;
    try {
        const persistedUser = localStorage.getItem("user");
        user = persistedUser ? JSON.parse(persistedUser) : null;
    } catch (error) {
        console.warn("Failed to parse persisted user", error);
    }

    const tenant = user?.tenant || {};
    const now = new Date();
    const year = now.getFullYear();
    const month = `${now.getMonth() + 1}`.padStart(2, "0");
    const day = `${now.getDate()}`.padStart(2, "0");

    return {
        companyName:
            tenant?.name ||
            tenant?.tenantName ||
            tenant?.label ||
            user?.fullName ||
            "RSF",
        printedBy: user?.fullName || user?.username || "系统用户",
        reportDate: `${year}年${month}月${day}日`,
        reportDateValue: `${year}-${month}-${day}`,
        title,
    };
};

export const buildListReportRequestPayload = ({
    filter,
    filterValues,
    sort,
    ids,
    columns,
    reportMeta,
    extraPayload = {},
}) => ({
    ...Common.integrateParams({
        sort,
        filter: filter ? { ...filterValues, ...filter } : filterValues,
    }),
    ids: ids?.length ? ids : undefined,
    columns,
    reportMeta,
    ...extraPayload,
});

const getColumnToken = column => column?.key || column?.source;

const resolveColumnByToken = (columnDefs, token) => {
    if (typeof token === "number" || /^\d+$/.test(String(token))) {
        return columnDefs[Number(token)];
    }

    if (typeof token === "string") {
        return columnDefs.find(column => column.key === token || column.source === token);
    }

    if (token && typeof token === "object") {
        if ("index" in token) {
            return columnDefs[Number(token.index)];
        }
        if ("source" in token) {
            return columnDefs.find(column => column.source === token.source);
        }
        if ("key" in token) {
            return columnDefs.find(column => column.key === token.key);
        }
        if ("id" in token) {
            return columnDefs.find(column => column.key === token.id || column.source === token.id);
        }
    }

    return undefined;
};

const buildDefaultVisibleColumns = (columnDefs, omitSet) =>
    columnDefs.filter(column => !omitSet.has(column.source) && !omitSet.has(column.key));

export const resolveVisibleColumns = ({
    columnDefs = [],
    storedColumns = [],
    availableColumns = [],
    storedOmit = [],
    omit = [],
}) => {
    if (!Array.isArray(columnDefs) || columnDefs.length === 0) {
        return [];
    }

    const omitSet = new Set([...(omit || []), ...(storedOmit || [])]);
    const fallbackColumns = buildDefaultVisibleColumns(columnDefs, omitSet);
    const storedOrder = Array.isArray(storedColumns) && storedColumns.length > 0
        ? storedColumns
        : Array.isArray(availableColumns) && availableColumns.length > 0
            ? availableColumns
            : [];

    const resolvedColumns = storedOrder
        .map(token => resolveColumnByToken(columnDefs, token))
        .filter(Boolean)
        .filter(column => !omitSet.has(column.source) && !omitSet.has(column.key));

    const visibleColumns = resolvedColumns.length > 0 ? resolvedColumns : fallbackColumns;

    return visibleColumns.map(column => ({
        key: column.key,
        source: column.source,
        label: column.label,
        isExtendField: Boolean(column.isExtendField),
    }));
};

const getNestedValue = (record, source) =>
    source.split(".").reduce((accumulator, segment) => {
        if (accumulator == null) {
            return undefined;
        }
        return accumulator[segment];
    }, record);

export const getListReportCellValue = (record, source) => {
    if (!record || !source) {
        return "";
    }

    const extendFieldMatch = source.match(/^extendFields\.\[(.+)\]$/);
    if (extendFieldMatch) {
        return record?.extendFields?.[extendFieldMatch[1]] ?? "";
    }

    if (Object.prototype.hasOwnProperty.call(record, source)) {
        return record[source] ?? "";
    }

    const value = source.includes(".") ? getNestedValue(record, source) : record[source];
    return value ?? "";
};

export const resolveReportMeta = (reportConfig, params) => {
    if (typeof reportConfig?.buildReportMeta === "function") {
        return reportConfig.buildReportMeta(params);
    }
    return reportConfig?.reportMeta || null;
};