/**
 * 작업지시 관리 타입 정의
 */

import { formatDate } from '@/lib/utils/date';

// 공정 정보 (API 관계)
export interface ProcessInfo {
  id: number;
  process_code: string;
  process_name: string;
}

// @deprecated process_type은 process_id FK로 변경됨
// 하위 호환성을 위해 유지
export type ProcessType = 'screen' | 'slat' | 'bending' | 'bending_wip';

export const PROCESS_TYPE_LABELS: Record<ProcessType, string> = {
  screen: '스크린',
  slat: '슬랫',
  bending: '절곡',
  bending_wip: '절곡 재공품',
};

// 작업 상태
export type WorkOrderStatus =
  | 'unassigned'    // 미배정
  | 'pending'       // 승인대기
  | 'waiting'       // 작업대기
  | 'in_progress'   // 작업중
  | 'completed'     // 작업완료
  | 'shipped';      // 출하완료

export const WORK_ORDER_STATUS_LABELS: Record<WorkOrderStatus, string> = {
  unassigned: '미배정',
  pending: '승인대기',
  waiting: '작업대기',
  in_progress: '작업중',
  completed: '작업완료',
  shipped: '출하완료',
};

export const WORK_ORDER_STATUS_COLORS: Record<WorkOrderStatus, string> = {
  unassigned: 'bg-gray-100 text-gray-700',
  pending: 'bg-yellow-100 text-yellow-700',
  waiting: 'bg-blue-100 text-blue-700',
  in_progress: 'bg-green-100 text-green-700',
  completed: 'bg-purple-100 text-purple-700',
  shipped: 'bg-slate-100 text-slate-700',
};

// 스크린 공정 단계
export type ScreenProcessStep =
  | 'cutting'       // 원단절단
  | 'sewing'        // 미싱
  | 'endlock'       // 앤드락작업
  | 'inspection'    // 중간검사
  | 'packing';      // 포장

export const SCREEN_PROCESS_STEPS: { key: ScreenProcessStep; label: string; order: number }[] = [
  { key: 'cutting', label: '원단절단', order: 1 },
  { key: 'sewing', label: '미싱', order: 2 },
  { key: 'endlock', label: '앤드락작업', order: 3 },
  { key: 'inspection', label: '중간검사', order: 4 },
  { key: 'packing', label: '포장', order: 5 },
];

// 슬랫 공정 단계
export type SlatProcessStep =
  | 'coil_cutting'  // 코일절단
  | 'forming'       // 성형
  | 'finishing'     // 미미작업
  | 'inspection'    // 검사
  | 'packing';      // 포장

export const SLAT_PROCESS_STEPS: { key: SlatProcessStep; label: string; order: number }[] = [
  { key: 'coil_cutting', label: '코일절단', order: 1 },
  { key: 'forming', label: '성형', order: 2 },
  { key: 'finishing', label: '미미작업', order: 3 },
  { key: 'inspection', label: '검사', order: 4 },
  { key: 'packing', label: '포장', order: 5 },
];

// 절곡 공정 단계
export type BendingProcessStep =
  | 'guide_rail'    // 가이드레일 제작
  | 'case'          // 케이스 제작
  | 'bottom_finish' // 하단마감재 제작
  | 'inspection';   // 검사

export const BENDING_PROCESS_STEPS: { key: BendingProcessStep; label: string; order: number }[] = [
  { key: 'guide_rail', label: '가이드레일 제작', order: 1 },
  { key: 'case', label: '케이스 제작', order: 2 },
  { key: 'bottom_finish', label: '하단마감재 제작', order: 3 },
  { key: 'inspection', label: '검사', order: 4 },
];

