'use server';

import type { Item, ItemStats, ItemListParams, ItemListResponse, ItemDetail, ItemFormData, OrderItem, ItemType, Specification, OrderType as FrontOrderType, ItemStatus } from './types';
import { apiClient } from '@/lib/api';

// ========================================
// 타입 변환 함수
// ========================================

/**
 * Backend item_type → Frontend itemType 변환
 * FG → 제품, PT → 부품, SM → 소모품, CS → 소모품, RM → 공과
 */
function transformItemType(backendType: string | null | undefined): ItemType {
  const typeMap: Record<string, ItemType> = {
    FG: '제품',
    PT: '부품',
    SM: '소모품',
    CS: '소모품',
    RM: '공과',
  };
  return typeMap[backendType?.toUpperCase() || ''] || '제품';
}

/**
 * Frontend itemType → Backend item_type 변환
 * 제품 → FG, 부품 → PT, 소모품 → CS, 공과 → RM
 */
function transformToBackendItemType(frontendType: ItemType): string {
  const typeMap: Record<ItemType, string> = {
    '제품': 'FG',
    '부품': 'PT',
    '소모품': 'CS',
    '공과': 'RM',
  };
  return typeMap[frontendType] || 'FG';
}

/**
 * Backend attributes.spec → Frontend specification 변환
 * 실제 규격 텍스트 (예: "1∅220V", "면적 18.1m²")
 */
function transformSpecification(attributes: Record<string, unknown> | null | undefined): Specification {
  const spec = attributes?.spec;
  if (typeof spec === 'string' && spec.trim()) return spec.trim();
  return '-';
}

/**
 * Backend options → Frontend orderType 변환
 */
function transformOrderType(options: Record<string, unknown> | null | undefined): FrontOrderType {
  const orderType = options?.orderType as string | undefined;
  const validTypes: FrontOrderType[] = ['외주발주', '경품발주', '원자재발주'];
  if (orderType && validTypes.includes(orderType as FrontOrderType)) {
    return orderType as FrontOrderType;
  }
  return '외주발주'; // 기본값
}

/**
 * Backend is_active + options → Frontend status 변환
 */
function transformStatus(isActive: boolean | null | undefined, options: Record<string, unknown> | null | undefined): ItemStatus {
  const status = options?.status as string | undefined;
  if (status === '승인' || status === '작업' || status === '사용' || status === '중지') {
    return status;
  }
  return isActive ? '사용' : '중지';
}

/**
 * Backend options → Frontend orderItems 변환
 */
function transformOrderItems(options: Record<string, unknown> | null | undefined): OrderItem[] {
  const orderItems = options?.orderItems;
  if (Array.isArray(orderItems)) {
    return orderItems.map((item: { id?: string; label?: string; value?: string }, index: number) => ({
      id: item.id || `oi_${index}`,
      label: item.label || '',
      value: item.value || '',
    }));
  }
  return [];
}

/**
 * API 응답 → Item 타입 변환
 */
interface ApiItem {
  id: number;
  item_code: string; // API가 'code' 대신 'item_code'로 반환 (ApiResponse 충돌 방지)
  name: string;
  item_type: string | null;
  category_id: number | null;
  category?: { name?: string } | null;
  unit: string | null;
  options: Record<string, unknown> | null;
  attributes: Record<string, unknown> | null;
  is_active: boolean;
  description: string | null;
  created_at: string;
  updated_at: string;
}

function transformItem(apiItem: ApiItem): Item {
  return {
    id: String(apiItem.id),
    itemNumber: apiItem.item_code || '',
    itemName: apiItem.name || '',
    itemType: transformItemType(apiItem.item_type),
    categoryId: apiItem.category_id ? String(apiItem.category_id) : '',
    categoryName: apiItem.category?.name || '',
    unit: apiItem.unit || 'EA',
    specification: transformSpecification(apiItem.attributes),
    orderType: transformOrderType(apiItem.options),
    status: transformStatus(apiItem.is_active, apiItem.options),
    createdAt: apiItem.created_at,
    updatedAt: apiItem.updated_at,
  };
}

/**
 * API 응답 → ItemDetail 타입 변환
 */
function transformItemDetail(apiItem: ApiItem): ItemDetail {
  return {
    ...transformItem(apiItem),
    note: apiItem.description || '',
    orderItems: transformOrderItems(apiItem.options),
  };
}

/**
 * ItemFormData → API 요청 데이터 변환
 */
function transformItemToApi(data: ItemFormData): Record<string, unknown> {
  return {
    code: data.itemNumber,
    name: data.itemName,
    product_type: transformToBackendItemType(data.itemType),
    category_id: data.categoryId ? parseInt(data.categoryId, 10) : null,
    unit: data.unit,
    is_active: data.status === '사용' || data.status === '승인',
    description: data.note || null,
    attributes: {
      spec: data.specification || null,
    },
    options: {
      orderType: data.orderType,
      status: data.status,
      orderItems: data.orderItems,
    },
  };
}

