import request from "@/utils/request";
import type { BaseResult, PageResult } from "@/models/base";

export type TimelinessMaterialType = "单丝" | "绞线";

export interface TimeSensitiveTaskQuery {
  current: number;
  size?: number;
  initiatorName?: string;
  machineName?: string;
  materialType?: TimelinessMaterialType | string;
  taskStatus?: number | string;
  startTime?: string;
  endTime?: string;
}

export interface TimeSensitiveTaskForm {
  materialType: TimelinessMaterialType;
  initiatorName: string;
  initiateTime: string;
  setTemperature: number | string;
  agingDuration: number | string;
  machineName: string;
  inspectorName: string;
}

export interface TimeSensitiveTaskStartForm extends TimeSensitiveTaskForm {
  id: number | string;
  furnaceInTime: string;
}

export interface TimeSensitiveCandidateQuery {
  current: number;
  size?: number;
  taskId: number | string;
  materialType: TimelinessMaterialType;
  model?: string;
  materialCode?: string;
}

export interface TimelinessInspectionDetailForm {
  id?: number | string;
  routingInspectionUser?: string;
  zoneOne?: number | string;
  zoneTwo?: number | string;
  zoneThree?: number | string;
  zoneFour?: number | string;
  zoneFive?: number | string;
  zoneSix?: number | string;
  timelinessInspectionId?: number | string;
}

/** 联调完成后改为 false 即可恢复下方真实接口。 */
export const USE_TIME_SENSITIVE_MOCK = true;

const mockTasks: any[] = [
  {
    id: 9001,
    taskCode: "SX-20260904-001",
    materialType: "单丝",
    initiatorName: "张工",
    initiateTime: "2026-09-04 09:10:00",
    setTemperature: 180,
    agingDuration: "2+4+1",
    machineName: "时效炉-01",
    itemCount: 2,
    furnaceInTime: "",
    furnaceOutTime: "",
    inspectorName: "李师傅",
    taskStatus: 0,
  },
  {
    id: 9002,
    taskCode: "JX-20260904-001",
    materialType: "绞线",
    initiatorName: "王工",
    initiateTime: "2026-09-04 08:30:00",
    setTemperature: 175,
    agingDuration: "2+3+1",
    machineName: "时效炉-02",
    itemCount: 2,
    furnaceInTime: "2026-09-04 10:00:00",
    furnaceOutTime: "",
    inspectorName: "赵师傅",
    taskStatus: 1,
  },
  {
    id: 9003,
    taskCode: "SX-20260903-001",
    materialType: "单丝",
    initiatorName: "刘工",
    initiateTime: "2026-09-03 08:00:00",
    setTemperature: 180,
    agingDuration: "2+4+1",
    machineName: "时效炉-01",
    itemCount: 1,
    furnaceInTime: "2026-09-03 08:30:00",
    furnaceOutTime: "2026-09-03 15:30:00",
    inspectorName: "孙师傅",
    taskStatus: 2,
  },
];

