import { QueryKeys } from "@/enums/QueryKeys";
import { useQuery } from "@tanstack/react-query";
import type { ResponseType } from "@/types/types";
import {
    getStoreInventories,
    getStoreInventoryItemOptions,
    getStoreInventoryLotOptions,
} from "@/utils/apiFunctions/storeInventoryApiFunction";
import type { Unit } from "./UnitsQuery";

type InventoryItem = {
    id: number;
    name: string;
    item_code: string;
};

type InventoryBranch = {
    id: number;
    lot_no: string;
    warehouse?: { id: number; name: string };
};

export type StoreInventory = {
    id: number;
    store_item_id: number;
    item_id: number;
    item_branch_id: number;
    unit_id: number;
    quantity: number;
    item: InventoryItem;
    item_branch: InventoryBranch;
    unit: Unit;
};

type ResponseStoreInventories = ResponseType & {
    data: StoreInventory[];
};

export type StoreInventoryItemOption = {
    id: number;
    name: string;
    item_code: string;
};

export type StoreInventoryLotOption = {
    id: number;
    item_id: number;
    item_branch_id: number;
    lot_no: string;
    quantity: number;
    unit: Unit;
    warehouse?: { id: number; name: string };
};

type ResponseStoreInventoryItemOptions = ResponseType & {
    data: StoreInventoryItemOption[];
};

type ResponseStoreInventoryLotOptions = ResponseType & {
    data: StoreInventoryLotOption[];
};

export const useStoreInventoriesQuery = (storeId?: number, keyword?: string) =>
    useQuery<StoreInventory[], Error>({
        queryKey: [QueryKeys.storeItems.allStoreItems, "inventories", { storeId, keyword }],
        enabled: typeof storeId === "number" && Number.isFinite(storeId),
        queryFn: async () => {
            const res: ResponseStoreInventories = await getStoreInventories(
                storeId as number,
                keyword,
            );
            return res.data;
        },
        staleTime: 5 * 60 * 1000,
        refetchOnWindowFocus: false,
        refetchOnReconnect: false,
    });

export const useStoreInventoryItemOptionsQuery = (
    storeId?: number,
    keyword?: string,
    limit: number = 30,
) =>
    useQuery<StoreInventoryItemOption[], Error>({
        queryKey: [QueryKeys.storeItems.allStoreItems, "inventory-item-options", { storeId, keyword, limit }],
        enabled: typeof storeId === "number" && Number.isFinite(storeId),
        queryFn: async () => {
            const res: ResponseStoreInventoryItemOptions = await getStoreInventoryItemOptions(
                storeId as number,
                keyword,
                limit,
            );
            return res.data;
        },
        staleTime: 2 * 60 * 1000,
        refetchOnWindowFocus: false,
        refetchOnReconnect: false,
    });

export const useStoreInventoryLotOptionsQuery = (storeId?: number, itemId?: number | null) =>
    useQuery<StoreInventoryLotOption[], Error>({
        queryKey: [QueryKeys.storeItems.allStoreItems, "inventory-lot-options", { storeId, itemId }],
        enabled:
            typeof storeId === "number" &&
            Number.isFinite(storeId) &&
            typeof itemId === "number" &&
            Number.isFinite(itemId),
        queryFn: async () => {
            const res: ResponseStoreInventoryLotOptions = await getStoreInventoryLotOptions(
                storeId as number,
                itemId as number,
            );
            return res.data;
        },
        staleTime: 60 * 1000,
        refetchOnWindowFocus: false,
        refetchOnReconnect: false,
    });