import { request } from './request';
import type { PageResult } from './basic-data';

export interface MachineryType {
  id?: number;
  parentId?: number;
  code?: string;
  name?: string;
  sort?: number;
  status?: number;
  remark?: string;
  createTime?: string;
  children?: MachineryType[];
}

export interface Workshop {
  id?: number;
  code?: string;
  name?: string;
}

export interface Machinery {
  id?: number;
  code?: string;
  name?: string;
  brand?: string;
  specification?: string;
  machineryTypeId?: number;
  machineryTypeName?: string;
  workshopId?: number;
  workshopName?: string;
  collectDeviceCode?: string;
  collectEnabled?: boolean;
  status?: number;
  lastMaintenTime?: string;
  lastCheckTime?: string;
  productionEfficiency?: number;
  conveyorBelt?: number;
  workstationId?: number;
  workstationName?: string;
  remark?: string;
  createTime?: string;
}

export interface CheckRecord {
  id?: number;
  machineryId?: number;
  machineryCode?: string;
  machineryName?: string;
  machineryBrand?: string;
  machinerySpecification?: string;
  planId?: number;
  planName?: string;
  planCycleType?: number;
  userId?: number;
  checkTime?: string;
  nickname?: string;
  status?: number;
  remark?: string;
}

export interface MaintenRecord {
  id?: number;
  machineryId?: number;
  machineryCode?: string;
  machineryName?: string;
  machineryBrand?: string;
  machinerySpecification?: string;
  planId?: number;
  planName?: string;
  planCycleType?: number;
  userId?: number;
  maintenTime?: string;
  nickname?: string;
  status?: number;
  remark?: string;
}

export interface Repair {
  id?: number;
  code?: string;
  name?: string;
  machineryId?: number;
  machineryCode?: string;
  machineryName?: string;
  machineryBrand?: string;
  machinerySpecification?: string;
  requireDate?: string;
  finishDate?: string;
  confirmDate?: string;
  acceptedUserId?: number;
  nickname?: string;
  acceptedUserNickname?: string;
  confirmUserId?: number;
  confirmUserNickname?: string;
  result?: number;
  status?: number;
  remark?: string;
  createTime?: string;
}

export interface Subject {
  id?: number;
  code?: string;
  name?: string;
  type?: number;
  content?: string;
  standard?: string;
  status?: number;
  remark?: string;
  createTime?: string;
}

export interface CheckPlan {
  id?: number;
  code?: string;
  name?: string;
  type?: number;
  startDate?: string;
  endDate?: string;
  cycleType?: number;
  cycleCount?: number;
  status?: number;
  remark?: string;
  createTime?: string;
}

export interface CheckPlanMachinery {
  id?: number;
  planId?: number;
  machineryId?: number;
  machineryCode?: string;
  machineryName?: string;
  machineryBrand?: string;
  machinerySpecification?: string;
  remark?: string;
}

export interface CheckPlanSubject {
  id?: number;
  planId?: number;
  subjectId?: number;
  subjectCode?: string;
  subjectName?: string;
  subjectType?: number;
  subjectContent?: string;
  subjectStandard?: string;
  remark?: string;
}

export interface CheckRecordLine {
  id?: number;
  recordId?: number;
  subjectId?: number;
  subjectCode?: string;
  subjectName?: string;
  subjectContent?: string;
  subjectStandard?: string;
  checkStatus?: number;
  checkResult?: string;
  remark?: string;
}

export interface MaintenRecordLine {
  id?: number;
  recordId?: number;
  subjectId?: number;
  subjectName?: string;
  subjectContent?: string;
  subjectStandard?: string;
  status?: number;
  result?: string;
  remark?: string;
}

export interface RepairLine {
  id?: number;
  repairId?: number;
  subjectId?: number;
  subjectName?: string;
  subjectContent?: string;
  subjectStandard?: string;
  malfunction?: string;
  malfunctionUrl?: string;
  description?: string;
  remark?: string;
}