const mockMaterialPool: Record<TimelinessMaterialType, any[]> = {
  单丝: [
    {
      id: 9101,
      materialType: "单丝",
      model: "Φ5.6",
      poleModel: "1A60 H12 Φ9.5 A2",
      rodNo: "720526083102-014",
      batchCode: "750826090101-005",
      monofilamentNumber: "750826090101-005",
      weight: 2875,
      supplier: "山东元旺电工科技有限公司",
    },
    {
      id: 9102,
      materialType: "单丝",
      model: "L-3.45",
      poleModel: "1A60-H14 Φ9.5 A6",
      rodNo: "710726081602-003",
      batchCode: "750426083002-037",
      monofilamentNumber: "750426083002-037",
      weight: 2650,
      supplier: "山东元旺电工科技有限公司",
    },
    {
      id: 9301,
      outputId: 9301,
      materialType: "单丝",
      model: "8030-95L",
      poleModel: "8030",
      rodNo: "720626082404-001",
      batchCode: "750626083101-001",
      monofilamentNumber: "750626083101-001",
      weight: 2400,
      supplier: "山东元旺电工科技有限公司",
    },
    {
      id: 9302,
      outputId: 9302,
      materialType: "单丝",
      model: "Φ3.20",
      poleModel: "1A60 H14 Φ9.5 A6",
      rodNo: "710726090401-002",
      batchCode: "750726090401-002",
      monofilamentNumber: "750726090401-002",
      weight: 2520,
      supplier: "山东元旺电工科技有限公司",
    },
    {
      id: 9501,
      materialType: "单丝",
      model: "Φ4.50",
      poleModel: "1A60 H12 Φ9.5 A2",
      rodNo: "720526083102-018",
      batchCode: "750826090201-001",
      monofilamentNumber: "750826090201-001",
      weight: 2780,
      supplier: "山东元旺电工科技有限公司",
    },
  ],
  绞线: [
    {
      id: 9201,
      outputId: 9201,
      materialType: "绞线",
      model: "JLHA1/G1A-16/3-6/1",
      batchCode: "JX260904001-01",
      weight: 1180,
    },
    {
      id: 9202,
      outputId: 9202,
      materialType: "绞线",
      model: "JLHA1/G1A-25/4-6/1",
      batchCode: "JX260904001-02",
      weight: 1260,
    },
    {
      id: 9401,
      outputId: 9401,
      materialType: "绞线",
      model: "JLHA1/G1A-35/6-6/1",
      batchCode: "JX260904002-01",
      weight: 1380,
    },
    {
      id: 9402,
      outputId: 9402,
      materialType: "绞线",
      model: "JLHA1/G1A-50/8-6/1",
      batchCode: "JX260904002-02",
      weight: 1460,
    },
  ],
};

const findMockMaterial = (id: number | string) =>
  [...mockMaterialPool.单丝, ...mockMaterialPool.绞线].find(
    (item) => String(item.id) === String(id)
  );

const cloneMockMaterial = (id: number | string) => {
  const item = findMockMaterial(id);
  return item ? { ...item } : undefined;
};

const mockItems: Record<string, any[]> = {
  "9001": [cloneMockMaterial(9101), cloneMockMaterial(9102)].filter(Boolean),
  "9002": [cloneMockMaterial(9201), cloneMockMaterial(9202)].filter(Boolean),
  "9003": [cloneMockMaterial(9501)].filter(Boolean),
};

const mockInspections: Record<string, any[]> = {
  "9002": [
    {
      id: 9601,
      routingInspectionUser: "赵师傅",
      zoneOne: 175,
      zoneTwo: 175.2,
      zoneThree: 174.8,
      zoneFour: 175.1,
      zoneFive: 175,
      zoneSix: 174.9,
      createTime: "2026-09-04 11:00:00",
      timelinessInspectionId: 9002,
    },
  ],
  "9003": [
    {
      id: 9602,
      routingInspectionUser: "孙师傅",
      zoneOne: 180,
      zoneTwo: 180,
      zoneThree: 179.8,
      zoneFour: 180.1,
      zoneFive: 180,
      zoneSix: 179.9,
      createTime: "2026-09-03 10:30:00",
      timelinessInspectionId: 9003,
    },
  ],
};

const mockOperations: Record<string, any[]> = {
  "9001": [
    {
      id: 9701,
      operationType: 1,
      operationTypeDesc: "新增",
      beforeStatus: "",
      afterStatus: "待开始",
      operationDetail: "张工创建时效任务",
      operatorName: "张工",
      operateTime: "2026-09-04 09:10:00",
    },
  ],
  "9002": [
    {
      id: 9702,
      operationType: 2,
      operationTypeDesc: "开始时效",
      beforeStatus: "待开始",
      afterStatus: "时效中",
      operationDetail: "赵师傅确认任务信息并开始时效",
      operatorName: "赵师傅",
      operateTime: "2026-09-04 10:00:00",
    },
  ],
  "9003": [
    {
      id: 9703,
      operationType: 3,
      operationTypeDesc: "结束时效",
      beforeStatus: "时效中",
      afterStatus: "时效结束",
      operationDetail: "孙师傅结束时效任务",
      operatorName: "孙师傅",
      operateTime: "2026-09-03 15:30:00",
    },
  ],
};

const mockUsers = [
  { userId: 1, nickName: "张工" },
  { userId: 2, nickName: "王工" },
  { userId: 3, nickName: "刘工" },
  { userId: 4, nickName: "李师傅" },
  { userId: 5, nickName: "赵师傅" },
  { userId: 6, nickName: "孙师傅" },
];