// BD 코드 종류코드 → 필요 작업단계 매핑
export const BENDING_STEP_MAP: Record<string, BendingProcessStep[]> = {
  'R': ['guide_rail', 'inspection'],    // 가이드레일-벽면
  'S': ['guide_rail', 'inspection'],    // 가이드레일-측면
  'C': ['case', 'inspection'],          // 케이스
  'B': ['bottom_finish', 'inspection'], // 하단마감재-스크린
  'T': ['bottom_finish', 'inspection'], // 하단마감재-철재
  'L': ['guide_rail', 'inspection'],    // L-Bar
  'G': ['guide_rail', 'inspection'],    // 연기차단재
};

/**
 * BD 코드에서 종류코드 추출 (BD-{종류코드}{규격코드}-{길이코드})
 * 예: BD-RS-30 → 'R', BD-CF-35 → 'C'
 */
export function extractBendingTypeCode(itemCode: string): string | null {
  const match = itemCode.match(/^BD-([A-Z])/);
  return match ? match[1] : null;
}

/**
 * 작업지시 품목들의 BD 코드로 필요한 작업단계 필터링
 * 여러 품목이면 합집합(union), BD 코드 아닌 품목이면 전체 반환
 */
export function filterBendingSteps(
  itemCodes: string[],
  allSteps: typeof BENDING_PROCESS_STEPS
): typeof BENDING_PROCESS_STEPS {
  if (!itemCodes.length) return allSteps;

  const neededKeys = new Set<string>();
  let hasNonBdItem = false;

  for (const code of itemCodes) {
    const typeCode = extractBendingTypeCode(code);
    if (typeCode && BENDING_STEP_MAP[typeCode]) {
      BENDING_STEP_MAP[typeCode].forEach((k) => neededKeys.add(k));
    } else {
      hasNonBdItem = true;
    }
  }

  // BD 코드가 아닌 품목이 있거나 매핑 결과가 없으면 전체 반환
  if (hasNonBdItem || neededKeys.size === 0) return allSteps;

  return allSteps.filter((step) => neededKeys.has(step.key));
}

// 품목 상태
export type ItemStatus = 'waiting' | 'in_progress' | 'completed';

export const ITEM_STATUS_LABELS: Record<ItemStatus, string> = {
  waiting: '대기',
  in_progress: '작업중',
  completed: '완료',
};

// 작업 품목
export interface WorkOrderItem {
  id: string;
  no: number;
  status: ItemStatus;
  itemCode: string;
  productName: string;
  floorCode: string;    // 층/부호
  specification: string; // 규격
  width?: number;        // 제작사이즈 가로 (mm) - options JSON
  height?: number;       // 제작사이즈 세로 (mm) - options JSON
  quantity: number;
  unit: string;          // 단위
  orderNodeId: number | null;    // 개소 ID
  orderNodeName: string;         // 개소명
  slatInfo?: { length: number; slatCount: number; jointBar: number; glassQty: number };  // 슬랫 공정 정보
  bendingInfo?: Record<string, unknown>;  // 절곡 공정 정보 (bending_info JSON)
  materialInputLots?: string[];  // 개소별 투입자재 LOT 번호 목록
}

// 전개도 상세 (절곡용)
export interface BendingDetail {
  id: string;
  code: string;         // SD30, SD31 등
  name: string;         // 엘바, 하장바 등
  material: string;     // E.G.I 1.6T 등
  quantity: number;     // 수량
  developWidth: string; // 전개폭
  length: string;       // 길이
  weight: string;       // 중량
  note: string;         // 비고
  developDimension: string; // 전개치수
  imageUrl?: string;    // 전개도 이미지
}

// 이슈
export interface WorkOrderIssue {
  id: string;
  status: 'pending' | 'processing' | 'resolved';
  type: string;         // 불량품발생 등
  description: string;  // 상세 설명
  createdAt: string;
}

export const ISSUE_STATUS_LABELS: Record<WorkOrderIssue['status'], string> = {
  pending: '대기중',
  processing: '처리중',
  resolved: '해결됨',
};

