import request from './request'

// ============ 类型定义 ============

/** 生产工单 BOM 物料行 */
export interface WorkOrderBom {
  lineId?: number
  workorderId?: number
  itemId?: number
  itemCode?: string
  itemName?: string
  itemSpc?: string
  unitOfMeasure?: string
  unitName?: string
  itemOrProduct?: string
  quantity?: number
  remark?: string
}

/** 生产工单主表 */
export interface WorkOrder {
  workorderId?: number
  workorderCode?: string
  workorderName?: string
  workorderType?: string
  orderSource?: string
  sourceCode?: string
  productId?: number
  productCode?: string
  productName?: string
  productSpc?: string
  unitOfMeasure?: string
  unitName?: string
  routeId?: number
  routeCode?: string
  routeName?: string
  batchCode?: string
  quantity?: number
  quantityProduced?: number
  quantityChanged?: number
  quantityScheduled?: number
  clientId?: number
  clientCode?: string
  clientName?: string
  vendorId?: number
  vendorCode?: string
  vendorName?: string
  productionDate?: string  // 前端字段名，映射到后端 requestDate
  requestDate?: string     // 后端实际字段名（数据库列 request_date）
  finishDate?: string
  cancelDate?: string
  parentId?: number
  ancestors?: string
  status?: string
  remark?: string
  createBy?: string
  createTime?: string
  updateBy?: string
  updateTime?: string
  // v3.1 新增字段
  orderDate?: string            // 单据日期
  businessType?: string         // 业务类型
  businessStatus?: string       // 业务状态
  operatorName?: string         // 操作员
  approverName?: string         // 审核员
  approveDate?: string          // 审核日期
  salesOrderCode?: string       // 跟单编号（销售订单号）
  deliveryDate?: string         // 订单交期
  drawingNo?: string            // 图纸号
  productionLine?: string       // 生产线
  processTime?: number          // 加工时长（分钟）
  qualityReq?: string           // 质量要求
}

/** 查询参数 */
export interface WorkOrderQuery {
  workorderCode?: string
  workorderName?: string
  workorderType?: string
  sourceCode?: string
  productCode?: string
  productName?: string
  status?: string
  beginProductionDate?: string  // 前端用，映射到后端 beginRequestDate
  endProductionDate?: string    // 前端用，映射到后端 endRequestDate
  pageNum?: number
  pageSize?: number
}

/** 分页响应 */
export interface WorkOrderListResponse {
  rows: WorkOrder[]
  total: number
}

// ============ 状态映射 ============

export const STATUS_MAP: Record<string, { label: string; type: string }> = {
  'PREPARE': { label: '草稿', type: 'info' },
  'CONFIRMED': { label: '已确认', type: '' },
  'APPROVED': { label: '已审核', type: 'success' },
  'FINISHED': { label: '已完成', type: 'success' },
  'CANCELED': { label: '已取消', type: 'danger' }
}

export const WORKORDER_TYPE_OPTIONS = [
  { value: 'SELF', label: '自产' },
  { value: 'OUTSOURCE', label: '委外' },
  { value: 'PROCESSING', label: '加工车间' }
]

export const BUSINESS_STATUS_OPTIONS = [
  { value: 'NORMAL', label: '正常' },
  { value: 'PAUSE', label: '暂停' },
  { value: 'CANCEL', label: '取消' }
]

// ============ API 接口 ============

const BASE = '/mes/pro/workorder'

/** 查询生产工单列表 */
export function getWorkOrderList(params: WorkOrderQuery): Promise<WorkOrderListResponse> {
  // 将前端日期查询参数映射为后端字段名
  const backendParams: Record<string, any> = { ...params }
  if (backendParams.beginProductionDate) {
    backendParams.beginRequestDate = backendParams.beginProductionDate
    delete backendParams.beginProductionDate
  }
  if (backendParams.endProductionDate) {
    backendParams.endRequestDate = backendParams.endProductionDate
    delete backendParams.endProductionDate
  }
  return request.get(`${BASE}/list`, { params: backendParams }).then((res: any) => {
    const rows = (res.rows ?? res.data?.rows ?? []).map((row: any) => {
      // 后端返回 requestDate，前端显示用 productionDate
      if (row.requestDate && !row.productionDate) {
        row.productionDate = row.requestDate
      }
      return row
    })
    const total = res.total ?? res.data?.total ?? 0
    return { rows, total }
  })
}

/** 获取生产工单详情 */
export function getWorkOrderDetail(workorderId: number): Promise<WorkOrder> {
  return request.get(`${BASE}/${workorderId}`).then((res: any) => {
    const data = res.data ?? res
    // 后端返回 requestDate，前端用 productionDate
    if (data.requestDate && !data.productionDate) {
      data.productionDate = data.requestDate
    }
    return data
  })
}

