/**
 * 품목 관리 Zustand Store
 *
 * React Context 대신 Zustand를 사용한 클라이언트 상태 관리
 * DataContext.tsx에서 마이그레이션
 */

import { create } from 'zustand';
import { devtools } from 'zustand/middleware';
import type { ItemMaster, ItemType, BOMLine } from '@/types/item';

// ===== Store 타입 정의 =====

interface ItemStore {
  // === State ===
  items: ItemMaster[];                  // 품목 목록 (캐시)
  selectedItem: ItemMaster | null;      // 현재 선택된 품목
  isLoading: boolean;                   // 로딩 상태
  error: string | null;                 // 에러 메시지

  // 필터 상태
  filters: {
    itemType?: ItemType;
    search?: string;
    category1?: string;
    category2?: string;
    category3?: string;
    isActive?: boolean;
  };

  // === Actions ===

  // 품목 목록 관리
  setItems: (items: ItemMaster[]) => void;
  addItem: (item: ItemMaster) => void;
  updateItem: (itemCode: string, updates: Partial<ItemMaster>) => void;
  deleteItem: (itemCode: string) => void;

  // 선택 관리
  selectItem: (item: ItemMaster | null) => void;

  // 로딩/에러 상태
  setLoading: (isLoading: boolean) => void;
  setError: (error: string | null) => void;

  // 필터 관리
  setFilters: (filters: Partial<ItemStore['filters']>) => void;
  clearFilters: () => void;

  // === Helpers ===

  // 품목 검색
  getItemByCode: (itemCode: string) => ItemMaster | undefined;
  getItemsByType: (itemType: ItemType) => ItemMaster[];
  getFilteredItems: () => ItemMaster[];

  // BOM 관리
  updateBOM: (itemCode: string, bom: BOMLine[]) => void;

  // 초기화
  reset: () => void;
}

// ===== 초기 상태 =====

const initialState = {
  items: [],
  selectedItem: null,
  isLoading: false,
  error: null,
  filters: {},
};

// ===== Store 생성 =====

export const useItemStore = create<ItemStore>()(
  devtools(
    // persist(  // 필요시 localStorage 영구 저장 활성화
      (set, get) => ({
        // Initial state
        ...initialState,

        // ===== 품목 목록 관리 =====

        setItems: (items) =>
          set(
            { items },
            false,
            'setItems'
          ),

        addItem: (item) =>
          set(
            (state) => ({
              items: [...state.items, item],
            }),
            false,
            'addItem'
          ),

        updateItem: (itemCode, updates) =>
          set(
            (state) => ({
              items: state.items.map((item) =>
                item.itemCode === itemCode ? { ...item, ...updates } : item
              ),
              // 선택된 품목도 업데이트
              selectedItem:
                state.selectedItem?.itemCode === itemCode
                  ? { ...state.selectedItem, ...updates }
                  : state.selectedItem,
            }),
            false,
            'updateItem'
          ),

        deleteItem: (itemCode) =>
          set(
            (state) => ({
              items: state.items.filter((item) => item.itemCode !== itemCode),
              // 선택된 품목이 삭제되면 선택 해제
              selectedItem:
                state.selectedItem?.itemCode === itemCode ? null : state.selectedItem,
            }),
            false,
            'deleteItem'
          ),

        // ===== 선택 관리 =====

        selectItem: (item) =>
          set(
            { selectedItem: item },
            false,
            'selectItem'
          ),

        // ===== 로딩/에러 상태 =====

        setLoading: (isLoading) =>
          set(
            { isLoading },
            false,
            'setLoading'
          ),

        setError: (error) =>
          set(
            { error },
            false,
            'setError'
          ),

        // ===== 필터 관리 =====

        setFilters: (filters) =>
          set(
            (state) => ({
              filters: { ...state.filters, ...filters },
            }),
            false,
            'setFilters'
          ),

        clearFilters: () =>
          set(
            { filters: {} },
            false,
            'clearFilters'
          ),

        // ===== Helpers =====

        getItemByCode: (itemCode) => {
          return get().items.find((item) => item.itemCode === itemCode);
        },

        getItemsByType: (itemType) => {
          return get().items.filter((item) => item.itemType === itemType);
        },

        getFilteredItems: () => {
          const { items, filters } = get();

          return items.filter((item) => {
            // 품목 유형 필터
            if (filters.itemType && item.itemType !== filters.itemType) {
              return false;
            }

            // 검색어 필터 (품목코드 또는 품목명)
            if (filters.search) {
              const searchLower = filters.search.toLowerCase();
              const matchesCode = item.itemCode.toLowerCase().includes(searchLower);
              const matchesName = item.itemName.toLowerCase().includes(searchLower);
              if (!matchesCode && !matchesName) {
                return false;
              }
            }

            // 대분류 필터
            if (filters.category1 && item.category1 !== filters.category1) {
              return false;
            }

            // 중분류 필터
            if (filters.category2 && item.category2 !== filters.category2) {
              return false;
            }

            // 소분류 필터
            if (filters.category3 && item.category3 !== filters.category3) {
              return false;
            }

            // 활성/비활성 필터
            if (filters.isActive !== undefined && item.isActive !== filters.isActive) {
              return false;
            }

            return true;
          });
        },

        // BOM 업데이트
        updateBOM: (itemCode, bom) =>
          set(
            (state) => ({
              items: state.items.map((item) =>
                item.itemCode === itemCode ? { ...item, bom } : item
              ),
              selectedItem:
                state.selectedItem?.itemCode === itemCode
                  ? { ...state.selectedItem, bom }
                  : state.selectedItem,
            }),
            false,
            'updateBOM'
          ),

        // 초기화
        reset: () =>
          set(
            initialState,
            false,
            'reset'
          ),
      }),
    //   {
    //     name: 'item-store', // localStorage 키
    //     partialize: (state) => ({
    //       // 필요한 필드만 영구 저장
    //       filters: state.filters,
    //     }),
    //   }
    // ),
    {
      name: 'ItemStore', // Redux DevTools에 표시될 이름
    }
  )
);

// ===== Selector Hooks (성능 최적화) =====

/**
 * 필터링된 품목 목록만 구독
 */
export const useFilteredItems = () =>
  useItemStore((state) => state.getFilteredItems());

/**
 * 특정 품목 유형만 구독
 */
export const useItemsByType = (itemType: ItemType) =>
  useItemStore((state) => state.getItemsByType(itemType));

/**
 * 선택된 품목만 구독
 */
export const useSelectedItem = () =>
  useItemStore((state) => state.selectedItem);

/**
 * 로딩 상태만 구독
 */
export const useItemLoading = () =>
  useItemStore((state) => state.isLoading);

/**
 * 에러 상태만 구독
 */
export const useItemError = () =>
  useItemStore((state) => state.error);

/**
 * 필터 상태만 구독
 */
export const useItemFilters = () =>
  useItemStore((state) => state.filters);

// ===== 액션 훅 (성능 최적화) =====

/**
 * 품목 관련 액션만 가져오기 (리렌더링 방지)
 */
export const useItemActions = () =>
  useItemStore((state) => ({
    setItems: state.setItems,
    addItem: state.addItem,
    updateItem: state.updateItem,
    deleteItem: state.deleteItem,
    selectItem: state.selectItem,
    setLoading: state.setLoading,
    setError: state.setError,
    setFilters: state.setFilters,
    clearFilters: state.clearFilters,
    updateBOM: state.updateBOM,
    reset: state.reset,
  }));

// ===== 타입 추출 (외부에서 사용) =====

export type { ItemStore };