// 공정 단계 타입
export interface ProcessStep {
  key: string;
  label: string;
  order: number;
}

// 작업지시 메인 타입
export interface WorkOrder {
  id: string;
  workOrderNo: string;      // 작업지시번호 (KD-WO-251217-12)
  lotNo: string;            // 로트번호 (KD-TS-251217-10)
  processId: number;        // 공정 ID (FK)
  processName: string;      // 공정명 (표시용)
  processCode: string;      // 공정코드 (표시용)
  workSteps?: ProcessStep[];  // 공정 단계 (동적, DB에서 로드)
  /** @deprecated process_id FK 사용 */
  processType: ProcessType; // 하위 호환용
  status: WorkOrderStatus;  // 작업상태

  // 기본 정보
  client: string;           // 발주처
  projectName: string;      // 현장명
  dueDate: string;          // 납기일
  assignee: string;         // 작업자 (주 담당자)
  assignees?: { id: string; name: string; isPrimary: boolean }[]; // 다중 담당자

  // 날짜 정보
  orderDate: string;        // 지시일
  scheduledDate: string;    // 예정일 (API: scheduled_date)
  shipmentDate: string;     // 출고예정일

  // 플래그
  isAssigned: boolean;      // 배정 여부
  isStarted: boolean;       // 시작 여부

  // 우선순위
  priority: number;         // 1~9 (1=긴급, 9=낮음)
  priorityLabel: string;    // 우선순위 라벨 (긴급/우선/일반)

  // 수주 관련
  salesOrderDate: string;   // 수주일
  salesOrderWriter?: string; // 수주 담당자
  clientContact?: string;   // 담당자 연락처
  shutterCount: number | null; // 틀수
  department: string;       // 부서명

  // 품목
  items: WorkOrderItem[];

  // 공정 진행 상태 (현재 단계)
  currentStep: number;

  // 절곡 전용
  bendingInfo?: Record<string, unknown>;  // 작업지시 레벨 bending_info (work_orders.options)
  bendingDetails?: BendingDetail[];

  // 이슈
  issues?: WorkOrderIssue[];

  // 비고
  note?: string;
}

// 수주 정보 (모달용)
export interface SalesOrder {
  id: string;
  orderNo: string;          // KD-TS-251201-01
  status: string;           // 생산지시완료 등
  client: string;           // 삼성물산(주)
  projectName: string;      // 삼성물산 레미안 강남 1차
  dueDate: string;          // 납기
  itemCount: number;        // 품목수
  splitCount: number;       // 분할건
}

// 리스트 필터
export interface WorkOrderFilter {
  search: string;
  status: WorkOrderStatus | 'all';
  processType: ProcessType | 'all';
}

// 통계
export interface WorkOrderStats {
  total: number;
  unassigned: number;
  pending: number;
  waiting: number;
  inProgress: number;
  completed: number;
  /** 공정별 카운트 (key: process_id 또는 'none', value: count) */
  byProcess: Record<string, number>;
}

// ===== API 타입 정의 =====

// API 응답 - 작업지시 품목
export interface WorkOrderItemApi {
  id: number;
  work_order_id: number;
  item_id: number | null;
  item?: { id: number; code: string } | null;
  item_name: string;
  specification: string | null;
  quantity: number;
  unit: string | null;
  sort_order: number;
  status: 'waiting' | 'in_progress' | 'completed';
  options?: Record<string, unknown> | null;
  created_at: string;
  updated_at: string;
  source_order_item?: {
    id: number;
    order_node_id: number | null;
    floor_code?: string | null;
    symbol_code?: string | null;
    node?: {
      id: number;
      name: string;
      code: string;
    } | null;
  } | null;
  material_inputs?: Array<{
    id: number;
    stock_lot_id: number;
    item_id: number;
    qty: number;
    stock_lot?: { id: number; lot_no: string };
  }>;
}

