import { QueryKeys } from "@/enums/QueryKeys";
import {
    getStockTransfers,
    getStockTransferSourceWarehouses,
    getStockTransferLotOptions,
    getStockTransferUnits,
    getStockTransferById,
    type StockTransferLotOption,
    type StockTransferSourceWarehouse,
    type StockTransferUnitOption,
    type StockTransferDetail,
} from "@/utils/apiFunctions/stockTransferApiFunction";
import { keepPreviousData, useQuery } from "@tanstack/react-query";

export type StockTransfer = StockTransferDetail;

type Pagination = {
    total: number;
    per_page: number;
    current_page: number;
    last_page: number;
    from: number | null;
    to: number | null;
    offset: number;
};

type StockTransfersResponse = ResponseType & {
    data: StockTransfer[];
    pagination: Pagination;
};

type SourceWarehouseResponse = ResponseType & {
    data: StockTransferSourceWarehouse[];
};

type LotOptionsResponse = ResponseType & {
    data: StockTransferLotOption[];
};

type StockTransferUnitsResponse = ResponseType & {
    data: StockTransferUnitOption[];
};

type SingleStockTransferResponse = ResponseType & {
    data: StockTransferDetail;
};

export type StockTransfersPaginated = {
    data: StockTransfer[];
    pagination: Pagination;
};

export const useStockTransfersQuery = (
    keyword: string,
    status: "all" | "pending" | "confirmed" | "rejected",
    page: number,
    perPage: number,
) =>
    useQuery<StockTransfersPaginated, Error>({
        queryKey: [
            QueryKeys.stockTransfers.allStockTransfers,
            { keyword: keyword.trim(), status, page, perPage: Math.min(perPage, 50) },
        ],
        queryFn: async () => {
            const res: StockTransfersResponse = await getStockTransfers(
                keyword,
                status,
                page,
                Math.min(perPage, 50),
            );
            return {
                data: res.data,
                pagination: res.pagination,
            };
        },
        placeholderData: keepPreviousData,
        staleTime: 60 * 1000,
        refetchOnWindowFocus: false,
        refetchOnReconnect: false,
    });

export const useStockTransferSourceWarehousesQuery = (itemId?: number) =>
    useQuery<StockTransferSourceWarehouse[], Error>({
        queryKey: [QueryKeys.stockTransfers.sourceWarehouses, itemId],
        queryFn: async () => {
            const res: SourceWarehouseResponse = await getStockTransferSourceWarehouses(itemId as number, 20);
            return res.data;
        },
        enabled: !!itemId,
        staleTime: 5 * 60 * 1000,
        refetchOnWindowFocus: false,
        refetchOnReconnect: false,
    });

export const useStockTransferLotOptionsQuery = (itemId?: number, fromWarehouseId?: number) =>
    useQuery<StockTransferLotOption[], Error>({
        queryKey: [QueryKeys.stockTransfers.lotOptions, { itemId, fromWarehouseId }],
        queryFn: async () => {
            const res: LotOptionsResponse = await getStockTransferLotOptions(
                itemId as number,
                fromWarehouseId as number,
                20,
            );
            return res.data;
        },
        enabled: !!itemId && !!fromWarehouseId,
        staleTime: 2 * 60 * 1000,
        refetchOnWindowFocus: false,
        refetchOnReconnect: false,
    });

export const useStockTransferUnitsQuery = (itemId?: number) =>
    useQuery<StockTransferUnitOption[], Error>({
        queryKey: [QueryKeys.stockTransfers.relatedUnits, itemId],
        queryFn: async () => {
            const res: StockTransferUnitsResponse = await getStockTransferUnits(itemId as number);
            return res.data;
        },
        enabled: !!itemId,
        staleTime: 10 * 60 * 1000,
        refetchOnWindowFocus: false,
        refetchOnReconnect: false,
    });

export const useSingleStockTransferQuery = (stockTransferId?: number) =>
    useQuery<StockTransferDetail, Error>({
        queryKey: [QueryKeys.stockTransfers.singleStockTransfer, stockTransferId],
        queryFn: async () => {
            const res: SingleStockTransferResponse = await getStockTransferById(stockTransferId as number);
            return res.data;
        },
        enabled: !!stockTransferId,
        staleTime: 60 * 1000,
        refetchOnWindowFocus: false,
        refetchOnReconnect: false,
    });