const mockMachines = [
  { deviceId: 1, deviceModel: "时效炉-01" },
  { deviceId: 2, deviceModel: "时效炉-02" },
  { deviceId: 3, deviceModel: "时效炉-03" },
];

const pad = (value: number) => String(value).padStart(2, "0");
const mockDateTime = () => {
  const date = new Date();
  return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())} ${pad(
    date.getHours()
  )}:${pad(date.getMinutes())}:${pad(date.getSeconds())}`;
};

const mockResult = <T>(data: T, msg = "success") =>
  new Promise<BaseResult<T>>((resolve) => {
    setTimeout(() => resolve({ code: 200, msg, data }), 120);
  });

const mockMaterialCode = (item: any) =>
  String(item?.flowCode || item?.batchCode || item?.monofilamentNumber || "").trim();

const updateMockItemCount = (taskId: number | string) => {
  const task = mockTasks.find((item) => String(item.id) === String(taskId));
  if (task) task.itemCount = (mockItems[String(taskId)] || []).length;
};

const addMockOperation = (
  taskId: number | string,
  operationType: number,
  operationTypeDesc: string,
  beforeStatus: string,
  afterStatus: string,
  operationDetail: string,
  operatorName: string
) => {
  const key = String(taskId);
  mockOperations[key] ||= [];
  mockOperations[key].unshift({
    id: Date.now(),
    operationType,
    operationTypeDesc,
    beforeStatus,
    afterStatus,
    operationDetail,
    operatorName,
    operateTime: mockDateTime(),
  });
};

const TimeSensitiveTaskApi = {
  queryPage(params: TimeSensitiveTaskQuery) {
    if (USE_TIME_SENSITIVE_MOCK) {
      let rows = [...mockTasks];
      if (params.initiatorName) {
        rows = rows.filter((item) => item.initiatorName.includes(params.initiatorName!));
      }
      if (params.machineName) {
        rows = rows.filter((item) => item.machineName.includes(params.machineName!));
      }
      if (params.materialType) {
        rows = rows.filter((item) => item.materialType === params.materialType);
      }
      if (params.taskStatus !== undefined && params.taskStatus !== "") {
        rows = rows.filter((item) => Number(item.taskStatus) === Number(params.taskStatus));
      }
      if (params.startTime) {
        rows = rows.filter((item) => item.initiateTime >= params.startTime!);
      }
      if (params.endTime) {
        rows = rows.filter((item) => item.initiateTime <= params.endTime!);
      }
      const current = Number(params.current || 1);
      const size = Number(params.size || 10);
      return mockResult<PageResult>({
        records: rows.slice((current - 1) * size, current * size),
        total: rows.length,
        current,
        size,
        pages: current * size < rows.length,
      });
    }
    return request<BaseResult<PageResult>>({
      url: "/timeSensitiveTask/queryPage",
      method: "GET",
      data: params,
    });
  },

  getDetail(id: number | string) {
    if (USE_TIME_SENSITIVE_MOCK) {
      return mockResult(mockTasks.find((item) => String(item.id) === String(id)) || null);
    }
    return request<BaseResult<any>>({
      url: "/timeSensitiveTask/getDetailById",
      method: "GET",
      data: { id },
    });
  },

  getItems(taskId: number | string) {
    if (USE_TIME_SENSITIVE_MOCK) {
      return mockResult<any[]>((mockItems[String(taskId)] || []).map((item) => ({ ...item })));
    }
    return request<BaseResult<any[]>>({
      url: "/timeSensitiveTask/getItems",
      method: "GET",
      data: { taskId },
    });
  },

  create(data: TimeSensitiveTaskForm) {
    if (USE_TIME_SENSITIVE_MOCK) {
      const id = Date.now();
      const taskCode = `${data.materialType === "单丝" ? "SX" : "JX"}-${String(id).slice(-10)}`;
      mockTasks.unshift({
        id,
        taskCode,
        ...data,
        itemCount: 0,
        furnaceInTime: "",
        furnaceOutTime: "",
        taskStatus: 0,
      });
      mockItems[String(id)] = [];
      addMockOperation(
        id,
        1,
        "新增",
        "",
        "待开始",
        `${data.initiatorName}创建时效任务`,
        data.initiatorName
      );
      return mockResult({ id, taskCode }, "时效任务新增成功");
    }
    return request<BaseResult<any>>({
      url: "/timeSensitiveTask/add",
      method: "POST",
      data,
    });
  },

  update(data: TimeSensitiveTaskForm & { id: number | string }) {
    if (USE_TIME_SENSITIVE_MOCK) {
      const task = mockTasks.find((item) => String(item.id) === String(data.id));
      if (task) Object.assign(task, data);
      addMockOperation(
        data.id,
        2,
        "修改",
        "待开始",
        "待开始",
        "修改时效任务基础信息",
        data.initiatorName
      );
      return mockResult(task, "时效任务修改成功");
    }
    return request<BaseResult<any>>({
      url: "/timeSensitiveTask/update",
      method: "POST",
      data,
    });
  },

  delete(id: number | string) {
    if (USE_TIME_SENSITIVE_MOCK) {
      const index = mockTasks.findIndex((item) => String(item.id) === String(id));
      if (index >= 0) mockTasks.splice(index, 1);
      delete mockItems[String(id)];
      delete mockOperations[String(id)];
      delete mockInspections[String(id)];
      return mockResult(true, "时效任务删除成功");
    }
    return request<BaseResult<any>>({
      url: "/timeSensitiveTask/delete",
      method: "DELETE",
      data: { id },
    });
  },

  start(data: TimeSensitiveTaskStartForm) {
    if (USE_TIME_SENSITIVE_MOCK) {
      const task = mockTasks.find((item) => String(item.id) === String(data.id));
      if (task) Object.assign(task, data, { taskStatus: 1 });
      addMockOperation(
        data.id,
        2,
        "开始时效",
        "待开始",
        "时效中",
        `${data.inspectorName}确认任务信息并开始时效`,
        data.inspectorName
      );
      return mockResult(task, "时效已开始");
    }
    return request<BaseResult<any>>({
      url: "/timeSensitiveTask/start",
      method: "POST",
      data,
    });
  },

  checkEnd(id: number | string) {
    if (USE_TIME_SENSITIVE_MOCK) {
      return mockResult({
        canEnd: false,
        reachedDuration: false,
        elapsedMinutes: 120,
        requiredMinutes: 360,
        message: "Mock：尚未达到设定时效时长。",
      });
    }
    return request<BaseResult<any>>({
      url: "/timeSensitiveTask/checkEnd",
      method: "GET",
      data: { id },
    });
  },

  end(data: { id: number | string; forceEnd: boolean }) {
    if (USE_TIME_SENSITIVE_MOCK) {
      const task = mockTasks.find((item) => String(item.id) === String(data.id));
      if (task) Object.assign(task, { taskStatus: 2, furnaceOutTime: mockDateTime() });
      addMockOperation(
        data.id,
        3,
        "结束时效",
        "时效中",
        "时效结束",
        data.forceEnd ? "未达到时长，确认强制结束时效" : "结束时效任务",
        task?.inspectorName || "操作人"
      );
      return mockResult(task, "时效已结束");
    }
    return request<BaseResult<any>>({
      url: "/timeSensitiveTask/end",
      method: "POST",
      data,
    });
  },

  queryCandidates(params: TimeSensitiveCandidateQuery) {
    if (USE_TIME_SENSITIVE_MOCK) {
      const existingIds = new Set(
        (mockItems[String(params.taskId)] || []).map((item) => String(item.id))
      );
      let rows = mockMaterialPool[params.materialType]
        .filter((item) => !existingIds.has(String(item.id)))
        .map((item) => ({ ...item }));
      if (params.model) {
        const model = params.model.trim().toUpperCase();
        rows = rows.filter((item) =>
          String(item.model || "")
            .toUpperCase()
            .includes(model)
        );
      }
      if (params.materialCode) {
        const code = params.materialCode.trim().toUpperCase();
        rows = rows.filter(
          (item) =>
            mockMaterialCode(item).toUpperCase().includes(code) ||
            String(item.id).toUpperCase() === code ||
            String(item.outputId || "").toUpperCase() === code
        );
      }
      const current = Number(params.current || 1);
      const size = Number(params.size || 10);
      return mockResult<PageResult>({
        records: rows.slice((current - 1) * size, current * size),
        total: rows.length,
        current,
        size,
        pages: current * size < rows.length,
      });
    }
    return request<BaseResult<PageResult>>({
      url: "/timeSensitiveTask/queryCandidates",
      method: "GET",
      data: params,
    });
  },

  addItems(data: { taskId: number | string; itemIds: Array<number | string> }) {
    if (USE_TIME_SENSITIVE_MOCK) {
      const key = String(data.taskId);
      mockItems[key] ||= [];
      const existingIds = new Set(mockItems[key].map((item) => String(item.id)));
      data.itemIds.forEach((id) => {
        const material = cloneMockMaterial(id);
        if (material && !existingIds.has(String(id))) mockItems[key].push(material);
      });
      updateMockItemCount(data.taskId);
      const task = mockTasks.find((item) => String(item.id) === key);
      addMockOperation(
        data.taskId,
        1,
        "新增明细",
        "待开始",
        "待开始",
        `新增 ${data.itemIds.length} 条时效明细`,
        task?.initiatorName || "操作人"
      );
      return mockResult(true, "时效明细新增成功");
    }
    return request<BaseResult<any>>({
      url: "/timeSensitiveTask/addItems",
      method: "POST",
      data,
    });
  },

  deleteItems(data: { taskId: number | string; itemIds: Array<number | string> }) {
    if (USE_TIME_SENSITIVE_MOCK) {
      const key = String(data.taskId);
      const idSet = new Set(data.itemIds.map(String));
      mockItems[key] = (mockItems[key] || []).filter((item) => !idSet.has(String(item.id)));
      updateMockItemCount(data.taskId);
      const task = mockTasks.find((item) => String(item.id) === key);
      addMockOperation(
        data.taskId,
        4,
        "删除明细",
        "待开始",
        "待开始",
        `删除 ${data.itemIds.length} 条时效明细`,
        task?.initiatorName || "操作人"
      );
      return mockResult(true, "时效明细删除成功");
    }
    return request<BaseResult<any>>({
      url: "/timeSensitiveTask/deleteItems",
      method: "POST",
      data,
    });
  },

  getMachines() {
    if (USE_TIME_SENSITIVE_MOCK) return mockResult(mockMachines.map((item) => ({ ...item })));
    return request<BaseResult<any[]>>({
      url: "/device/querydeviceSx",
      method: "GET",
    });
  },

  getUsers() {
    if (USE_TIME_SENSITIVE_MOCK) return mockResult(mockUsers.map((item) => ({ ...item })));
    return request<BaseResult<any[]>>({
      url: "/team/getUser",
      method: "GET",
    });
  },

  getOperationRecords(recordId: number | string) {
    if (USE_TIME_SENSITIVE_MOCK) {
      return mockResult<any[]>(
        (mockOperations[String(recordId)] || []).map((item) => ({ ...item }))
      );
    }
    return request<BaseResult<any[]>>({
      url: "/operationRecord/list",
      method: "POST",
      data: { tableName: "time_sensitive_task", recordId },
    });
  },

  getInspectionDetails(id: number | string) {
    if (USE_TIME_SENSITIVE_MOCK) {
      return mockResult<any[]>((mockInspections[String(id)] || []).map((item) => ({ ...item })));
    }
    return request<BaseResult<any>>({
      url: "/timelinessInspection/getDetailById",
      method: "GET",
      data: { id },
    });
  },

  saveInspectionDetails(data: TimelinessInspectionDetailForm[]) {
    if (USE_TIME_SENSITIVE_MOCK) {
      const inspectionId = data[0]?.timelinessInspectionId;
      if (inspectionId !== undefined) {
        mockInspections[String(inspectionId)] = data.map((item, index) => ({
          ...item,
          id: item.id || Date.now() + index,
          createTime: (item as any).createTime || mockDateTime(),
        }));
      }
      return mockResult(true, "巡检记录保存成功");
    }
    return request<BaseResult<any>>({
      url: "/timelinessInspectionDetail/add",
      method: "POST",
      data,
    });
  },

  deleteInspectionDetail(id: number | string) {
    if (USE_TIME_SENSITIVE_MOCK) {
      Object.keys(mockInspections).forEach((key) => {
        mockInspections[key] = mockInspections[key].filter(
          (item) => String(item.id) !== String(id)
        );
      });
      return mockResult(true, "巡检记录删除成功");
    }
    return request<BaseResult<any>>({
      url: "/timelinessInspectionDetail/delete",
      method: "DELETE",
      data: { id },
    });
  },
};

export default TimeSensitiveTaskApi;