// 품목기준관리 API Client
// Phase 0: 기본 구조 작성 (API 연동은 백엔드 완성 후)

import type {
  ApiResponse,
  InitResponse,
  ItemPageRequest,
  ItemPageResponse,
  PageReorderRequest,
  ItemSectionRequest,
  ItemSectionResponse,
  SectionReorderRequest,
  ItemFieldRequest,
  ItemFieldResponse,
  FieldReorderRequest,
  BomItemRequest,
  BomItemResponse,
  SectionTemplateRequest,
  SectionTemplateResponse,
  MasterFieldRequest,
  MasterFieldResponse,
  CustomTabRequest,
  CustomTabResponse,
  TabReorderRequest,
  TabColumnUpdateRequest,
  UnitOptionRequest,
  UnitOptionResponse,
} from '@/types/item-master-api';
import { getAuthHeaders } from './auth-headers';
import { handleApiError } from './error-handler';
import { apiLogger } from './logger';

const BASE_URL = process.env.NEXT_PUBLIC_API_URL || 'http://api.codebridge-x.com/api/v1';

export const itemMasterApi = {
  // ============================================
  // 초기화 API
  // ============================================
  /**
   * 초기 데이터 로드 (화면 진입 시 호출)
   * @returns pages, sectionTemplates, masterFields, customTabs, tabColumns, unitOptions
   */
  init: async (): Promise<InitResponse> => {
    const startTime = apiLogger.logRequest('GET', `${BASE_URL}/item-master/init`);

    try {
      const headers = getAuthHeaders();
      const response = await fetch(`${BASE_URL}/item-master/init`, {
        method: 'GET',
        headers,
      });

      if (!response.ok) {
        await handleApiError(response);
      }

      const result: ApiResponse<InitResponse> = await response.json();
      apiLogger.logResponse('GET', `${BASE_URL}/item-master/init`, response.status, result, startTime);

      return result.data;
    } catch (error) {
      // 네트워크 오류 (서버 연결 실패, CORS 오류 등)
      if (error instanceof TypeError) {
        apiLogger.logError('GET', `${BASE_URL}/item-master/init`, error, undefined, startTime);
        throw new Error('네트워크 연결을 확인해주세요. 서버에 연결할 수 없습니다.');
      }

      apiLogger.logError('GET', `${BASE_URL}/item-master/init`, error as Error, undefined, startTime);
      throw error;
    }
  },

  // ============================================
  // 페이지 관리
  // ============================================
  pages: {
    list: async () => {
      // TODO: Phase 2에서 구현
      throw new Error('API 연동 전');
    },

    /**
     * 페이지 생성
     * POST /v1/item-master/pages
     */
    create: async (data: ItemPageRequest): Promise<ItemPageResponse> => {
      const startTime = apiLogger.logRequest('POST', `${BASE_URL}/item-master/pages`, data);

      try {
        const headers = getAuthHeaders();
        const response = await fetch(`${BASE_URL}/item-master/pages`, {
          method: 'POST',
          headers,
          body: JSON.stringify(data),
        });

        if (!response.ok) {
          await handleApiError(response);
        }

        const result: ApiResponse<ItemPageResponse> = await response.json();
        apiLogger.logResponse('POST', `${BASE_URL}/item-master/pages`, response.status, result, startTime);

        return result.data;
      } catch (error) {
        if (error instanceof TypeError) {
          apiLogger.logError('POST', `${BASE_URL}/item-master/pages`, error, undefined, startTime);
          throw new Error('네트워크 연결을 확인해주세요. 서버에 연결할 수 없습니다.');
        }

        apiLogger.logError('POST', `${BASE_URL}/item-master/pages`, error as Error, undefined, startTime);
        throw error;
      }
    },

    /**
     * 페이지 수정
     * PUT /v1/item-master/pages/{id}
     */
    update: async (id: number, data: Partial<ItemPageRequest>): Promise<ApiResponse<ItemPageResponse>> => {
      const startTime = apiLogger.logRequest('PUT', `${BASE_URL}/item-master/pages/${id}`, data);

      try {
        const headers = getAuthHeaders();
        const response = await fetch(`${BASE_URL}/item-master/pages/${id}`, {
          method: 'PUT',
          headers,
          body: JSON.stringify(data),
        });

        if (!response.ok) {
          await handleApiError(response);
        }

        const result: ApiResponse<ItemPageResponse> = await response.json();
        apiLogger.logResponse('PUT', `${BASE_URL}/item-master/pages/${id}`, response.status, result, startTime);

        return result;
      } catch (error) {
        if (error instanceof TypeError) {
          apiLogger.logError('PUT', `${BASE_URL}/item-master/pages/${id}`, error, undefined, startTime);
          throw new Error('네트워크 연결을 확인해주세요. 서버에 연결할 수 없습니다.');
        }

        apiLogger.logError('PUT', `${BASE_URL}/item-master/pages/${id}`, error as Error, undefined, startTime);
        throw error;
      }
    },

    /**
     * 페이지 삭제
     * DELETE /v1/item-master/pages/{id}
     */
    delete: async (id: number): Promise<ApiResponse<void>> => {
      const startTime = apiLogger.logRequest('DELETE', `${BASE_URL}/item-master/pages/${id}`);

      try {
        const headers = getAuthHeaders();
        const response = await fetch(`${BASE_URL}/item-master/pages/${id}`, {
          method: 'DELETE',
          headers,
        });

        if (!response.ok) {
          await handleApiError(response);
        }

        const result: ApiResponse<void> = await response.json();
        apiLogger.logResponse('DELETE', `${BASE_URL}/item-master/pages/${id}`, response.status, result, startTime);

        return result;
      } catch (error) {
        if (error instanceof TypeError) {
          apiLogger.logError('DELETE', `${BASE_URL}/item-master/pages/${id}`, error, undefined, startTime);
          throw new Error('네트워크 연결을 확인해주세요. 서버에 연결할 수 없습니다.');
        }

        apiLogger.logError('DELETE', `${BASE_URL}/item-master/pages/${id}`, error as Error, undefined, startTime);
        throw error;
      }
    },

    /**
     * 페이지 순서 변경
     * PUT /v1/item-master/pages/reorder
     */
    reorder: async (data: PageReorderRequest): Promise<ApiResponse<ItemPageResponse[]>> => {
      const startTime = apiLogger.logRequest('PUT', `${BASE_URL}/item-master/pages/reorder`, data);

      try {
        const headers = getAuthHeaders();
        const response = await fetch(`${BASE_URL}/item-master/pages/reorder`, {
          method: 'PUT',
          headers,
          body: JSON.stringify(data),
        });

        if (!response.ok) {
          await handleApiError(response);
        }

        const result: ApiResponse<ItemPageResponse[]> = await response.json();
        apiLogger.logResponse('PUT', `${BASE_URL}/item-master/pages/reorder`, response.status, result, startTime);

        return result;
      } catch (error) {
        if (error instanceof TypeError) {
          apiLogger.logError('PUT', `${BASE_URL}/item-master/pages/reorder`, error, undefined, startTime);
          throw new Error('네트워크 연결을 확인해주세요. 서버에 연결할 수 없습니다.');
        }

        apiLogger.logError('PUT', `${BASE_URL}/item-master/pages/reorder`, error as Error, undefined, startTime);
        throw error;
      }
    },
  },

  // ============================================
  // 섹션 관리
  // ============================================
  sections: {
    /**
     * 섹션 생성
     * POST /v1/item-master/pages/{pageId}/sections
     */
    create: async (pageId: number, data: ItemSectionRequest): Promise<ApiResponse<ItemSectionResponse>> => {
      const startTime = apiLogger.logRequest('POST', `${BASE_URL}/item-master/pages/${pageId}/sections`, data);

      try {
        const headers = getAuthHeaders();
        const response = await fetch(`${BASE_URL}/item-master/pages/${pageId}/sections`, {
          method: 'POST',
          headers,
          body: JSON.stringify(data),
        });

        if (!response.ok) {
          await handleApiError(response);
        }

        const result: ApiResponse<ItemSectionResponse> = await response.json();
        apiLogger.logResponse('POST', `${BASE_URL}/item-master/pages/${pageId}/sections`, response.status, result, startTime);

        return result;
      } catch (error) {
        if (error instanceof TypeError) {
          apiLogger.logError('POST', `${BASE_URL}/item-master/pages/${pageId}/sections`, error, undefined, startTime);
          throw new Error('네트워크 연결을 확인해주세요. 서버에 연결할 수 없습니다.');
        }

        apiLogger.logError('POST', `${BASE_URL}/item-master/pages/${pageId}/sections`, error as Error, undefined, startTime);
        throw error;
      }
    },

    /**
     * 섹션 수정
     * PUT /v1/item-master/sections/{id}
     */
    update: async (id: number, data: Partial<ItemSectionRequest>): Promise<ApiResponse<ItemSectionResponse>> => {
      const startTime = apiLogger.logRequest('PUT', `${BASE_URL}/item-master/sections/${id}`, data);

      try {
        const headers = getAuthHeaders();
        const response = await fetch(`${BASE_URL}/item-master/sections/${id}`, {
          method: 'PUT',
          headers,
          body: JSON.stringify(data),
        });

        if (!response.ok) {
          await handleApiError(response);
        }

        const result: ApiResponse<ItemSectionResponse> = await response.json();
        apiLogger.logResponse('PUT', `${BASE_URL}/item-master/sections/${id}`, response.status, result, startTime);

        return result;
      } catch (error) {
        if (error instanceof TypeError) {
          apiLogger.logError('PUT', `${BASE_URL}/item-master/sections/${id}`, error, undefined, startTime);
          throw new Error('네트워크 연결을 확인해주세요. 서버에 연결할 수 없습니다.');
        }

        apiLogger.logError('PUT', `${BASE_URL}/item-master/sections/${id}`, error as Error, undefined, startTime);
        throw error;
      }
    },

    /**
     * 섹션 삭제
     * DELETE /v1/item-master/sections/{id}
     */
    delete: async (id: number): Promise<ApiResponse<void>> => {
      const startTime = apiLogger.logRequest('DELETE', `${BASE_URL}/item-master/sections/${id}`);

      try {
        const headers = getAuthHeaders();
        const response = await fetch(`${BASE_URL}/item-master/sections/${id}`, {
          method: 'DELETE',
          headers,
        });

        if (!response.ok) {
          await handleApiError(response);
        }

        const result: ApiResponse<void> = await response.json();
        apiLogger.logResponse('DELETE', `${BASE_URL}/item-master/sections/${id}`, response.status, result, startTime);

        return result;
      } catch (error) {
        if (error instanceof TypeError) {
          apiLogger.logError('DELETE', `${BASE_URL}/item-master/sections/${id}`, error, undefined, startTime);
          throw new Error('네트워크 연결을 확인해주세요. 서버에 연결할 수 없습니다.');
        }

        apiLogger.logError('DELETE', `${BASE_URL}/item-master/sections/${id}`, error as Error, undefined, startTime);
        throw error;
      }
    },

    /**
     * 섹션 순서 변경
     * PUT /v1/item-master/pages/{pageId}/sections/reorder
     */
    reorder: async (pageId: number, data: SectionReorderRequest): Promise<ApiResponse<ItemSectionResponse[]>> => {
      const startTime = apiLogger.logRequest('PUT', `${BASE_URL}/item-master/pages/${pageId}/sections/reorder`, data);

      try {
        const headers = getAuthHeaders();
        const response = await fetch(`${BASE_URL}/item-master/pages/${pageId}/sections/reorder`, {
          method: 'PUT',
          headers,
          body: JSON.stringify(data),
        });

        if (!response.ok) {
          await handleApiError(response);
        }

        const result: ApiResponse<ItemSectionResponse[]> = await response.json();
        apiLogger.logResponse('PUT', `${BASE_URL}/item-master/pages/${pageId}/sections/reorder`, response.status, result, startTime);

        return result;
      } catch (error) {
        if (error instanceof TypeError) {
          apiLogger.logError('PUT', `${BASE_URL}/item-master/pages/${pageId}/sections/reorder`, error, undefined, startTime);
          throw new Error('네트워크 연결을 확인해주세요. 서버에 연결할 수 없습니다.');
        }

        apiLogger.logError('PUT', `${BASE_URL}/item-master/pages/${pageId}/sections/reorder`, error as Error, undefined, startTime);
        throw error;
      }
    },
  },

  // ============================================
  // 필드 관리
  // ============================================
  fields: {
    /**
     * 필드 생성
     * POST /v1/item-master/sections/{sectionId}/fields
     */
    create: async (sectionId: number, data: ItemFieldRequest): Promise<ApiResponse<ItemFieldResponse>> => {
      const startTime = apiLogger.logRequest('POST', `${BASE_URL}/item-master/sections/${sectionId}/fields`, data);

      try {
        const headers = getAuthHeaders();
        const response = await fetch(`${BASE_URL}/item-master/sections/${sectionId}/fields`, {
          method: 'POST',
          headers,
          body: JSON.stringify(data),
        });

        if (!response.ok) {
          await handleApiError(response);
        }

        const result: ApiResponse<ItemFieldResponse> = await response.json();
        apiLogger.logResponse('POST', `${BASE_URL}/item-master/sections/${sectionId}/fields`, response.status, result, startTime);

        return result;
      } catch (error) {
        if (error instanceof TypeError) {
          apiLogger.logError('POST', `${BASE_URL}/item-master/sections/${sectionId}/fields`, error, undefined, startTime);
          throw new Error('네트워크 연결을 확인해주세요. 서버에 연결할 수 없습니다.');
        }

        apiLogger.logError('POST', `${BASE_URL}/item-master/sections/${sectionId}/fields`, error as Error, undefined, startTime);
        throw error;
      }
    },

    /**
     * 필드 수정
     * PUT /v1/item-master/fields/{id}
     */
    update: async (id: number, data: Partial<ItemFieldRequest>): Promise<ApiResponse<ItemFieldResponse>> => {
      const startTime = apiLogger.logRequest('PUT', `${BASE_URL}/item-master/fields/${id}`, data);

      try {
        const headers = getAuthHeaders();
        const response = await fetch(`${BASE_URL}/item-master/fields/${id}`, {
          method: 'PUT',
          headers,
          body: JSON.stringify(data),
        });

        if (!response.ok) {
          await handleApiError(response);
        }

        const result: ApiResponse<ItemFieldResponse> = await response.json();
        apiLogger.logResponse('PUT', `${BASE_URL}/item-master/fields/${id}`, response.status, result, startTime);

        return result;
      } catch (error) {
        if (error instanceof TypeError) {
          apiLogger.logError('PUT', `${BASE_URL}/item-master/fields/${id}`, error, undefined, startTime);
          throw new Error('네트워크 연결을 확인해주세요. 서버에 연결할 수 없습니다.');
        }

        apiLogger.logError('PUT', `${BASE_URL}/item-master/fields/${id}`, error as Error, undefined, startTime);
        throw error;
      }
    },

    /**
     * 필드 삭제
     * DELETE /v1/item-master/fields/{id}
     */
    delete: async (id: number): Promise<ApiResponse<void>> => {
      const startTime = apiLogger.logRequest('DELETE', `${BASE_URL}/item-master/fields/${id}`);

      try {
        const headers = getAuthHeaders();
        const response = await fetch(`${BASE_URL}/item-master/fields/${id}`, {
          method: 'DELETE',
          headers,
        });

        if (!response.ok) {
          await handleApiError(response);
        }

        const result: ApiResponse<void> = await response.json();
        apiLogger.logResponse('DELETE', `${BASE_URL}/item-master/fields/${id}`, response.status, result, startTime);

        return result;
      } catch (error) {
        if (error instanceof TypeError) {
          apiLogger.logError('DELETE', `${BASE_URL}/item-master/fields/${id}`, error, undefined, startTime);
          throw new Error('네트워크 연결을 확인해주세요. 서버에 연결할 수 없습니다.');
        }

        apiLogger.logError('DELETE', `${BASE_URL}/item-master/fields/${id}`, error as Error, undefined, startTime);
        throw error;
      }
    },

    /**
     * 필드 순서 변경
     * PUT /v1/item-master/sections/{sectionId}/fields/reorder
     */
    reorder: async (sectionId: number, data: FieldReorderRequest): Promise<ApiResponse<ItemFieldResponse[]>> => {
      const startTime = apiLogger.logRequest('PUT', `${BASE_URL}/item-master/sections/${sectionId}/fields/reorder`, data);

      try {
        const headers = getAuthHeaders();
        const response = await fetch(`${BASE_URL}/item-master/sections/${sectionId}/fields/reorder`, {
          method: 'PUT',
          headers,
          body: JSON.stringify(data),
        });

        if (!response.ok) {
          await handleApiError(response);
        }

        const result: ApiResponse<ItemFieldResponse[]> = await response.json();
        apiLogger.logResponse('PUT', `${BASE_URL}/item-master/sections/${sectionId}/fields/reorder`, response.status, result, startTime);

        return result;
      } catch (error) {
        if (error instanceof TypeError) {
          apiLogger.logError('PUT', `${BASE_URL}/item-master/sections/${sectionId}/fields/reorder`, error, undefined, startTime);
          throw new Error('네트워크 연결을 확인해주세요. 서버에 연결할 수 없습니다.');
        }

        apiLogger.logError('PUT', `${BASE_URL}/item-master/sections/${sectionId}/fields/reorder`, error as Error, undefined, startTime);
        throw error;
      }
    },
  },

  // ============================================
  // BOM 관리
  // ============================================
  bomItems: {
    /**
     * BOM 항목 생성
     * POST /v1/item-master/sections/{sectionId}/bom-items
     */
    create: async (sectionId: number, data: BomItemRequest): Promise<ApiResponse<BomItemResponse>> => {
      const startTime = apiLogger.logRequest('POST', `${BASE_URL}/item-master/sections/${sectionId}/bom-items`, data);

      try {
        const headers = getAuthHeaders();
        const response = await fetch(`${BASE_URL}/item-master/sections/${sectionId}/bom-items`, {
          method: 'POST',
          headers,
          body: JSON.stringify(data),
        });

        if (!response.ok) {
          await handleApiError(response);
        }

        const result: ApiResponse<BomItemResponse> = await response.json();
        apiLogger.logResponse('POST', `${BASE_URL}/item-master/sections/${sectionId}/bom-items`, response.status, result, startTime);

        return result;
      } catch (error) {
        if (error instanceof TypeError) {
          apiLogger.logError('POST', `${BASE_URL}/item-master/sections/${sectionId}/bom-items`, error, undefined, startTime);
          throw new Error('네트워크 연결을 확인해주세요. 서버에 연결할 수 없습니다.');
        }

        apiLogger.logError('POST', `${BASE_URL}/item-master/sections/${sectionId}/bom-items`, error as Error, undefined, startTime);
        throw error;
      }
    },

    /**
     * BOM 항목 수정
     * PUT /v1/item-master/bom-items/{id}
     */
    update: async (id: number, data: Partial<BomItemRequest>): Promise<ApiResponse<BomItemResponse>> => {
      const startTime = apiLogger.logRequest('PUT', `${BASE_URL}/item-master/bom-items/${id}`, data);

      try {
        const headers = getAuthHeaders();
        const response = await fetch(`${BASE_URL}/item-master/bom-items/${id}`, {
          method: 'PUT',
          headers,
          body: JSON.stringify(data),
        });

        if (!response.ok) {
          await handleApiError(response);
        }

        const result: ApiResponse<BomItemResponse> = await response.json();
        apiLogger.logResponse('PUT', `${BASE_URL}/item-master/bom-items/${id}`, response.status, result, startTime);

        return result;
      } catch (error) {
        if (error instanceof TypeError) {
          apiLogger.logError('PUT', `${BASE_URL}/item-master/bom-items/${id}`, error, undefined, startTime);
          throw new Error('네트워크 연결을 확인해주세요. 서버에 연결할 수 없습니다.');
        }

        apiLogger.logError('PUT', `${BASE_URL}/item-master/bom-items/${id}`, error as Error, undefined, startTime);
        throw error;
      }
    },

    /**
     * BOM 항목 삭제
     * DELETE /v1/item-master/bom-items/{id}
     */
    delete: async (id: number): Promise<ApiResponse<void>> => {
      const startTime = apiLogger.logRequest('DELETE', `${BASE_URL}/item-master/bom-items/${id}`);

      try {
        const headers = getAuthHeaders();
        const response = await fetch(`${BASE_URL}/item-master/bom-items/${id}`, {
          method: 'DELETE',
          headers,
        });

        if (!response.ok) {
          await handleApiError(response);
        }

        const result: ApiResponse<void> = await response.json();
        apiLogger.logResponse('DELETE', `${BASE_URL}/item-master/bom-items/${id}`, response.status, result, startTime);

        return result;
      } catch (error) {
        if (error instanceof TypeError) {
          apiLogger.logError('DELETE', `${BASE_URL}/item-master/bom-items/${id}`, error, undefined, startTime);
          throw new Error('네트워크 연결을 확인해주세요. 서버에 연결할 수 없습니다.');
        }

        apiLogger.logError('DELETE', `${BASE_URL}/item-master/bom-items/${id}`, error as Error, undefined, startTime);
        throw error;
      }
    },
  },

  // ============================================
  // 섹션 템플릿
  // ============================================
  templates: {
    /**
     * 템플릿 목록 조회
     * GET /v1/item-master/section-templates
     * Note: init API에 포함되므로 일반적으로 직접 호출 불필요
     */
    list: async (): Promise<ApiResponse<SectionTemplateResponse[]>> => {
      const startTime = apiLogger.logRequest('GET', `${BASE_URL}/item-master/section-templates`);

      try {
        const headers = getAuthHeaders();
        const response = await fetch(`${BASE_URL}/item-master/section-templates`, {
          method: 'GET',
          headers,
        });

        if (!response.ok) {
          await handleApiError(response);
        }

        const result: ApiResponse<SectionTemplateResponse[]> = await response.json();
        apiLogger.logResponse('GET', `${BASE_URL}/item-master/section-templates`, response.status, result, startTime);

        return result;
      } catch (error) {
        if (error instanceof TypeError) {
          apiLogger.logError('GET', `${BASE_URL}/item-master/section-templates`, error, undefined, startTime);
          throw new Error('네트워크 연결을 확인해주세요. 서버에 연결할 수 없습니다.');
        }

        apiLogger.logError('GET', `${BASE_URL}/item-master/section-templates`, error as Error, undefined, startTime);
        throw error;
      }
    },

    /**
     * 템플릿 생성
     * POST /v1/item-master/section-templates
     */
    create: async (data: SectionTemplateRequest): Promise<ApiResponse<SectionTemplateResponse>> => {
      const startTime = apiLogger.logRequest('POST', `${BASE_URL}/item-master/section-templates`, data);

      try {
        const headers = getAuthHeaders();
        const response = await fetch(`${BASE_URL}/item-master/section-templates`, {
          method: 'POST',
          headers,
          body: JSON.stringify(data),
        });

        if (!response.ok) {
          await handleApiError(response);
        }

        const result: ApiResponse<SectionTemplateResponse> = await response.json();
        apiLogger.logResponse('POST', `${BASE_URL}/item-master/section-templates`, response.status, result, startTime);

        return result;
      } catch (error) {
        if (error instanceof TypeError) {
          apiLogger.logError('POST', `${BASE_URL}/item-master/section-templates`, error, undefined, startTime);
          throw new Error('네트워크 연결을 확인해주세요. 서버에 연결할 수 없습니다.');
        }

        apiLogger.logError('POST', `${BASE_URL}/item-master/section-templates`, error as Error, undefined, startTime);
        throw error;
      }
    },

    /**
     * 템플릿 수정
     * PUT /v1/item-master/section-templates/{id}
     */
    update: async (id: number, data: Partial<SectionTemplateRequest>): Promise<ApiResponse<SectionTemplateResponse>> => {
      const startTime = apiLogger.logRequest('PUT', `${BASE_URL}/item-master/section-templates/${id}`, data);

      try {
        const headers = getAuthHeaders();
        const response = await fetch(`${BASE_URL}/item-master/section-templates/${id}`, {
          method: 'PUT',
          headers,
          body: JSON.stringify(data),
        });

        if (!response.ok) {
          await handleApiError(response);
        }

        const result: ApiResponse<SectionTemplateResponse> = await response.json();
        apiLogger.logResponse('PUT', `${BASE_URL}/item-master/section-templates/${id}`, response.status, result, startTime);

        return result;
      } catch (error) {
        if (error instanceof TypeError) {
          apiLogger.logError('PUT', `${BASE_URL}/item-master/section-templates/${id}`, error, undefined, startTime);
          throw new Error('네트워크 연결을 확인해주세요. 서버에 연결할 수 없습니다.');
        }

        apiLogger.logError('PUT', `${BASE_URL}/item-master/section-templates/${id}`, error as Error, undefined, startTime);
        throw error;
      }
    },

    /**
     * 템플릿 삭제
     * DELETE /v1/item-master/section-templates/{id}
     */
    delete: async (id: number): Promise<ApiResponse<void>> => {
      const startTime = apiLogger.logRequest('DELETE', `${BASE_URL}/item-master/section-templates/${id}`);

      try {
        const headers = getAuthHeaders();
        const response = await fetch(`${BASE_URL}/item-master/section-templates/${id}`, {
          method: 'DELETE',
          headers,
        });

        if (!response.ok) {
          await handleApiError(response);
        }

        const result: ApiResponse<void> = await response.json();
        apiLogger.logResponse('DELETE', `${BASE_URL}/item-master/section-templates/${id}`, response.status, result, startTime);

        return result;
      } catch (error) {
        if (error instanceof TypeError) {
          apiLogger.logError('DELETE', `${BASE_URL}/item-master/section-templates/${id}`, error, undefined, startTime);
          throw new Error('네트워크 연결을 확인해주세요. 서버에 연결할 수 없습니다.');
        }

        apiLogger.logError('DELETE', `${BASE_URL}/item-master/section-templates/${id}`, error as Error, undefined, startTime);
        throw error;
      }
    },
  },

  // ============================================
  // 마스터 필드
  // ============================================
  masterFields: {
    /**
     * 마스터 필드 목록 조회
     * GET /v1/item-master/master-fields
     * Note: init API에 포함되므로 일반적으로 직접 호출 불필요
     */
    list: async (): Promise<ApiResponse<MasterFieldResponse[]>> => {
      const startTime = apiLogger.logRequest('GET', `${BASE_URL}/item-master/master-fields`);

      try {
        const headers = getAuthHeaders();
        const response = await fetch(`${BASE_URL}/item-master/master-fields`, {
          method: 'GET',
          headers,
        });

        if (!response.ok) {
          await handleApiError(response);
        }

        const result: ApiResponse<MasterFieldResponse[]> = await response.json();
        apiLogger.logResponse('GET', `${BASE_URL}/item-master/master-fields`, response.status, result, startTime);

        return result;
      } catch (error) {
        if (error instanceof TypeError) {
          apiLogger.logError('GET', `${BASE_URL}/item-master/master-fields`, error, undefined, startTime);
          throw new Error('네트워크 연결을 확인해주세요. 서버에 연결할 수 없습니다.');
        }

        apiLogger.logError('GET', `${BASE_URL}/item-master/master-fields`, error as Error, undefined, startTime);
        throw error;
      }
    },

    /**
     * 마스터 필드 생성
     * POST /v1/item-master/master-fields
     */
    create: async (data: MasterFieldRequest): Promise<ApiResponse<MasterFieldResponse>> => {
      const startTime = apiLogger.logRequest('POST', `${BASE_URL}/item-master/master-fields`, data);

      try {
        const headers = getAuthHeaders();
        const response = await fetch(`${BASE_URL}/item-master/master-fields`, {
          method: 'POST',
          headers,
          body: JSON.stringify(data),
        });

        if (!response.ok) {
          await handleApiError(response);
        }

        const result: ApiResponse<MasterFieldResponse> = await response.json();
        apiLogger.logResponse('POST', `${BASE_URL}/item-master/master-fields`, response.status, result, startTime);

        return result;
      } catch (error) {
        if (error instanceof TypeError) {
          apiLogger.logError('POST', `${BASE_URL}/item-master/master-fields`, error, undefined, startTime);
          throw new Error('네트워크 연결을 확인해주세요. 서버에 연결할 수 없습니다.');
        }

        apiLogger.logError('POST', `${BASE_URL}/item-master/master-fields`, error as Error, undefined, startTime);
        throw error;
      }
    },

    /**
     * 마스터 필드 수정
     * PUT /v1/item-master/master-fields/{id}
     */
    update: async (id: number, data: Partial<MasterFieldRequest>): Promise<ApiResponse<MasterFieldResponse>> => {
      const startTime = apiLogger.logRequest('PUT', `${BASE_URL}/item-master/master-fields/${id}`, data);

      try {
        const headers = getAuthHeaders();
        const response = await fetch(`${BASE_URL}/item-master/master-fields/${id}`, {
          method: 'PUT',
          headers,
          body: JSON.stringify(data),
        });

        if (!response.ok) {
          await handleApiError(response);
        }

        const result: ApiResponse<MasterFieldResponse> = await response.json();
        apiLogger.logResponse('PUT', `${BASE_URL}/item-master/master-fields/${id}`, response.status, result, startTime);

        return result;
      } catch (error) {
        if (error instanceof TypeError) {
          apiLogger.logError('PUT', `${BASE_URL}/item-master/master-fields/${id}`, error, undefined, startTime);
          throw new Error('네트워크 연결을 확인해주세요. 서버에 연결할 수 없습니다.');
        }

        apiLogger.logError('PUT', `${BASE_URL}/item-master/master-fields/${id}`, error as Error, undefined, startTime);
        throw error;
      }
    },

    /**
     * 마스터 필드 삭제
     * DELETE /v1/item-master/master-fields/{id}
     */
    delete: async (id: number): Promise<ApiResponse<void>> => {
      const startTime = apiLogger.logRequest('DELETE', `${BASE_URL}/item-master/master-fields/${id}`);

      try {
        const headers = getAuthHeaders();
        const response = await fetch(`${BASE_URL}/item-master/master-fields/${id}`, {
          method: 'DELETE',
          headers,
        });

        if (!response.ok) {
          await handleApiError(response);
        }

        const result: ApiResponse<void> = await response.json();
        apiLogger.logResponse('DELETE', `${BASE_URL}/item-master/master-fields/${id}`, response.status, result, startTime);

        return result;
      } catch (error) {
        if (error instanceof TypeError) {
          apiLogger.logError('DELETE', `${BASE_URL}/item-master/master-fields/${id}`, error, undefined, startTime);
          throw new Error('네트워크 연결을 확인해주세요. 서버에 연결할 수 없습니다.');
        }

        apiLogger.logError('DELETE', `${BASE_URL}/item-master/master-fields/${id}`, error as Error, undefined, startTime);
        throw error;
      }
    },
  },

  // ============================================
  // 커스텀 탭
  // ============================================
  customTabs: {
    /**
     * 커스텀 탭 목록 조회
     * GET /v1/item-master/custom-tabs
     * Note: init API에 포함되므로 일반적으로 직접 호출 불필요
     */
    list: async (): Promise<ApiResponse<CustomTabResponse[]>> => {
      const startTime = apiLogger.logRequest('GET', `${BASE_URL}/item-master/custom-tabs`);

      try {
        const headers = getAuthHeaders();
        const response = await fetch(`${BASE_URL}/item-master/custom-tabs`, {
          method: 'GET',
          headers,
        });

        if (!response.ok) {
          await handleApiError(response);
        }

        const result: ApiResponse<CustomTabResponse[]> = await response.json();
        apiLogger.logResponse('GET', `${BASE_URL}/item-master/custom-tabs`, response.status, result, startTime);

        return result;
      } catch (error) {
        if (error instanceof TypeError) {
          apiLogger.logError('GET', `${BASE_URL}/item-master/custom-tabs`, error, undefined, startTime);
          throw new Error('네트워크 연결을 확인해주세요. 서버에 연결할 수 없습니다.');
        }

        apiLogger.logError('GET', `${BASE_URL}/item-master/custom-tabs`, error as Error, undefined, startTime);
        throw error;
      }
    },

    /**
     * 커스텀 탭 생성
     * POST /v1/item-master/custom-tabs
     */
    create: async (data: CustomTabRequest): Promise<ApiResponse<CustomTabResponse>> => {
      const startTime = apiLogger.logRequest('POST', `${BASE_URL}/item-master/custom-tabs`, data);

      try {
        const headers = getAuthHeaders();
        const response = await fetch(`${BASE_URL}/item-master/custom-tabs`, {
          method: 'POST',
          headers,
          body: JSON.stringify(data),
        });

        if (!response.ok) {
          await handleApiError(response);
        }

        const result: ApiResponse<CustomTabResponse> = await response.json();
        apiLogger.logResponse('POST', `${BASE_URL}/item-master/custom-tabs`, response.status, result, startTime);

        return result;
      } catch (error) {
        if (error instanceof TypeError) {
          apiLogger.logError('POST', `${BASE_URL}/item-master/custom-tabs`, error, undefined, startTime);
          throw new Error('네트워크 연결을 확인해주세요. 서버에 연결할 수 없습니다.');
        }

        apiLogger.logError('POST', `${BASE_URL}/item-master/custom-tabs`, error as Error, undefined, startTime);
        throw error;
      }
    },

    /**
     * 커스텀 탭 수정
     * PUT /v1/item-master/custom-tabs/{id}
     */
    update: async (id: number, data: Partial<CustomTabRequest>): Promise<ApiResponse<CustomTabResponse>> => {
      const startTime = apiLogger.logRequest('PUT', `${BASE_URL}/item-master/custom-tabs/${id}`, data);

      try {
        const headers = getAuthHeaders();
        const response = await fetch(`${BASE_URL}/item-master/custom-tabs/${id}`, {
          method: 'PUT',
          headers,
          body: JSON.stringify(data),
        });

        if (!response.ok) {
          await handleApiError(response);
        }

        const result: ApiResponse<CustomTabResponse> = await response.json();
        apiLogger.logResponse('PUT', `${BASE_URL}/item-master/custom-tabs/${id}`, response.status, result, startTime);

        return result;
      } catch (error) {
        if (error instanceof TypeError) {
          apiLogger.logError('PUT', `${BASE_URL}/item-master/custom-tabs/${id}`, error, undefined, startTime);
          throw new Error('네트워크 연결을 확인해주세요. 서버에 연결할 수 없습니다.');
        }

        apiLogger.logError('PUT', `${BASE_URL}/item-master/custom-tabs/${id}`, error as Error, undefined, startTime);
        throw error;
      }
    },

    /**
     * 커스텀 탭 삭제
     * DELETE /v1/item-master/custom-tabs/{id}
     */
    delete: async (id: number): Promise<ApiResponse<void>> => {
      const startTime = apiLogger.logRequest('DELETE', `${BASE_URL}/item-master/custom-tabs/${id}`);

      try {
        const headers = getAuthHeaders();
        const response = await fetch(`${BASE_URL}/item-master/custom-tabs/${id}`, {
          method: 'DELETE',
          headers,
        });

        if (!response.ok) {
          await handleApiError(response);
        }

        const result: ApiResponse<void> = await response.json();
        apiLogger.logResponse('DELETE', `${BASE_URL}/item-master/custom-tabs/${id}`, response.status, result, startTime);

        return result;
      } catch (error) {
        if (error instanceof TypeError) {
          apiLogger.logError('DELETE', `${BASE_URL}/item-master/custom-tabs/${id}`, error, undefined, startTime);
          throw new Error('네트워크 연결을 확인해주세요. 서버에 연결할 수 없습니다.');
        }

        apiLogger.logError('DELETE', `${BASE_URL}/item-master/custom-tabs/${id}`, error as Error, undefined, startTime);
        throw error;
      }
    },

    /**
     * 탭 순서 변경
     * PUT /v1/item-master/custom-tabs/reorder
     */
    reorder: async (data: TabReorderRequest): Promise<ApiResponse<void>> => {
      const startTime = apiLogger.logRequest('PUT', `${BASE_URL}/item-master/custom-tabs/reorder`, data);

      try {
        const headers = getAuthHeaders();
        const response = await fetch(`${BASE_URL}/item-master/custom-tabs/reorder`, {
          method: 'PUT',
          headers,
          body: JSON.stringify(data),
        });

        if (!response.ok) {
          await handleApiError(response);
        }

        const result: ApiResponse<void> = await response.json();
        apiLogger.logResponse('PUT', `${BASE_URL}/item-master/custom-tabs/reorder`, response.status, result, startTime);

        return result;
      } catch (error) {
        if (error instanceof TypeError) {
          apiLogger.logError('PUT', `${BASE_URL}/item-master/custom-tabs/reorder`, error, undefined, startTime);
          throw new Error('네트워크 연결을 확인해주세요. 서버에 연결할 수 없습니다.');
        }

        apiLogger.logError('PUT', `${BASE_URL}/item-master/custom-tabs/reorder`, error as Error, undefined, startTime);
        throw error;
      }
    },

    /**
     * 탭별 컬럼 설정
     * PUT /v1/item-master/custom-tabs/{id}/columns
     */
    updateColumns: async (id: number, data: TabColumnUpdateRequest): Promise<ApiResponse<Record<string, any>>> => {
      const startTime = apiLogger.logRequest('PUT', `${BASE_URL}/item-master/custom-tabs/${id}/columns`, data);

      try {
        const headers = getAuthHeaders();
        const response = await fetch(`${BASE_URL}/item-master/custom-tabs/${id}/columns`, {
          method: 'PUT',
          headers,
          body: JSON.stringify(data),
        });

        if (!response.ok) {
          await handleApiError(response);
        }

        const result: ApiResponse<Record<string, any>> = await response.json();
        apiLogger.logResponse('PUT', `${BASE_URL}/item-master/custom-tabs/${id}/columns`, response.status, result, startTime);

        return result;
      } catch (error) {
        if (error instanceof TypeError) {
          apiLogger.logError('PUT', `${BASE_URL}/item-master/custom-tabs/${id}/columns`, error, undefined, startTime);
          throw new Error('네트워크 연결을 확인해주세요. 서버에 연결할 수 없습니다.');
        }

        apiLogger.logError('PUT', `${BASE_URL}/item-master/custom-tabs/${id}/columns`, error as Error, undefined, startTime);
        throw error;
      }
    },
  },

  // ============================================
  // 단위 옵션
  // ============================================
  units: {
    list: async (): Promise<ApiResponse<UnitOptionResponse[]>> => {
      const startTime = apiLogger.logRequest('GET', `${BASE_URL}/item-master/unit-options`);

      try {
        const headers = getAuthHeaders();
        const response = await fetch(`${BASE_URL}/item-master/unit-options`, {
          method: 'GET',
          headers,
        });

        if (!response.ok) {
          await handleApiError(response);
        }

        const result: ApiResponse<UnitOptionResponse[]> = await response.json();
        apiLogger.logResponse('GET', `${BASE_URL}/item-master/unit-options`, response.status, result, startTime);

        return result;
      } catch (error) {
        if (error instanceof TypeError) {
          apiLogger.logError('GET', `${BASE_URL}/item-master/unit-options`, error, undefined, startTime);
          throw new Error('네트워크 연결을 확인해주세요. 서버에 연결할 수 없습니다.');
        }

        apiLogger.logError('GET', `${BASE_URL}/item-master/unit-options`, error as Error, undefined, startTime);
        throw error;
      }
    },

    create: async (data: UnitOptionRequest): Promise<ApiResponse<UnitOptionResponse>> => {
      const startTime = apiLogger.logRequest('POST', `${BASE_URL}/item-master/unit-options`, data);

      try {
        const headers = getAuthHeaders();
        const response = await fetch(`${BASE_URL}/item-master/unit-options`, {
          method: 'POST',
          headers,
          body: JSON.stringify(data),
        });

        if (!response.ok) {
          await handleApiError(response);
        }

        const result: ApiResponse<UnitOptionResponse> = await response.json();
        apiLogger.logResponse('POST', `${BASE_URL}/item-master/unit-options`, response.status, result, startTime);

        return result;
      } catch (error) {
        if (error instanceof TypeError) {
          apiLogger.logError('POST', `${BASE_URL}/item-master/unit-options`, error, undefined, startTime);
          throw new Error('네트워크 연결을 확인해주세요. 서버에 연결할 수 없습니다.');
        }

        apiLogger.logError('POST', `${BASE_URL}/item-master/unit-options`, error as Error, undefined, startTime);
        throw error;
      }
    },

    delete: async (id: number): Promise<ApiResponse<void>> => {
      const startTime = apiLogger.logRequest('DELETE', `${BASE_URL}/item-master/unit-options/${id}`);

      try {
        const headers = getAuthHeaders();
        const response = await fetch(`${BASE_URL}/item-master/unit-options/${id}`, {
          method: 'DELETE',
          headers,
        });

        if (!response.ok) {
          await handleApiError(response);
        }

        const result: ApiResponse<void> = await response.json();
        apiLogger.logResponse('DELETE', `${BASE_URL}/item-master/unit-options/${id}`, response.status, result, startTime);

        return result;
      } catch (error) {
        if (error instanceof TypeError) {
          apiLogger.logError('DELETE', `${BASE_URL}/item-master/unit-options/${id}`, error, undefined, startTime);
          throw new Error('네트워크 연결을 확인해주세요. 서버에 연결할 수 없습니다.');
        }

        apiLogger.logError('DELETE', `${BASE_URL}/item-master/unit-options/${id}`, error as Error, undefined, startTime);
        throw error;
      }
    },
  },
};