export interface Metering {
  id?: number;
  code?: string;
  name?: string;
  specification?: string;
  brand?: string;
  category?: number;
  precision?: string;
  range?: string;
  deptId?: number;
  deptName?: string;
  chargeUserId?: number;
  chargeUserNickname?: string;
  checkCycleCount?: number;
  useDate?: string;
  lastCheckDate?: string;
  nextCheckDate?: string;
  status?: number;
  expireStatus?: number;
  expireDays?: number;
  remark?: string;
  createTime?: string;
}

export interface MeteringCheck {
  id?: number;
  meteringId?: number;
  meteringCode?: string;
  meteringName?: string;
  checkCode?: string;
  checkDate?: string;
  checkOrg?: string;
  checkResult?: number;
  certNo?: string;
  checkUserId?: number;
  checkUserNickname?: string;
  nextCheckDate?: string;
  remark?: string;
  createTime?: string;
}

export interface ToolType {
  id?: number;
  code?: string;
  name?: string;
  codeFlag?: boolean;
  maintenType?: number;
  maintenPeriod?: number;
  remark?: string;
  createTime?: string;
}

export interface Tool {
  id?: number;
  code?: string;
  name?: string;
  brand?: string;
  specification?: string;
  toolTypeId?: number;
  toolTypeName?: string;
  codeFlag?: boolean;
  quantity?: number;
  availableQuantity?: number;
  maintenType?: number;
  nextMaintenPeriod?: number;
  nextMaintenDate?: string;
  status?: number;
  remark?: string;
  createTime?: string;
}

function authHeader(accessToken: string) {
  return { Authorization: `Bearer ${accessToken}` };
}