// ========================================
// API 함수
// ========================================

/**
 * 품목 목록 조회
 * GET /api/v1/items
 */
export async function getItemList(
  params: ItemListParams = {}
): Promise<{ success: boolean; data?: ItemListResponse; error?: string }> {
  try {
    const queryParams: Record<string, string> = {};

    // 페이지네이션
    if (params.page) queryParams.page = String(params.page);
    if (params.size) queryParams.size = String(params.size);

    // 검색
    if (params.search) queryParams.q = params.search;

    // 품목유형 필터 (Frontend → Backend 변환)
    if (params.itemType && params.itemType !== 'all') {
      queryParams.type = transformToBackendItemType(params.itemType as ItemType);
    }

    // 카테고리 필터
    if (params.categoryId && params.categoryId !== 'all') {
      queryParams.category_id = params.categoryId;
    }

    // 활성 상태 필터
    if (params.status && params.status !== 'all') {
      queryParams.active = params.status === '사용' || params.status === '승인' ? '1' : '0';
    }

    const response = await apiClient.get<{
      data: ApiItem[];
      meta?: { total: number; current_page: number; per_page: number };
      total?: number;
      current_page?: number;
      per_page?: number;
      last_page?: number;
    }>('/items', { params: queryParams });

    // API 응답 구조 처리
    // Laravel 페이지네이션 응답: { current_page, data: [...], last_page, per_page, total, ... }
    // data 필드가 배열인 경우와 페이지네이션 객체인 경우 모두 처리
    let items: ApiItem[];
    let meta: { total: number; current_page: number; per_page: number };

    if (Array.isArray(response.data)) {
      // response.data가 직접 배열인 경우
      items = response.data;
      meta = response.meta || {
        total: response.total || items.length,
        current_page: response.current_page || params.page || 1,
        per_page: response.per_page || params.size || 20,
      };
    } else if (response.data && Array.isArray((response as unknown as { data: { data: ApiItem[] } }).data.data)) {
      // response가 { data: { current_page, data: [...], ... } } 형태인 경우 (Laravel 페이지네이션)
      const paginatedResponse = response as unknown as {
        data: { data: ApiItem[]; current_page: number; total: number; per_page: number };
      };
      items = paginatedResponse.data.data;
      meta = {
        total: paginatedResponse.data.total || items.length,
        current_page: paginatedResponse.data.current_page || params.page || 1,
        per_page: paginatedResponse.data.per_page || params.size || 20,
      };
    } else if (response.current_page !== undefined && Array.isArray((response as unknown as { data: ApiItem[] }).data)) {
      // response가 { current_page, data: [...], total, per_page } 형태인 경우
      items = (response as unknown as { data: ApiItem[] }).data;
      meta = {
        total: response.total || items.length,
        current_page: response.current_page || params.page || 1,
        per_page: response.per_page || params.size || 20,
      };
    } else {
      // 예상치 못한 응답 구조
      console.error('❌ [getItemList] 예상치 못한 응답 구조:', response);
      items = [];
      meta = { total: 0, current_page: 1, per_page: 20 };
    }


    // Frontend 필터링 (Backend에서 지원하지 않는 필터)
    let transformedItems = items.map(transformItem);

    // 규격 필터 (Frontend)
    if (params.specification && params.specification !== 'all') {
      transformedItems = transformedItems.filter((item) => item.specification === params.specification);
    }

    // 구분 필터 (Frontend)
    if (params.orderType && params.orderType !== 'all') {
      transformedItems = transformedItems.filter((item) => item.orderType === params.orderType);
    }

    // 상태 필터 (Frontend에서 추가 처리)
    if (params.status && params.status !== 'all') {
      transformedItems = transformedItems.filter((item) => item.status === params.status);
    }

    // 날짜 필터 (Frontend)
    if (params.startDate) {
      const startDate = new Date(params.startDate);
      transformedItems = transformedItems.filter((item) => new Date(item.createdAt) >= startDate);
    }
    if (params.endDate) {
      const endDate = new Date(params.endDate);
      endDate.setHours(23, 59, 59, 999);
      transformedItems = transformedItems.filter((item) => new Date(item.createdAt) <= endDate);
    }

    // 정렬 (Frontend)
    if (params.sortBy === 'oldest') {
      transformedItems.sort((a, b) => new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime());
    } else {
      transformedItems.sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
    }

    return {
      success: true,
      data: {
        items: transformedItems,
        total: meta.total,
        page: meta.current_page,
        size: meta.per_page,
      },
    };
  } catch (error) {
    console.error('❌ [getItemList] 오류:', error);
    return { success: false, error: '품목 목록을 불러오는데 실패했습니다.' };
  }
}

