import { create } from 'zustand';
import { persist } from 'zustand/middleware';

export interface InventoryState {
    unlockedCharacters: string[];
    unlockedCustomizations: string[];
    unlockedDLCs: string[];
    unlockedPerks: string[];
    items: Record<string, number>;
    offerings: Record<string, number>;
    addons: Record<string, number>;

    spoofItems: boolean;
    spoofPerks: boolean;
    spoofCatalog: boolean;
    spoofDLCs: boolean;

    toggleItem: (id: string, category: 'characters' | 'customizations' | 'items' | 'offerings' | 'addons' | 'dlcs' | 'perks') => void;
    setItemQuantity: (id: string, qty: number) => void;
    setOfferingQuantity: (id: string, qty: number) => void;
    setAddonQuantity: (id: string, qty: number) => void;
    setToggle: (key: 'spoofItems' | 'spoofPerks' | 'spoofCatalog' | 'spoofDLCs', val: boolean) => void;
    importToggles: (toggles: any) => void;

    unlockAllInCategory: (category: 'characters' | 'customizations' | 'items' | 'offerings' | 'addons' | 'dlcs' | 'perks', allIds: string[], qty?: number) => void;
    clearCategory: (category: 'characters' | 'customizations' | 'items' | 'offerings' | 'addons' | 'dlcs' | 'perks') => void;
    clearAll: () => void;
    importProfile: (profile: any) => void;
}

export const useInventoryStore = create<InventoryState>()(
    persist(
        (set) => ({
            unlockedCharacters: [],
            unlockedCustomizations: [],
            unlockedDLCs: [],
            unlockedPerks: [],
            items: {},
            offerings: {},
            addons: {},

            spoofItems: false,
            spoofPerks: false,
            spoofCatalog: false,
            spoofDLCs: false,

            setToggle: (key, val) => set({ [key]: val }),

            importToggles: (toggles) => set((state) => {
                if (!toggles) return {};
                return {
                    spoofItems: typeof toggles.spoofItems === 'boolean' ? toggles.spoofItems : state.spoofItems,
                    spoofPerks: typeof toggles.spoofPerks === 'boolean' ? toggles.spoofPerks : state.spoofPerks,
                    spoofCatalog: typeof toggles.spoofCatalog === 'boolean' ? toggles.spoofCatalog : state.spoofCatalog,
                    spoofDLCs: typeof toggles.spoofDLCs === 'boolean' ? toggles.spoofDLCs : state.spoofDLCs,
                };
            }),

            toggleItem: (id, category) => set((state) => {
                if (category === 'characters') {
                    const arr = state.unlockedCharacters;
                    return { unlockedCharacters: arr.includes(id) ? arr.filter(i => i !== id) : [...arr, id] };
                } else if (category === 'customizations') {
                    const arr = state.unlockedCustomizations;
                    return { unlockedCustomizations: arr.includes(id) ? arr.filter(i => i !== id) : [...arr, id] };
                } else if (category === 'dlcs') {
                    const arr = state.unlockedDLCs;
                    return { unlockedDLCs: arr.includes(id) ? arr.filter(i => i !== id) : [...arr, id] };
                } else if (category === 'perks') {
                    const arr = state.unlockedPerks;
                    return { unlockedPerks: arr.includes(id) ? arr.filter(i => i !== id) : [...arr, id] };
                } else if (category === 'items') {
                    const newItems = { ...state.items };
                    if ((newItems[id] || 0) > 0) delete newItems[id]; else newItems[id] = 100;
                    return { items: newItems };
                } else if (category === 'addons') {
                    const newAddons = { ...state.addons };
                    if ((newAddons[id] || 0) > 0) delete newAddons[id]; else newAddons[id] = 100;
                    return { addons: newAddons };
                } else {
                    const newOfferings = { ...state.offerings };
                    if ((newOfferings[id] || 0) > 0) delete newOfferings[id]; else newOfferings[id] = 100;
                    return { offerings: newOfferings };
                }
            }),

            setItemQuantity: (id, qty) => set((state) => {
                const newItems = { ...state.items };
                if (qty <= 0) delete newItems[id]; else newItems[id] = Math.min(32767, Math.max(0, qty));
                return { items: newItems };
            }),

            setOfferingQuantity: (id, qty) => set((state) => {
                const newOfferings = { ...state.offerings };
                if (qty <= 0) delete newOfferings[id]; else newOfferings[id] = Math.min(32767, Math.max(0, qty));
                return { offerings: newOfferings };
            }),

            setAddonQuantity: (id, qty) => set((state) => {
                const newAddons = { ...state.addons };
                if (qty <= 0) delete newAddons[id]; else newAddons[id] = Math.min(32767, Math.max(0, qty));
                return { addons: newAddons };
            }),

            unlockAllInCategory: (category, allIds, qty = 100) => set((state) => {
                if (category === 'characters') return { unlockedCharacters: allIds };
                if (category === 'customizations') return { unlockedCustomizations: allIds };
                if (category === 'dlcs') return { unlockedDLCs: allIds };
                if (category === 'perks') return { unlockedPerks: allIds };
                if (category === 'items') {
                    const newItems = { ...state.items };
                    allIds.forEach(id => { newItems[id] = qty; });
                    return { items: newItems };
                } else if (category === 'addons') {
                    const newAddons = { ...state.addons };
                    allIds.forEach(id => { newAddons[id] = qty; });
                    return { addons: newAddons };
                } else {
                    const newOfferings = { ...state.offerings };
                    allIds.forEach(id => { newOfferings[id] = qty; });
                    return { offerings: newOfferings };
                }
            }),

            clearCategory: (category) => set(() => {
                if (category === 'characters') return { unlockedCharacters: [] };
                if (category === 'customizations') return { unlockedCustomizations: [] };
                if (category === 'dlcs') return { unlockedDLCs: [] };
                if (category === 'perks') return { unlockedPerks: [] };
                if (category === 'items') return { items: {} };
                if (category === 'addons') return { addons: {} };
                return { offerings: {} };
            }),

            clearAll: () => set({
                unlockedCharacters: [],
                unlockedCustomizations: [],
                unlockedDLCs: [],
                unlockedPerks: [],
                items: {},
                offerings: {},
                addons: {},
            }),

            importProfile: (profile) => set((state) => {
                if (!profile) return {};
                return {
                    unlockedCharacters: Array.isArray(profile.unlockedCharacters) ? profile.unlockedCharacters : state.unlockedCharacters,
                    unlockedCustomizations: Array.isArray(profile.unlockedCustomizations) ? profile.unlockedCustomizations : state.unlockedCustomizations,
                    unlockedDLCs: Array.isArray(profile.unlockedDLCs) ? profile.unlockedDLCs : state.unlockedDLCs,
                    unlockedPerks: Array.isArray(profile.unlockedPerks) ? profile.unlockedPerks : state.unlockedPerks,
                    items: (profile.items && typeof profile.items === 'object') ? profile.items : state.items,
                    offerings: (profile.offerings && typeof profile.offerings === 'object') ? profile.offerings : state.offerings,
                    addons: (profile.addons && typeof profile.addons === 'object') ? profile.addons : state.addons,
                };
            })
        }),
        {
            name: 'hex-unlocked-inventory',
        }
    )
);