// API 응답 - 벤딩 상세
export interface WorkOrderBendingDetailApi {
  id: number;
  work_order_id: number;
  shaft_cutting: boolean;
  bearing: boolean;
  shaft_welding: boolean;
  assembly: boolean;
  winder_welding: boolean;
  frame_assembly: boolean;
  bundle_assembly: boolean;
  motor_assembly: boolean;
  bracket_assembly: boolean;
  created_at: string;
  updated_at: string;
}

// API 응답 - 담당자 (다중 담당자)
export interface WorkOrderAssigneeApi {
  id: number;
  work_order_id: number;
  user_id: number;
  is_primary: boolean;
  created_at: string;
  updated_at: string;
  user?: { id: number; name: string };
}

// API 응답 - 이슈
export interface WorkOrderIssueApi {
  id: number;
  work_order_id: number;
  title: string;
  description: string | null;
  priority: 'low' | 'medium' | 'high';
  is_resolved: boolean;
  resolved_at: string | null;
  resolved_by: number | null;
  created_by: number | null;
  created_at: string;
  updated_at: string;
}

// API 응답 - 작업지시
export interface WorkOrderApi {
  id: number;
  tenant_id: number;
  work_order_no: string;
  sales_order_id: number | null;
  project_name: string | null;
  process_id: number;  // FK to processes.id
  status: 'unassigned' | 'pending' | 'waiting' | 'in_progress' | 'completed' | 'shipped';
  assignee_id: number | null;
  team_id: number | null;
  scheduled_date: string | null;
  memo: string | null;
  options?: { bending_info?: Record<string, unknown>; [key: string]: unknown } | null;
  is_active: boolean;
  created_by: number | null;
  updated_by: number | null;
  created_at: string;
  updated_at: string;
  deleted_at: string | null;
  // Relations
  priority: number | null;
  sales_order?: {
    id: number;
    order_no: string;
    order_date?: string;
    site_name?: string;
    client_contact?: string;
    received_at?: string;
    created_at?: string;
    quantity?: number;
    root_nodes_count?: number;
    options?: { manager_name?: string; [key: string]: unknown };
    client?: { id: number; name: string };
    writer?: { id: number; name: string };
  };
  process?: {
    id: number;
    process_code: string;
    process_name: string;
    department?: string;
    work_steps?: string[] | { key: string; label: string; order: number }[];
  };
  assignee?: { id: number; name: string };
  assignees?: WorkOrderAssigneeApi[];
  team?: { id: number; name: string };
  items?: WorkOrderItemApi[];
  bending_detail?: WorkOrderBendingDetailApi;
  issues?: WorkOrderIssueApi[];
}

// API 페이징 응답
export interface WorkOrderApiPaginatedResponse {
  data: WorkOrderApi[];
  current_page: number;
  last_page: number;
  per_page: number;
  total: number;
}

// API 통계 응답
export interface WorkOrderStatsApi {
  total: number;
  unassigned: number;
  pending: number;
  waiting: number;
  in_progress: number;
  completed: number;
  shipped: number;
  by_process?: Record<string, number>;
}

// ===== 변환 함수 =====