/**
 * 품목 통계 조회
 * GET /api/v1/items/stats
 */
export async function getItemStats(): Promise<{ success: boolean; data?: ItemStats; error?: string }> {
  try {
    const response = await apiClient.get<{ total: number; active: number }>('/items/stats');

    return {
      success: true,
      data: {
        total: response.total,
        active: response.active,
      },
    };
  } catch (error) {
    console.error('품목 통계 조회 오류:', error);
    return { success: false, error: '품목 통계를 불러오는데 실패했습니다.' };
  }
}

/**
 * 품목 삭제
 * DELETE /api/v1/items/{id}
 */
export async function deleteItem(id: string): Promise<{ success: boolean; error?: string }> {
  try {
    await apiClient.delete(`/items/${id}`);
    return { success: true };
  } catch (error) {
    console.error('품목 삭제 오류:', error);
    return { success: false, error: '품목 삭제에 실패했습니다.' };
  }
}

/**
 * 품목 일괄 삭제
 * DELETE /api/v1/items/batch
 */
export async function deleteItems(
  ids: string[]
): Promise<{ success: boolean; deletedCount?: number; error?: string }> {
  try {
    const response = await apiClient.delete<{ deleted_count: number }>('/items/batch', {
      data: { ids: ids.map((id) => parseInt(id, 10)) },
    });

    return { success: true, deletedCount: response.deleted_count };
  } catch (error) {
    console.error('품목 일괄 삭제 오류:', error);
    return { success: false, error: '품목 일괄 삭제에 실패했습니다.' };
  }
}

/**
 * 카테고리 목록 조회 (필터용)
 * GET /api/v1/categories
 */
export async function getCategoryOptions(): Promise<{
  success: boolean;
  data?: { id: string; name: string }[];
  error?: string;
}> {
  try {
    const response = await apiClient.get<{
      success: boolean;
      message: string;
      data: {
        current_page: number;
        data: { id: number; name: string }[];
        total: number;
      };
    }>('/categories', { params: { size: '100' } });

    // API 응답 구조: { success, message, data: { current_page, data: [...], ... } }
    const categoryData = response.data?.data;
    if (!Array.isArray(categoryData)) {
      console.error('카테고리 응답 구조 오류:', response);
      return { success: true, data: [] };
    }

    const categories = categoryData.map((cat) => ({
      id: String(cat.id),
      name: cat.name,
    }));

    return { success: true, data: categories };
  } catch (error) {
    console.error('카테고리 목록 조회 오류:', error);
    return { success: false, error: '카테고리 목록을 불러오는데 실패했습니다.' };
  }
}

/**
 * 품목 상세 조회
 * GET /api/v1/items/{id}
 */
export async function getItem(id: string): Promise<{
  success: boolean;
  data?: ItemDetail;
  error?: string;
}> {
  try {
    const response = await apiClient.get<{ success: boolean; message: string; data: ApiItem }>(`/items/${id}`);

    // API 응답 구조: { success, message, data: {...item...} }
    const item = response.data;
    if (!item) {
      console.error('❌ [getItem] 응답에 data가 없음:', response);
      return { success: false, error: '품목 정보를 찾을 수 없습니다.' };
    }

    return { success: true, data: transformItemDetail(item) };
  } catch (error) {
    console.error('품목 상세 조회 오류:', error);
    return { success: false, error: '품목 정보를 불러오는데 실패했습니다.' };
  }
}

/**
 * 품목 등록
 * POST /api/v1/items
 */
export async function createItem(data: ItemFormData): Promise<{
  success: boolean;
  data?: { id: string };
  error?: string;
}> {
  try {
    const apiData = transformItemToApi(data);
    const response = await apiClient.post<{ success: boolean; data: { id: number }; id?: number }>('/items', apiData);

    // API 응답 구조: { success, message, data: { id } } 또는 { id }
    const itemId = response.data?.id ?? response.id;
    if (!itemId) {
      console.error('❌ [createItem] 응답에서 ID를 찾을 수 없음:', response);
      return { success: false, error: '품목 등록 후 ID를 가져오지 못했습니다.' };
    }
    return { success: true, data: { id: String(itemId) } };
  } catch (error) {
    console.error('❌ [createItem] 품목 등록 오류:', error);
    return { success: false, error: '품목 등록에 실패했습니다.' };
  }
}

/**
 * 품목 수정
 * PUT /api/v1/items/{id}
 */
export async function updateItem(
  id: string,
  data: ItemFormData
): Promise<{
  success: boolean;
  error?: string;
}> {
  try {
    const apiData = transformItemToApi(data);
    await apiClient.put(`/items/${id}`, apiData);

    return { success: true };
  } catch (error) {
    console.error('품목 수정 오류:', error);
    return { success: false, error: '품목 수정에 실패했습니다.' };
  }
}