import {create} from "zustand";
import {B2BQOMOrderListItem, B2BQOM_item} from "../types/b2bqom";


export type ParseMode = 'full' | 'selection' | 'auto';

export const toParseMode = (modeString: string | null | undefined): ParseMode => {
  switch (modeString) {
    case "full":
    case "selection":
    case "auto":
      return modeString;
    default:
      return "auto"; // fallback to safest default
  }
}

const LS_KEY_PARSE_MODE = "b2bqom_parseMode";

type StoreState = {
  // state
  searchTerm: string;
  searchTermOnSearchAction: string;
  searchResults: B2BQOM_item[];
  orderList: B2BQOMOrderListItem[];
  orderName: string;
  showEmptyResultsMsg: boolean;
  unresolvedSkus: string[];
  parseMode: ParseMode;

  // actions
  setSearchTerm: (term: string) => void;
  setSearchTermOnSearchAction: (term: string) => void;
  setSearchResults: (term: string, results: B2BQOM_item[]) => void;
  clearSearchResults: () => void;
  setUnresolvedSkus: (unresolvedSkus: string[]) => void;
  setParseMode: (mode: string | null) => void;

  addAllToOrderList: (item: B2BQOMOrderListItem[]) => void;
  addToOrderList: (item: B2BQOMOrderListItem) => void;
  removeFromOrderList: (id: number) => void;
  clearOrderList: () => void;
  updateInOrderList: (item: B2BQOMOrderListItem) => void;
  capQuantitiesToStock: () => number;
  setOrderName: (name: string) => void;

};

export const useAppStore = create<StoreState>((set) => ({
  // initial state
  searchTerm: '',
  searchTermOnSearchAction: '',
  searchResults: [],
  orderList: [],
  orderName: '',
  showEmptyResultsMsg: false,
  unresolvedSkus: [],
  parseMode: 'auto',


  // actions
  setSearchTerm: (term) => set({searchTerm: term}),
  setSearchTermOnSearchAction: (term) => set({searchTermOnSearchAction: term}),
  setUnresolvedSkus: (unresolvedSkus => set({unresolvedSkus})),

  setSearchResults: (term, results) => set({
    searchTermOnSearchAction: term,
    searchResults: results,
    showEmptyResultsMsg: results.length === 0
  }),

  setParseMode: (mode: string | null) => {
    const normalized = toParseMode(mode)
    localStorage.setItem(LS_KEY_PARSE_MODE, normalized)
    set({parseMode: toParseMode(mode)})
  },

  clearSearchResults: () => set({
    searchResults: [],
    showEmptyResultsMsg: false,
    searchTerm: '',
    searchTermOnSearchAction: ''
  }),

  addToOrderList: (item) =>
    set((state) => ({
      orderList: [...state.orderList, item],
    })),

  addAllToOrderList: (items) =>
    set((state) => {
      const orderList = [...state.orderList];
      const skuIndexMap = new Map(orderList.map((item, idx) => [item.sku, idx]));

      items.forEach(newItem => {
        const existingIdx = skuIndexMap.get(newItem.sku);
        if (existingIdx !== undefined) {
          // Merge quantities for existing SKU
          orderList[existingIdx] = {
            ...orderList[existingIdx],
            quantity: orderList[existingIdx].quantity + newItem.quantity,
          };
        } else {
          // Add new item at the end
          orderList.push(newItem);
          skuIndexMap.set(newItem.sku, orderList.length - 1);
        }
      });

      return { orderList };
    }),

  updateInOrderList: (item) =>
    set((state) => ({
      orderList: state.orderList.map(oli => oli.id === item.id ? item : oli),
    })),

  removeFromOrderList: (id) =>
    set((state) => ({
      orderList: state.orderList.filter((i) => i.id !== id),
    })),

  clearOrderList: () => set({orderList: [], unresolvedSkus: [], orderName: ''}),

  setOrderName: (name: string) => set({orderName: name}),

  capQuantitiesToStock: () => {
    let adjustedCount = 0;
    set((state) => {
      const orderList = state.orderList.map(item => {
        if (item.stock_quantity != null && item.quantity > item.stock_quantity) {
          adjustedCount++;
          return { ...item, quantity: item.stock_quantity };
        }
        return item;
      });
      return { orderList };
    });
    return adjustedCount;
  },

}));