/** 将前端字段名映射为后端字段名 */
function toBackendPayload(data: Partial<WorkOrder>): Record<string, any> {
  const payload: Record<string, any> = { ...data }
  // 前端用 productionDate，后端用 requestDate
  if (payload.productionDate !== undefined) {
    payload.requestDate = payload.productionDate
    delete payload.productionDate
  }
  return payload
}

/** 新增生产工单 */
export function createWorkOrder(data: Partial<WorkOrder>): Promise<number> {
  return request.post(BASE, toBackendPayload(data)).then((res: any) => res.data ?? res)
}

/** 修改生产工单 */
export function updateWorkOrder(data: Partial<WorkOrder>): Promise<void> {
  return request.put(BASE, toBackendPayload(data))
}

/** 删除生产工单（支持批量） */
export function deleteWorkOrder(workorderIds: number | number[] | string): Promise<void> {
  const ids = Array.isArray(workorderIds) ? workorderIds.join(',') : String(workorderIds)
  return request.delete(`${BASE}/${ids}`)
}

/** 完工工单 */
export function finishWorkOrder(workorderId: number): Promise<void> {
  return request.put(`${BASE}/finish/${workorderId}`)
}

/** 取消工单 */
export function cancelWorkOrder(workorderId: number): Promise<void> {
  return request.put(`${BASE}/cancel/${workorderId}`)
}

/** 获取工单 BOM 组成列表（直接查 pro_workorder_bom 表，字段名直接对应） */
export function getWorkOrderBomList(workorderId: number): Promise<WorkOrderBom[]> {
  return request.get('/mes/pro/workorderbom/list', {
    params: { workorderId, pageNum: 1, pageSize: 500 }
  }).then((res: any) => {
    return res.rows ?? res.data?.rows ?? []
  })
}

/** 导出生产工单 */
export function exportWorkOrder(params: WorkOrderQuery): Promise<Blob> {
  return request.post(`${BASE}/export`, params, { responseType: 'blob' })
}

/** 一键领料：根据工单 BOM 自动创建领料单，返回领料单 ID */
export function quickIssue(workorderId: number): Promise<number> {
  return request.post(`${BASE}/quickIssue/${workorderId}`).then((res: any) => res.data ?? res)
}

/** 审核工单（确认）：PREPARE → CONFIRMED */
export function confirmWorkOrder(workorderId: number): Promise<void> {
  return request.put(`${BASE}/confirm/${workorderId}`)
}

/** 反审核工单：CONFIRMED → PREPARE */
export function unconfirmWorkOrder(workorderId: number): Promise<void> {
  return request.put(`${BASE}/unconfirm/${workorderId}`)
}

/** 查询工单关联的领料明细列表 */
export function getIssueListByWorkorder(workorderId: number): Promise<{ rows: any[]; total: number }> {
  return request.get('/mes/wm/issueheader/list', {
    params: { workorderId, pageNum: 1, pageSize: 100 }
  }).then((res: any) => ({
    rows: res.rows ?? [],
    total: res.total ?? 0
  }))
}

// ============ 工序任务（ProTask）API ============

/** 工序任务 */
export interface ProTask {
  taskId?: number
  taskCode?: string
  taskName?: string
  workorderId?: number
  workorderCode?: string
  processId?: number
  processCode?: string
  processName?: string
  quantity?: number
  quantityProduced?: number
  quantityQuanlified?: number
  quantityUnquanlified?: number
  startTime?: string
  duration?: number
  endTime?: string
  colorCode?: string
  status?: string
  remark?: string
  createBy?: string
  createTime?: string
  updateBy?: string
  updateTime?: string
}

/** 根据工单 ID 获取工序任务列表 */
export function getTaskListByWorkorder(workorderId: number): Promise<ProTask[]> {
  return request.get('/mes/pro/protask/list', {
    params: { workorderId, pageNum: 1, pageSize: 500 }
  }).then((res: any) => {
    return res.rows ?? res.data?.rows ?? []
  })
}

// ============ 工艺路线选择 API ============

/** 工艺路线列表（选择弹窗，不默认过滤 enableFlag 以避免列表为空） */
export function getRouteList(params?: {
  routeCode?: string
  routeName?: string
  enableFlag?: string
  pageNum?: number
  pageSize?: number
}): Promise<{ rows: any[]; total: number }> {
  return request.get('/mes/pro/proroute/list', {
    params: { pageNum: 1, pageSize: 100, ...params }
  }).then((res: any) => ({
    rows: res.rows ?? [],
    total: res.total ?? 0
  }))
}

// ============ 客户选择 API（备用） ============

/** 客户列表（选择弹窗） */
export function getClientList(params?: {
  clientCode?: string
  clientName?: string
  pageNum?: number
  pageSize?: number
}): Promise<{ rows: any[]; total: number }> {
  return request.get('/mes/md/client/list', {
    params: { pageNum: 1, pageSize: 100, ...params }
  }).then((res: any) => ({
    rows: res.rows ?? [],
    total: res.total ?? 0
  }))
}