import { WORKBENCH_SIZE } from "./consts.js";
import { ItemType, type IItem, type IScrewdriver } from "./state/item.js";
import type { IInventory, IState, IWorkbench } from "./state/types.js";

type AllInventories = "player" | "car" | "home" | "workbench";

interface ItemContainer<T> {
    index: number;
    item: T;
}

const GetItemsAsInventory = (items: IItem[]): IInventory => {
    return {
        size: -1,
        items: items,
    };
};

const GetWorkbenchAsInventory = (workbench: IWorkbench): IInventory => {
    return {
        size: WORKBENCH_SIZE,
        items: workbench.devices,
    };
};

const GetInventory = (name: AllInventories, state: IState): IInventory => {
    let inventory: IInventory;

    switch (name) {
        case "player":
            inventory = state.player.inventory;
            break;
        case "car":
            inventory = state.car.inventory;
            break;
        case "home":
            inventory = state.home.inventory;
            break;
        case "workbench":
            inventory = GetWorkbenchAsInventory(state.home.workbench);
            break;
    }

    return inventory;
};

const GetItemsOfType = <T>(
    itemType: ItemType,
    inventories: IInventory[],
): T[] => {
    const items: T[] = [];

    inventories.forEach((inventory) => {
        items.push(
            ...(inventory.items.filter(
                (item) => item.type === itemType,
            ) as T[]),
        );
    });

    return items;
};

const GetItemOfType = <T>(
    itemType: ItemType,
    inventories: IInventory[],
): T | undefined => {
    let item: T | undefined;

    inventories.forEach((inventory) => {
        const found = inventory.items.find(
            (_item) => _item.type === itemType,
        ) as T;
        if (found) {
            item = found;
            return;
        }
    });

    return item;
};

const GetItemContainerOfType = <T>(
    itemType: ItemType,
    inventories: IInventory[],
): ItemContainer<T> | undefined => {
    let container: ItemContainer<T> | undefined;

    inventories.forEach((inventory) => {
        const found = inventory.items.find(
            (_item) => _item.type === itemType,
        ) as T;
        const foundIndex = inventory.items.findIndex(
            (_item) => _item.type === itemType,
        );
        if (found && foundIndex) {
            container = {
                index: foundIndex,
                item: found,
            };
            return;
        }
    });

    return container;
};

const GetBestScrewdriver = (
    inventories: IInventory[],
): IScrewdriver | undefined => {
    const screwdrivers = GetItemsOfType(
        ItemType.SCREWDRIVER,
        inventories,
    ) as IScrewdriver[];

    let bestScrewdriver: IScrewdriver | undefined;
    let bestQuality = -1;

    screwdrivers.forEach((screwdriver) => {
        if (screwdriver.quality > bestQuality) {
            bestScrewdriver = screwdriver;
        }
    });

    return bestScrewdriver;
};

export { type AllInventories, type ItemContainer };
export {
    GetItemsAsInventory,
    GetWorkbenchAsInventory,
    GetInventory,
    GetItemsOfType,
    GetItemOfType,
    GetItemContainerOfType,
    GetBestScrewdriver,
};