function toQuery(params: Record<string, string | number | boolean | undefined>) {
  const content = Object.entries(params)
    .filter(([, value]) => value !== undefined && value !== '')
    .map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`)
    .join('&');
  return content ? `?${content}` : '';
}

export function getMachineryTypeList(accessToken: string, params: { name?: string; status?: number } = {}) {
  return request<MachineryType[]>(`/mes/dv/machinery-type/list${toQuery(params)}`, { header: authHeader(accessToken) });
}

export function getMachineryTypeSimpleList(accessToken: string) {
  return request<MachineryType[]>('/mes/dv/machinery-type/simple-list', { header: authHeader(accessToken) });
}

export function getMachineryType(accessToken: string, id: number) {
  return request<MachineryType>(`/mes/dv/machinery-type/get${toQuery({ id })}`, { header: authHeader(accessToken) });
}

export function createMachineryType(accessToken: string, data: MachineryType) {
  return request<number>('/mes/dv/machinery-type/create', { method: 'POST', data, header: authHeader(accessToken) });
}

export function updateMachineryType(accessToken: string, data: MachineryType) {
  return request<boolean>('/mes/dv/machinery-type/update', { method: 'PUT', data, header: authHeader(accessToken) });
}

export function deleteMachineryType(accessToken: string, id: number) {
  return request<boolean>(`/mes/dv/machinery-type/delete${toQuery({ id })}`, { method: 'DELETE', header: authHeader(accessToken) });
}

export function generateAutoCode(accessToken: string, ruleCode: string) {
  return request<string>('/mes/md/auto-code-record/generate', { method: 'POST', data: { ruleCode }, header: authHeader(accessToken) });
}

export function getToolTypePage(accessToken: string, params: { pageNo: number; pageSize: number; code?: string; name?: string; maintenType?: number }) {
  return request<PageResult<ToolType>>(`/mes/tm/tool-type/page${toQuery(params)}`, { header: authHeader(accessToken) });
}

export function getToolTypeSimpleList(accessToken: string) {
  return request<ToolType[]>('/mes/tm/tool-type/simple-list', { header: authHeader(accessToken) });
}

export function getToolType(accessToken: string, id: number) {
  return request<ToolType>(`/mes/tm/tool-type/get${toQuery({ id })}`, { header: authHeader(accessToken) });
}

export function createToolType(accessToken: string, data: ToolType) {
  return request<number>('/mes/tm/tool-type/create', { method: 'POST', data, header: authHeader(accessToken) });
}

export function updateToolType(accessToken: string, data: ToolType) {
  return request<boolean>('/mes/tm/tool-type/update', { method: 'PUT', data, header: authHeader(accessToken) });
}

export function deleteToolType(accessToken: string, id: number) {
  return request<boolean>(`/mes/tm/tool-type/delete${toQuery({ id })}`, { method: 'DELETE', header: authHeader(accessToken) });
}

export function getToolPage(accessToken: string, params: { pageNo: number; pageSize: number; code?: string; name?: string; brand?: string; specification?: string; status?: number; toolTypeId?: number }) {
  return request<PageResult<Tool>>(`/mes/tm/tool/page${toQuery(params)}`, { header: authHeader(accessToken) });
}

export function getToolSimpleList(accessToken: string) {
  return request<Tool[]>('/mes/tm/tool/simple-list', { header: authHeader(accessToken) });
}

export function getTool(accessToken: string, id: number) {
  return request<Tool>(`/mes/tm/tool/get${toQuery({ id })}`, { header: authHeader(accessToken) });
}

export function createTool(accessToken: string, data: Tool) {
  return request<number>('/mes/tm/tool/create', { method: 'POST', data, header: authHeader(accessToken) });
}

export function updateTool(accessToken: string, data: Tool) {
  return request<boolean>('/mes/tm/tool/update', { method: 'PUT', data, header: authHeader(accessToken) });
}

export function deleteTool(accessToken: string, id: number) {
  return request<boolean>(`/mes/tm/tool/delete${toQuery({ id })}`, { method: 'DELETE', header: authHeader(accessToken) });
}

export function getWorkshopSimpleList(accessToken: string) {
  return request<Workshop[]>('/mes/md-workshop/simple-list', { header: authHeader(accessToken) });
}

export function getMachineryPage(accessToken: string, params: { pageNo: number; pageSize: number; code?: string; name?: string; workshopId?: number; status?: number; machineryTypeId?: number; collectDeviceCode?: string; collectEnabled?: boolean }) {
  return request<PageResult<Machinery>>(`/mes/dv/machinery/page${toQuery(params)}`, { header: authHeader(accessToken) });
}

export function getMachinerySimpleList(accessToken: string) {
  return request<Machinery[]>('/mes/dv/machinery/simple-list', { header: authHeader(accessToken) });
}

export function getMachinery(accessToken: string, id: number) {
  return request<Machinery>(`/mes/dv/machinery/get${toQuery({ id })}`, { header: authHeader(accessToken) });
}

export function createMachinery(accessToken: string, data: Machinery) {
  return request<number>('/mes/dv/machinery/create', { method: 'POST', data, header: authHeader(accessToken) });
}

export function updateMachinery(accessToken: string, data: Machinery) {
  return request<boolean>('/mes/dv/machinery/update', { method: 'PUT', data, header: authHeader(accessToken) });
}

export function deleteMachinery(accessToken: string, id: number) {
  return request<boolean>(`/mes/dv/machinery/delete${toQuery({ id })}`, { method: 'DELETE', header: authHeader(accessToken) });
}

export function getCheckRecordPage(accessToken: string, params: { pageNo: number; pageSize: number; machineryId?: number; machineryName?: string; status?: number }) {
  return request<PageResult<CheckRecord>>(`/mes/dv/check-record/page${toQuery(params)}`, { header: authHeader(accessToken) });
}

export function getCheckRecord(accessToken: string, id: number) {
  return request<CheckRecord>(`/mes/dv/check-record/get${toQuery({ id })}`, { header: authHeader(accessToken) });
}

export function createCheckRecord(accessToken: string, data: CheckRecord) {
  return request<number>('/mes/dv/check-record/create', { method: 'POST', data, header: authHeader(accessToken) });
}

export function updateCheckRecord(accessToken: string, data: CheckRecord) {
  return request<boolean>('/mes/dv/check-record/update', { method: 'PUT', data, header: authHeader(accessToken) });
}

export function submitCheckRecord(accessToken: string, id: number) {
  return request<boolean>(`/mes/dv/check-record/submit${toQuery({ id })}`, { method: 'PUT', header: authHeader(accessToken) });
}

export function deleteCheckRecord(accessToken: string, id: number) {
  return request<boolean>(`/mes/dv/check-record/delete${toQuery({ id })}`, { method: 'DELETE', header: authHeader(accessToken) });
}

export function getMaintenRecordPage(accessToken: string, params: { pageNo: number; pageSize: number; machineryId?: number; machineryName?: string; status?: number }) {
  return request<PageResult<MaintenRecord>>(`/mes/dv/mainten-record/page${toQuery(params)}`, { header: authHeader(accessToken) });
}

export function getMaintenRecord(accessToken: string, id: number) {
  return request<MaintenRecord>(`/mes/dv/mainten-record/get${toQuery({ id })}`, { header: authHeader(accessToken) });
}

export function createMaintenRecord(accessToken: string, data: MaintenRecord) {
  return request<number>('/mes/dv/mainten-record/create', { method: 'POST', data, header: authHeader(accessToken) });
}

export function updateMaintenRecord(accessToken: string, data: MaintenRecord) {
  return request<boolean>('/mes/dv/mainten-record/update', { method: 'PUT', data, header: authHeader(accessToken) });
}

export function submitMaintenRecord(accessToken: string, id: number) {
  return request<boolean>(`/mes/dv/mainten-record/submit${toQuery({ id })}`, { method: 'PUT', header: authHeader(accessToken) });
}

export function deleteMaintenRecord(accessToken: string, id: number) {
  return request<boolean>(`/mes/dv/mainten-record/delete${toQuery({ id })}`, { method: 'DELETE', header: authHeader(accessToken) });
}

export function getRepairPage(accessToken: string, params: { pageNo: number; pageSize: number; machineryId?: number; machineryName?: string; code?: string; name?: string; result?: number; status?: number }) {
  return request<PageResult<Repair>>(`/mes/dv/repair/page${toQuery(params)}`, { header: authHeader(accessToken) });
}

export function getRepair(accessToken: string, id: number) {
  return request<Repair>(`/mes/dv/repair/get${toQuery({ id })}`, { header: authHeader(accessToken) });
}

export function createRepair(accessToken: string, data: Repair) {
  return request<number>('/mes/dv/repair/create', { method: 'POST', data, header: authHeader(accessToken) });
}

export function updateRepair(accessToken: string, data: Repair) {
  return request<boolean>('/mes/dv/repair/update', { method: 'PUT', data, header: authHeader(accessToken) });
}

export function submitRepair(accessToken: string, id: number) {
  return request<boolean>(`/mes/dv/repair/submit${toQuery({ id })}`, { method: 'PUT', header: authHeader(accessToken) });
}

export function confirmRepair(accessToken: string, data: Repair) {
  return request<boolean>('/mes/dv/repair/confirm', { method: 'PUT', data, header: authHeader(accessToken) });
}

export function finishRepair(accessToken: string, id: number, result: number) {
  return request<boolean>(`/mes/dv/repair/finish${toQuery({ id, result })}`, { method: 'PUT', header: authHeader(accessToken) });
}

export function getSubjectPage(accessToken: string, params: { pageNo: number; pageSize: number; code?: string; name?: string; type?: number }) {
  return request<PageResult<Subject>>(`/mes/dv/subject/page${toQuery(params)}`, { header: authHeader(accessToken) });
}

export function getSubjectSimpleList(accessToken: string) {
  return request<Subject[]>('/mes/dv/subject/simple-list', { header: authHeader(accessToken) });
}

export function getSubject(accessToken: string, id: number) {
  return request<Subject>(`/mes/dv/subject/get${toQuery({ id })}`, { header: authHeader(accessToken) });
}

export function createSubject(accessToken: string, data: Subject) {
  return request<number>('/mes/dv/subject/create', { method: 'POST', data, header: authHeader(accessToken) });
}

export function updateSubject(accessToken: string, data: Subject) {
  return request<boolean>('/mes/dv/subject/update', { method: 'PUT', data, header: authHeader(accessToken) });
}

export function deleteSubject(accessToken: string, id: number) {
  return request<boolean>(`/mes/dv/subject/delete${toQuery({ id })}`, { method: 'DELETE', header: authHeader(accessToken) });
}

export function getCheckPlanPage(accessToken: string, params: { pageNo: number; pageSize: number; code?: string; name?: string; type?: number; status?: number }) {
  return request<PageResult<CheckPlan>>(`/mes/dv/check-plan/page${toQuery(params)}`, { header: authHeader(accessToken) });
}

export function getCheckPlan(accessToken: string, id: number) {
  return request<CheckPlan>(`/mes/dv/check-plan/get${toQuery({ id })}`, { header: authHeader(accessToken) });
}

export function createCheckPlan(accessToken: string, data: CheckPlan) {
  return request<number>('/mes/dv/check-plan/create', { method: 'POST', data, header: authHeader(accessToken) });
}

export function updateCheckPlan(accessToken: string, data: CheckPlan) {
  return request<boolean>('/mes/dv/check-plan/update', { method: 'PUT', data, header: authHeader(accessToken) });
}

export function enableCheckPlan(accessToken: string, id: number) {
  return request<boolean>(`/mes/dv/check-plan/enable${toQuery({ id })}`, { method: 'PUT', header: authHeader(accessToken) });
}

export function disableCheckPlan(accessToken: string, id: number) {
  return request<boolean>(`/mes/dv/check-plan/disable${toQuery({ id })}`, { method: 'PUT', header: authHeader(accessToken) });
}

export function deleteCheckPlan(accessToken: string, id: number) {
  return request<boolean>(`/mes/dv/check-plan/delete${toQuery({ id })}`, { method: 'DELETE', header: authHeader(accessToken) });
}

export function getCheckPlanMachineryListByPlan(accessToken: string, planId: number) {
  return request<CheckPlanMachinery[]>(`/mes/dv/check-plan-machinery/list-by-plan${toQuery({ planId })}`, { header: authHeader(accessToken) });
}

export function createCheckPlanMachinery(accessToken: string, data: CheckPlanMachinery) {
  return request<number>('/mes/dv/check-plan-machinery/create', { method: 'POST', data, header: authHeader(accessToken) });
}

export function deleteCheckPlanMachinery(accessToken: string, id: number) {
  return request<boolean>(`/mes/dv/check-plan-machinery/delete${toQuery({ id })}`, { method: 'DELETE', header: authHeader(accessToken) });
}

export function getCheckPlanSubjectListByPlan(accessToken: string, planId: number) {
  return request<CheckPlanSubject[]>(`/mes/dv/check-plan-subject/list-by-plan${toQuery({ planId })}`, { header: authHeader(accessToken) });
}

export function createCheckPlanSubject(accessToken: string, data: CheckPlanSubject) {
  return request<number>('/mes/dv/check-plan-subject/create', { method: 'POST', data, header: authHeader(accessToken) });
}

export function deleteCheckPlanSubject(accessToken: string, id: number) {
  return request<boolean>(`/mes/dv/check-plan-subject/delete${toQuery({ id })}`, { method: 'DELETE', header: authHeader(accessToken) });
}

export function getCheckRecordLinePage(accessToken: string, params: { pageNo: number; pageSize: number; recordId: number }) {
  return request<PageResult<CheckRecordLine>>(`/mes/dv/check-record-line/page${toQuery(params)}`, { header: authHeader(accessToken) });
}

export function createCheckRecordLine(accessToken: string, data: CheckRecordLine) {
  return request<number>('/mes/dv/check-record-line/create', { method: 'POST', data, header: authHeader(accessToken) });
}

export function updateCheckRecordLine(accessToken: string, data: CheckRecordLine) {
  return request<boolean>('/mes/dv/check-record-line/update', { method: 'PUT', data, header: authHeader(accessToken) });
}

export function deleteCheckRecordLine(accessToken: string, id: number) {
  return request<boolean>(`/mes/dv/check-record-line/delete${toQuery({ id })}`, { method: 'DELETE', header: authHeader(accessToken) });
}

export function getMaintenRecordLinePage(accessToken: string, params: { pageNo: number; pageSize: number; recordId: number }) {
  return request<PageResult<MaintenRecordLine>>(`/mes/dv/mainten-record-line/page${toQuery(params)}`, { header: authHeader(accessToken) });
}

export function createMaintenRecordLine(accessToken: string, data: MaintenRecordLine) {
  return request<number>('/mes/dv/mainten-record-line/create', { method: 'POST', data, header: authHeader(accessToken) });
}

export function updateMaintenRecordLine(accessToken: string, data: MaintenRecordLine) {
  return request<boolean>('/mes/dv/mainten-record-line/update', { method: 'PUT', data, header: authHeader(accessToken) });
}

export function deleteMaintenRecordLine(accessToken: string, id: number) {
  return request<boolean>(`/mes/dv/mainten-record-line/delete${toQuery({ id })}`, { method: 'DELETE', header: authHeader(accessToken) });
}

export function deleteRepair(accessToken: string, id: number) {
  return request<boolean>(`/mes/dv/repair/delete${toQuery({ id })}`, { method: 'DELETE', header: authHeader(accessToken) });
}

export function getRepairLinePage(accessToken: string, params: { pageNo: number; pageSize: number; repairId: number }) {
  return request<PageResult<RepairLine>>(`/mes/dv/repair-line/page${toQuery(params)}`, { header: authHeader(accessToken) });
}

export function createRepairLine(accessToken: string, data: RepairLine) {
  return request<number>('/mes/dv/repair-line/create', { method: 'POST', data, header: authHeader(accessToken) });
}

export function updateRepairLine(accessToken: string, data: RepairLine) {
  return request<boolean>('/mes/dv/repair-line/update', { method: 'PUT', data, header: authHeader(accessToken) });
}

export function deleteRepairLine(accessToken: string, id: number) {
  return request<boolean>(`/mes/dv/repair-line/delete${toQuery({ id })}`, { method: 'DELETE', header: authHeader(accessToken) });
}

export function getMeteringPage(accessToken: string, params: { pageNo: number; pageSize: number; code?: string; name?: string; category?: number; deptId?: number; chargeUserId?: number; status?: number; expireStatus?: number }) {
  return request<PageResult<Metering>>(`/mes/dv/metering/page${toQuery(params)}`, { header: authHeader(accessToken) });
}

export function getMeteringSimpleList(accessToken: string) {
  return request<Metering[]>('/mes/dv/metering/simple-list', { header: authHeader(accessToken) });
}

export function getMetering(accessToken: string, id: number) {
  return request<Metering>(`/mes/dv/metering/get${toQuery({ id })}`, { header: authHeader(accessToken) });
}

export function createMetering(accessToken: string, data: Metering) {
  return request<number>('/mes/dv/metering/create', { method: 'POST', data, header: authHeader(accessToken) });
}

export function updateMetering(accessToken: string, data: Metering) {
  return request<boolean>('/mes/dv/metering/update', { method: 'PUT', data, header: authHeader(accessToken) });
}

export function deleteMetering(accessToken: string, id: number) {
  return request<boolean>(`/mes/dv/metering/delete${toQuery({ id })}`, { method: 'DELETE', header: authHeader(accessToken) });
}

export function getMeteringCheckPage(accessToken: string, params: { pageNo: number; pageSize: number; meteringId?: number; checkCode?: string; checkResult?: number }) {
  return request<PageResult<MeteringCheck>>(`/mes/dv/metering-check/page${toQuery(params)}`, { header: authHeader(accessToken) });
}

export function getMeteringCheck(accessToken: string, id: number) {
  return request<MeteringCheck>(`/mes/dv/metering-check/get${toQuery({ id })}`, { header: authHeader(accessToken) });
}

export function createMeteringCheck(accessToken: string, data: MeteringCheck) {
  return request<number>('/mes/dv/metering-check/create', { method: 'POST', data, header: authHeader(accessToken) });
}

export function updateMeteringCheck(accessToken: string, data: MeteringCheck) {
  return request<boolean>('/mes/dv/metering-check/update', { method: 'PUT', data, header: authHeader(accessToken) });
}

export function deleteMeteringCheck(accessToken: string, id: number) {
  return request<boolean>(`/mes/dv/metering-check/delete${toQuery({ id })}`, { method: 'DELETE', header: authHeader(accessToken) });
}