// API → Frontend 변환
export function transformApiToFrontend(api: WorkOrderApi): WorkOrder {
  // 다중 담당자 변환
  const assignees = (api.assignees || []).map(a => ({
    id: String(a.user_id),
    name: a.user?.name || '-',
    isPrimary: a.is_primary,
  }));

  // 주 담당자 이름 (기존 호환)
  const primaryAssignee = assignees.find(a => a.isPrimary);
  const assigneeName = primaryAssignee?.name || api.assignee?.name || '-';

  // 공정명 → 하위호환용 processType 매핑
  const processNameToType = (name: string): ProcessType => {
    const mapping: Record<string, ProcessType> = {
      '스크린': 'screen',
      '슬랫': 'slat',
      '절곡': 'bending',
    };
    return mapping[name] || 'screen';
  };

  // 우선순위 매핑 (1~3: 긴급, 4~6: 우선, 7~9: 일반)
  const priorityValue = api.priority ?? 5;
  const getPriorityLabel = (p: number): string => {
    if (p <= 3) return '긴급';
    if (p <= 6) return '우선';
    return '일반';
  };

  return {
    id: String(api.id),
    workOrderNo: api.work_order_no,
    lotNo: (api.sales_order?.options?.bending_lot as Record<string, unknown> | undefined)?.lot_number as string || api.sales_order?.order_no || '-',
    processId: api.process_id,
    processName: api.process?.process_name || '-',
    processCode: api.process?.process_code || '-',
    // work_steps: string[] 또는 ProcessStep[] 형식 모두 지원
    workSteps: api.process?.work_steps
      ? (api.process.work_steps as (string | { key: string; label: string; order: number })[]).map((step, idx) =>
          typeof step === 'string'
            ? { key: `step-${idx}`, label: step, order: idx + 1 }
            : step
        )
      : undefined,
    processType: processNameToType(api.process?.process_name || ''),  // 하위 호환
    status: api.status,
    client: api.sales_order?.client?.name || '-',
    projectName: api.sales_order?.site_name || api.project_name || '-',
    dueDate: api.scheduled_date || '-',
    assignee: assigneeName,
    assignees: assignees.length > 0 ? assignees : undefined,
    orderDate: formatDate(api.created_at),
    scheduledDate: api.scheduled_date || '',
    shipmentDate: api.scheduled_date || '-',
    isAssigned: api.assignee_id !== null || assignees.length > 0,
    isStarted: ['in_progress', 'completed', 'shipped'].includes(api.status),
    priority: priorityValue,
    priorityLabel: getPriorityLabel(priorityValue),
    salesOrderDate: api.sales_order?.received_at?.split('T')[0] || api.sales_order?.created_at?.split('T')[0] || formatDate(api.created_at),
    salesOrderWriter: api.sales_order?.options?.manager_name || api.sales_order?.writer?.name || '-',
    clientContact: api.sales_order?.client_contact || '-',
    shutterCount: api.sales_order?.root_nodes_count || null,
    department: api.process?.department || api.team?.name || '-',
    currentStep: getStatusStep(api.status),
    items: (api.items || []).map((item, idx) => ({
      id: String(item.id),
      no: idx + 1,
      status: (item.status as ItemStatus) || 'waiting',
      itemCode: item.item?.code || '',
      productName: item.item_name,
      floorCode: [item.source_order_item?.floor_code, item.source_order_item?.symbol_code].filter(Boolean).join('/') || '-',
      specification: item.specification || '-',
      width: typeof item.options?.width === 'number' ? item.options.width : undefined,
      height: typeof item.options?.height === 'number' ? item.options.height : undefined,
      quantity: item.quantity,
      unit: item.unit || '-',
      orderNodeId: item.source_order_item?.order_node_id ?? null,
      orderNodeName: item.source_order_item?.node?.name || '-',
      slatInfo: item.options?.slat_info ? (() => {
        const si = item.options.slat_info as { length?: number; slat_count?: number; joint_bar?: number; glass_qty?: number };
        return { length: si.length || 0, slatCount: si.slat_count || 0, jointBar: si.joint_bar || 0, glassQty: si.glass_qty || 0 };
      })() : undefined,
      bendingInfo: undefined, // deprecated: work order 레벨로 이동 (order.bendingInfo)
      materialInputLots: (() => {
        const inputs = item.material_inputs as Array<{ stock_lot?: { lot_no?: string } }> | undefined;
        if (!inputs || inputs.length === 0) return undefined;
        const lots = inputs.map(mi => mi.stock_lot?.lot_no).filter((v): v is string => !!v);
        return lots.length > 0 ? [...new Set(lots)] : undefined;
      })(),
    })),
    bendingInfo: api.options?.bending_info || undefined,
    bendingDetails: api.bending_detail ? transformBendingDetail(api.bending_detail) : undefined,
    issues: (api.issues || []).map(issue => ({
      id: String(issue.id),
      status: issue.is_resolved ? 'resolved' : 'pending',
      type: issue.priority === 'high' ? '긴급' : '일반',
      description: issue.title + (issue.description ? ` - ${issue.description}` : ''),
      createdAt: formatDate(issue.created_at),
    })),
    note: api.memo || undefined,
  };
}

// 벤딩 상세 변환
function transformBendingDetail(api: WorkOrderBendingDetailApi): BendingDetail[] {
  const fields: { key: keyof WorkOrderBendingDetailApi; label: string }[] = [
    { key: 'shaft_cutting', label: '샤프트 절단' },
    { key: 'bearing', label: '베어링' },
    { key: 'shaft_welding', label: '샤프트 용접' },
    { key: 'assembly', label: '조립' },
    { key: 'winder_welding', label: '와인더 용접' },
    { key: 'frame_assembly', label: '프레임 조립' },
    { key: 'bundle_assembly', label: '번들 조립' },
    { key: 'motor_assembly', label: '모터 조립' },
    { key: 'bracket_assembly', label: '브라켓 조립' },
  ];

  return fields.map((field, idx) => ({
    id: `bd-${idx}`,
    code: field.key.toUpperCase(),
    name: field.label,
    material: '-',
    quantity: api[field.key] ? 1 : 0,
    developWidth: '-',
    length: '-',
    weight: '-',
    note: api[field.key] ? '완료' : '미완료',
    developDimension: '-',
  }));
}

// 상태 → 단계 변환
// 작업 진행 표시용: 실제 작업이 시작되기 전에는 -1 (아무것도 완료/진행 없음)
function getStatusStep(status: WorkOrderStatus): number {
  const stepMap: Record<WorkOrderStatus, number> = {
    unassigned: -1,   // 미배정: 아무 단계도 시작 안함
    pending: -1,      // 대기: 배정됨, 작업 미시작
    waiting: 0,       // 준비중: 첫 단계 진행 중
    in_progress: 0,   // 작업중: 첫 단계 진행 중 (TODO: 실제 단계 추적 필요)
    completed: 999,   // 완료: 모든 단계 완료
    shipped: 999,     // 출하: 모든 단계 완료
  };
  return stepMap[status] ?? -1;
}

// Frontend → API 변환 (등록/수정용)
export function transformFrontendToApi(data: Partial<WorkOrder> & { processId?: number; assigneeIds?: number[] }): Record<string, unknown> {
  const result: Record<string, unknown> = {};

  if (data.projectName !== undefined) result.project_name = data.projectName;
  if (data.processId !== undefined) result.process_id = data.processId;
  if (data.status !== undefined) result.status = data.status;
  if (data.scheduledDate !== undefined) result.scheduled_date = data.scheduledDate;
  if (data.dueDate !== undefined && data.scheduledDate === undefined) result.scheduled_date = data.dueDate;
  if (data.note !== undefined) result.memo = data.note;
  if (data.priority !== undefined) result.priority = data.priority;
  if (data.assigneeIds !== undefined) result.assignee_ids = data.assigneeIds;

  // items 변환
  if (data.items !== undefined) {
    result.items = data.items.map((item, idx) => ({
      item_name: item.productName,
      specification: item.specification,
      quantity: item.quantity,
      sort_order: idx,
    }));
  }

  return result;
}

// 통계 변환
export function transformStatsApiToFrontend(api: WorkOrderStatsApi): WorkOrderStats {
  return {
    total: api.total,
    unassigned: api.unassigned,
    pending: api.pending,
    waiting: api.waiting,
    inProgress: api.in_progress,
    completed: api.completed + api.shipped,
    byProcess: api.by_process || {},
  };
}