import { API_BASE_URL, request, type ApiResponse } from "./request";
import type { PageResult } from "./basic-data";
import type { UserSimple } from "./purchase";

/* ==================== 基础参数（工艺参数） ==================== */

export interface PdParameter {
  id?: number;
  paramCode?: string;
  paramName?: string;
  paramType?: number;
  unitMeasureId?: number;
  unitMeasureName?: string;
  required?: boolean;
  remark?: string;
  createTime?: string;
}

/* ==================== 参数模板（工艺参数模板） ==================== */

export interface PdTemplateDetail {
  id?: number;
  templateId?: number;
  processParamId?: number;
  paramCode?: string;
  paramName?: string;
  paramType?: number;
  unitMeasureName?: string;
  required?: boolean;
  remark?: string;
}

export interface PdTemplate {
  id?: number;
  templateCode?: string;
  templateName?: string;
  templateType?: number;
  remark?: string;
  details?: PdTemplateDetail[];
  createTime?: string;
}

/* ==================== 工序设置（生产工序） ==================== */

export interface ProProcess {
  id?: number;
  code?: string;
  name?: string;
  attention?: string;
  status?: number;
  remark?: string;
  createTime?: string;
}

export interface ProProcessContent {
  id?: number;
  processId?: number;
  sort?: number;
  content?: string;
  device?: string;
  material?: string;
  docUrl?: string;
  remark?: string;
  createTime?: string;
}

export interface ProProcessParam {
  id?: number;
  processId?: number;
  processParamId?: number;
  paramCode?: string;
  paramName?: string;
  paramType?: number;
  unitMeasureId?: number;
  unitMeasureName?: string;
  required?: boolean;
  sort?: number;
  remark?: string;
}

export interface ProProcessParamSaveItem {
  processParamId: number;
  required?: boolean;
  sort?: number;
  remark?: string;
}

/* ==================== 工艺路线 ==================== */

export interface ProRoute {
  id?: number;
  code?: string;
  name?: string;
  description?: string;
  status?: number;
  remark?: string;
  createTime?: string;
}

export interface RouteProcessBomItem {
  itemId?: number;
  itemCode?: string;
  itemName?: string;
  quantity?: number;
  remark?: string;
}

export interface ProRouteProcess {
  id?: number;
  routeId?: number;
  processId?: number;
  paramTemplateId?: number;
  processCode?: string;
  processName?: string;
  sort?: number;
  nextProcessId?: number;
  nextProcessName?: string;
  linkType?: number;
  prepareTime?: number;
  waitTime?: number;
  colorCode?: string;
  keyFlag?: boolean;
  checkFlag?: boolean;
  backflushFlag?: boolean;
  outputItemId?: number;
  outputItemCode?: string;
  outputItemName?: string;
  outputItemIds?: number[];
  outputItemNames?: string;
  remark?: string;
  bomItems?: RouteProcessBomItem[];
  createTime?: string;
}

export interface RouteProduct {
  id?: number;
  routeId?: number;
  itemId?: number;
  itemCode?: string;
  itemName?: string;
  specification?: string;
  unitName?: string;
  quantity?: number;
  productionTime?: number;
  timeUnitType?: string;
  remark?: string;
  createTime?: string;
}

export interface RouteProductBom {
  id?: number;
  routeId?: number;
  processId?: number;
  productId?: number;
  itemId?: number;
  itemCode?: string;
  itemName?: string;
  specification?: string;
  unitName?: string;
  quantity?: number;
  remark?: string;
  createTime?: string;
}

/* ==================== 物料 / 产品 BOM ==================== */

export interface MdProductBom {
  id?: number;
  itemId?: number;
  bomItemId?: number;
  bomItemCode?: string;
  bomItemName?: string;
  bomItemSpecification?: string;
  unitMeasureName?: string;
  quantity?: number;
  status?: number;
  remark?: string;
  itemOrProduct?: string;
}

type QueryValue = string | number | boolean | string[] | undefined;
const header = (accessToken: string) => ({ Authorization: `Bearer ${accessToken}` });
function query(params: Record<string, QueryValue>) {
  const content = Object.entries(params)
    .filter(([, value]) => value !== undefined && value !== "")
    .flatMap(([key, value]) =>
      Array.isArray(value)
        ? value.map(item => `${encodeURIComponent(key)}=${encodeURIComponent(String(item))}`)
        : [`${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`],
    )
    .join("&");
  return content ? `?${content}` : "";
}

/** 生成 MES 编码 */
export function generateAutoCode(accessToken: string, ruleCode: string) {
  return request<string>("/mes/md/auto-code-record/generate", {
    method: "POST",
    data: { ruleCode },
    header: header(accessToken),
  });
}

/* ---------------- 基础参数 ---------------- */

export function getParameterPage(
  accessToken: string,
  params: { pageNo: number; pageSize: number; paramCode?: string; paramName?: string; paramType?: number },
) {
  return request<PageResult<PdParameter>>(`/mes/pd/process-param/page${query(params)}`, {
    header: header(accessToken),
  });
}
export function getParameterSimpleList(accessToken: string) {
  return request<PdParameter[]>("/mes/pd/process-param/simple-list", { header: header(accessToken) });
}
export function getParameter(accessToken: string, id: number) {
  return request<PdParameter>(`/mes/pd/process-param/get${query({ id })}`, { header: header(accessToken) });
}
export function createParameter(accessToken: string, data: PdParameter) {
  return request<number>("/mes/pd/process-param/create", { method: "POST", data, header: header(accessToken) });
}
export function updateParameter(accessToken: string, data: PdParameter) {
  return request<boolean>("/mes/pd/process-param/update", { method: "PUT", data, header: header(accessToken) });
}
export function deleteParameter(accessToken: string, id: number) {
  return request<boolean>(`/mes/pd/process-param/delete${query({ id })}`, {
    method: "DELETE",
    header: header(accessToken),
  });
}

/* ---------------- 参数模板 ---------------- */

export function getTemplatePage(
  accessToken: string,
  params: { pageNo: number; pageSize: number; templateCode?: string; templateName?: string; templateType?: number },
) {
  return request<PageResult<PdTemplate>>(`/mes/pd/process-param-template/page${query(params)}`, {
    header: header(accessToken),
  });
}
export function getTemplate(accessToken: string, id: number) {
  return request<PdTemplate>(`/mes/pd/process-param-template/get${query({ id })}`, {
    header: header(accessToken),
  });
}
export function createTemplate(accessToken: string, data: PdTemplate) {
  return request<number>("/mes/pd/process-param-template/create", {
    method: "POST",
    data,
    header: header(accessToken),
  });
}
export function updateTemplate(accessToken: string, data: PdTemplate) {
  return request<boolean>("/mes/pd/process-param-template/update", {
    method: "PUT",
    data,
    header: header(accessToken),
  });
}
export function deleteTemplate(accessToken: string, id: number) {
  return request<boolean>(`/mes/pd/process-param-template/delete${query({ id })}`, {
    method: "DELETE",
    header: header(accessToken),
  });
}

/* ---------------- 工序设置 ---------------- */

export function getProcessPage(
  accessToken: string,
  params: { pageNo: number; pageSize: number; code?: string; name?: string; status?: number },
) {
  return request<PageResult<ProProcess>>(`/mes/pro/process/page${query(params)}`, {
    header: header(accessToken),
  });
}
export function getProcessSimpleList(accessToken: string) {
  return request<ProProcess[]>("/mes/pro/process/simple-list", { header: header(accessToken) });
}
export function getProcess(accessToken: string, id: number) {
  return request<ProProcess>(`/mes/pro/process/get${query({ id })}`, { header: header(accessToken) });
}
export function createProcess(accessToken: string, data: ProProcess) {
  return request<number>("/mes/pro/process/create", { method: "POST", data, header: header(accessToken) });
}
export function updateProcess(accessToken: string, data: ProProcess) {
  return request<boolean>("/mes/pro/process/update", { method: "PUT", data, header: header(accessToken) });
}
export function deleteProcess(accessToken: string, id: number) {
  return request<boolean>(`/mes/pro/process/delete${query({ id })}`, { method: "DELETE", header: header(accessToken) });
}

/* ---------------- 工序操作步骤 ---------------- */

export function getProcessContentList(accessToken: string, processId: number) {
  return request<ProProcessContent[]>(`/mes/pro/process-content/list-by-process${query({ processId })}`, {
    header: header(accessToken),
  });
}
export function getProcessContent(accessToken: string, id: number) {
  return request<ProProcessContent>(`/mes/pro/process-content/get${query({ id })}`, {
    header: header(accessToken),
  });
}
export function createProcessContent(accessToken: string, data: ProProcessContent) {
  return request<number>("/mes/pro/process-content/create", { method: "POST", data, header: header(accessToken) });
}
export function updateProcessContent(accessToken: string, data: ProProcessContent) {
  return request<boolean>("/mes/pro/process-content/update", { method: "PUT", data, header: header(accessToken) });
}
export function deleteProcessContent(accessToken: string, id: number) {
  return request<boolean>(`/mes/pro/process-content/delete${query({ id })}`, {
    method: "DELETE",
    header: header(accessToken),
  });
}

/* ---------------- 工序-工艺参数绑定 ---------------- */

export function getProcessParamListByProcess(accessToken: string, processId: number) {
  return request<ProProcessParam[]>(`/mes/pro/process-param/list-by-process${query({ processId })}`, {
    header: header(accessToken),
  });
}
export function updateProcessParams(accessToken: string, processId: number, items: ProProcessParamSaveItem[]) {
  return request<boolean>("/mes/pro/process-param/update-bindings", {
    method: "POST",
    data: { processId, items },
    header: header(accessToken),
  });
}
export function getProcessListByParam(accessToken: string, paramId: number) {
  return request<ProProcess[]>(`/mes/pro/process-param/list-by-param${query({ paramId })}`, {
    header: header(accessToken),
  });
}

/* ---------------- 工艺路线 ---------------- */

export function getRoutePage(
  accessToken: string,
  params: { pageNo: number; pageSize: number; code?: string; name?: string; status?: number },
) {
  return request<PageResult<ProRoute>>(`/mes/pro/route/page${query(params)}`, { header: header(accessToken) });
}
export function getRouteSimpleList(accessToken: string) {
  return request<ProRoute[]>("/mes/pro/route/simple-list", { header: header(accessToken) });
}
export function getRoute(accessToken: string, id: number) {
  return request<ProRoute>(`/mes/pro/route/get${query({ id })}`, { header: header(accessToken) });
}
export function createRoute(accessToken: string, data: ProRoute) {
  return request<number>("/mes/pro/route/create", { method: "POST", data, header: header(accessToken) });
}
export function updateRoute(accessToken: string, data: ProRoute) {
  return request<boolean>("/mes/pro/route/update", { method: "PUT", data, header: header(accessToken) });
}
export function updateRouteStatus(accessToken: string, id: number, status: number) {
  return request<boolean>(`/mes/pro/route/update-status${query({ id, status })}`, {
    method: "PUT",
    header: header(accessToken),
  });
}
export function deleteRoute(accessToken: string, id: number) {
  return request<boolean>(`/mes/pro/route/delete${query({ id })}`, { method: "DELETE", header: header(accessToken) });
}

/* ---------------- 工艺路线工序 ---------------- */

export function getRouteProcessListByRoute(accessToken: string, routeId: number) {
  return request<ProRouteProcess[]>(`/mes/pro/route-process/list-by-route${query({ routeId })}`, {
    header: header(accessToken),
  });
}
export function getRouteProcessListByProduct(accessToken: string, productId: number) {
  return request<ProRouteProcess[]>(`/mes/pro/route-process/list-by-product${query({ productId })}`, {
    header: header(accessToken),
  });
}
export function getRouteProcess(accessToken: string, id: number) {
  return request<ProRouteProcess>(`/mes/pro/route-process/get${query({ id })}`, {
    header: header(accessToken),
  });
}
export function getRouteProcessByRouteAndProcess(accessToken: string, routeId: number, processId: number) {
  return request<ProRouteProcess>(`/mes/pro/route-process/get-by-route-and-process${query({ routeId, processId })}`, {
    header: header(accessToken),
  });
}
export function createRouteProcess(accessToken: string, data: ProRouteProcess) {
  return request<number>("/mes/pro/route-process/create", { method: "POST", data, header: header(accessToken) });
}
export function updateRouteProcess(accessToken: string, data: ProRouteProcess) {
  return request<boolean>("/mes/pro/route-process/update", { method: "PUT", data, header: header(accessToken) });
}
export function deleteRouteProcess(accessToken: string, id: number) {
  return request<boolean>(`/mes/pro/route-process/delete${query({ id })}`, {
    method: "DELETE",
    header: header(accessToken),
  });
}

/* ---------------- 工艺路线产品 ---------------- */

export function getRouteProductListByRoute(accessToken: string, routeId: number) {
  return request<RouteProduct[]>(`/mes/pro/route-product/list-by-route${query({ routeId })}`, {
    header: header(accessToken),
  });
}
export function getRouteProduct(accessToken: string, id: number) {
  return request<RouteProduct>(`/mes/pro/route-product/get${query({ id })}`, {
    header: header(accessToken),
  });
}
export function createRouteProduct(accessToken: string, data: RouteProduct) {
  return request<number>("/mes/pro/route-product/create", { method: "POST", data, header: header(accessToken) });
}
export function updateRouteProduct(accessToken: string, data: RouteProduct) {
  return request<boolean>("/mes/pro/route-product/update", { method: "PUT", data, header: header(accessToken) });
}
export function deleteRouteProduct(accessToken: string, id: number) {
  return request<boolean>(`/mes/pro/route-product/delete${query({ id })}`, {
    method: "DELETE",
    header: header(accessToken),
  });
}

/* ---------------- 工艺路线产品 BOM（投入物料） ---------------- */

export function getRouteProductBomList(
  accessToken: string,
  params: { routeId: number; processId?: number; productId?: number },
) {
  return request<RouteProductBom[]>(`/mes/pro/route-product-bom/list${query(params)}`, {
    header: header(accessToken),
  });
}
export function getRouteProductBom(accessToken: string, id: number) {
  return request<RouteProductBom>(`/mes/pro/route-product-bom/get${query({ id })}`, {
    header: header(accessToken),
  });
}
export function createRouteProductBom(accessToken: string, data: RouteProductBom) {
  return request<number>("/mes/pro/route-product-bom/create", {
    method: "POST",
    data,
    header: header(accessToken),
  });
}
export function updateRouteProductBom(accessToken: string, data: RouteProductBom) {
  return request<boolean>("/mes/pro/route-product-bom/update", {
    method: "PUT",
    data,
    header: header(accessToken),
  });
}
export function deleteRouteProductBom(accessToken: string, id: number) {
  return request<boolean>(`/mes/pro/route-product-bom/delete${query({ id })}`, {
    method: "DELETE",
    header: header(accessToken),
  });
}

/* ---------------- 产品 BOM（BOM 物料数据源） ---------------- */

export function getProductBomListByItemId(accessToken: string, itemId: number) {
  return request<MesProductBom[]>(`/mes/md/product-bom/list-by-item-id${query({ itemId })}`, {
    header: header(accessToken),
  });
}

/* ---------------- MES 物料产品（物料选择器数据源，与 web 端 MdItemSelect 一致） ---------------- */

export interface MesMdItem {
  id?: number;
  code?: string;
  name?: string;
  specification?: string;
  unitMeasureId?: number;
  unitMeasureName?: string;
  itemTypeId?: number;
  itemTypeName?: string;
  itemOrProduct?: string;
  status?: number;
  safeStockFlag?: boolean;
  minStock?: number;
  maxStock?: number;
  highValue?: boolean;
  batchFlag?: boolean;
  remark?: string;
  createTime?: string;
}

export interface MesWorkshop {
  id?: number;
  code?: string;
  name?: string;
  area?: number;
  chargeUserId?: number;
  chargeUserName?: string;
  status?: number;
  remark?: string;
  createTime?: string;
}

export interface MesWorkstation {
  id?: number;
  code?: string;
  name?: string;
  address?: string;
  workshopId?: number;
  workshopName?: string;
  processId?: number;
  processName?: string;
  warehouseId?: number;
  warehouseName?: string;
  locationId?: number;
  locationName?: string;
  areaId?: number;
  areaName?: string;
  status?: number;
  remark?: string;
  createTime?: string;
}

export interface MesProductBom {
  id?: number;
  itemId?: number;
  bomItemId?: number;
  quantity?: number;
  status?: number;
  remark?: string;
  createTime?: string;
  bomItemCode?: string;
  bomItemName?: string;
  bomItemSpecification?: string;
  unitMeasureName?: string;
  itemOrProduct?: string;
}

export interface MesBatchConfig {
  id?: number;
  itemId?: number;
  produceDateFlag?: boolean;
  expireDateFlag?: boolean;
  receiptDateFlag?: boolean;
  vendorFlag?: boolean;
  clientFlag?: boolean;
  salesOrderCodeFlag?: boolean;
  purchaseOrderCodeFlag?: boolean;
  workorderFlag?: boolean;
  taskFlag?: boolean;
  workstationFlag?: boolean;
  toolFlag?: boolean;
  moldFlag?: boolean;
  lotNumberFlag?: boolean;
  qualityStatusFlag?: boolean;
}

export interface ProductMedia {
  id?: number;
  itemId?: number;
  sort?: number;
  processId?: number;
  processCode?: string;
  processName?: string;
  title?: string;
  description?: string;
  url?: string;
  remark?: string;
  createTime?: string;
}
export interface StorageFile {
  id: number;
  name?: string;
  url?: string;
  previewURL?: string;
  downloadURL?: string;
}

export interface WorkstationMachine {
  id?: number;
  workstationId?: number;
  machineryId?: number;
  machineryCode?: string;
  machineryName?: string;
  quantity?: number;
  remark?: string;
  createTime?: string;
}

export interface WorkstationTool {
  id?: number;
  workstationId?: number;
  toolTypeId?: number;
  toolTypeName?: string;
  quantity?: number;
  remark?: string;
  createTime?: string;
}

export interface WorkstationWorker {
  id?: number;
  workstationId?: number;
  postId?: number;
  postName?: string;
  quantity?: number;
  remark?: string;
  createTime?: string;
}

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

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

export function getMesItemPage(
  accessToken: string,
  params: { pageNo: number; pageSize: number; code?: string; name?: string; status?: number; ids?: string; itemTypeId?: number },
) {
  return request<PageResult<MesMdItem>>(`/mes/md/item/page${query(params)}`, { header: header(accessToken) });
}
export function getMesItem(accessToken: string, id: number) {
  return request<MesMdItem>(`/mes/md/item/get${query({ id })}`, { header: header(accessToken) });
}
export function createMesItem(accessToken: string, data: MesMdItem) {
  return request<number>("/mes/md/item/create", { method: "POST", data, header: header(accessToken) });
}
export function updateMesItem(accessToken: string, data: MesMdItem) {
  return request<boolean>("/mes/md/item/update", { method: "PUT", data, header: header(accessToken) });
}
export function deleteMesItem(accessToken: string, id: number) {
  return request<boolean>(`/mes/md/item/delete${query({ id })}`, { method: "DELETE", header: header(accessToken) });
}

export function getWorkshopPage(
  accessToken: string,
  params: { pageNo: number; pageSize: number; code?: string; name?: string; status?: number },
) {
  return request<PageResult<MesWorkshop>>(`/mes/md-workshop/page${query(params)}`, { header: header(accessToken) });
}
export function getWorkshopSimpleList(accessToken: string) {
  return request<MesWorkshop[]>("/mes/md-workshop/simple-list", { header: header(accessToken) });
}
export function getWorkshop(accessToken: string, id: number) {
  return request<MesWorkshop>(`/mes/md-workshop/get${query({ id })}`, { header: header(accessToken) });
}
export function createWorkshop(accessToken: string, data: MesWorkshop) {
  return request<number>("/mes/md-workshop/create", { method: "POST", data, header: header(accessToken) });
}
export function updateWorkshop(accessToken: string, data: MesWorkshop) {
  return request<boolean>("/mes/md-workshop/update", { method: "PUT", data, header: header(accessToken) });
}
export function deleteWorkshop(accessToken: string, id: number) {
  return request<boolean>(`/mes/md-workshop/delete${query({ id })}`, { method: "DELETE", header: header(accessToken) });
}

export function getWorkstationPage(
  accessToken: string,
  params: { pageNo: number; pageSize: number; code?: string; name?: string; workshopId?: number; processId?: number; status?: number },
) {
  return request<PageResult<MesWorkstation>>(`/mes/md-workstation/page${query(params)}`, { header: header(accessToken) });
}
export function getWorkstation(accessToken: string, id: number) {
  return request<MesWorkstation>(`/mes/md-workstation/get${query({ id })}`, { header: header(accessToken) });
}
export function createWorkstation(accessToken: string, data: MesWorkstation) {
  return request<number>("/mes/md-workstation/create", { method: "POST", data, header: header(accessToken) });
}
export function updateWorkstation(accessToken: string, data: MesWorkstation) {
  return request<boolean>("/mes/md-workstation/update", { method: "PUT", data, header: header(accessToken) });
}
export function deleteWorkstation(accessToken: string, id: number) {
  return request<boolean>(`/mes/md-workstation/delete${query({ id })}`, { method: "DELETE", header: header(accessToken) });
}

export function createProductBom(accessToken: string, data: MesProductBom) {
  return request<number>("/mes/md/product-bom/create", { method: "POST", data, header: header(accessToken) });
}
export function updateProductBom(accessToken: string, data: MesProductBom) {
  return request<boolean>("/mes/md/product-bom/update", { method: "PUT", data, header: header(accessToken) });
}
export function deleteProductBom(accessToken: string, id: number) {
  return request<boolean>(`/mes/md/product-bom/delete${query({ id })}`, { method: "DELETE", header: header(accessToken) });
}
export function getBatchConfigByItemId(accessToken: string, itemId: number) {
  return request<MesBatchConfig>(`/mes/md/item-batch-config/get-by-item-id${query({ itemId })}`, { header: header(accessToken) });
}
export function saveBatchConfig(accessToken: string, data: MesBatchConfig) {
  return request<number>("/mes/md/item-batch-config/save", { method: "POST", data, header: header(accessToken) });
}
export function uploadMesFile(accessToken: string, filePath: string) {
  return new Promise<StorageFile>((resolve, reject) =>
    uni.uploadFile({
      url: `${API_BASE_URL}/system/storage-blob/upload`,
      filePath,
      name: "files",
      header: header(accessToken),
      success: response => {
        try {
          const data = JSON.parse(response.data) as ApiResponse<StorageFile[]>;
          if ((data.code === 0 || data.code === 200) && data.data?.[0]) resolve(data.data[0]);
          else reject(new Error(data.msg || "文件上传失败"));
        } catch {
          reject(new Error("文件上传响应解析失败"));
        }
      },
      fail: () => reject(new Error("文件上传失败，请检查网络后重试")),
    }),
  );
}
export function getProductSipListByItemId(accessToken: string, itemId: number) {
  return request<ProductMedia[]>(`/mes/md/product-sip/list-by-item-id${query({ itemId })}`, { header: header(accessToken) });
}
export function createProductSip(accessToken: string, data: ProductMedia) {
  return request<number>("/mes/md/product-sip/create", { method: "POST", data, header: header(accessToken) });
}
export function updateProductSip(accessToken: string, data: ProductMedia) {
  return request<boolean>("/mes/md/product-sip/update", { method: "PUT", data, header: header(accessToken) });
}
export function deleteProductSip(accessToken: string, id: number) {
  return request<boolean>(`/mes/md/product-sip/delete${query({ id })}`, { method: "DELETE", header: header(accessToken) });
}
export function getProductSopListByItemId(accessToken: string, itemId: number) {
  return request<ProductMedia[]>(`/mes/md/product-sop/list-by-item-id${query({ itemId })}`, { header: header(accessToken) });
}
export function createProductSop(accessToken: string, data: ProductMedia) {
  return request<number>("/mes/md/product-sop/create", { method: "POST", data, header: header(accessToken) });
}
export function updateProductSop(accessToken: string, data: ProductMedia) {
  return request<boolean>("/mes/md/product-sop/update", { method: "PUT", data, header: header(accessToken) });
}
export function deleteProductSop(accessToken: string, id: number) {
  return request<boolean>(`/mes/md/product-sop/delete${query({ id })}`, { method: "DELETE", header: header(accessToken) });
}

export function getWorkstationMachineList(accessToken: string, workstationId: number) {
  return request<WorkstationMachine[]>(`/mes/md-workstation-machine/list-by-workstation${query({ workstationId })}`, { header: header(accessToken) });
}
export function createWorkstationMachine(accessToken: string, data: WorkstationMachine) {
  return request<number>("/mes/md-workstation-machine/create", { method: "POST", data, header: header(accessToken) });
}
export function deleteWorkstationMachine(accessToken: string, id: number) {
  return request<boolean>(`/mes/md-workstation-machine/delete${query({ id })}`, { method: "DELETE", header: header(accessToken) });
}
export function getToolTypeSimpleList(accessToken: string) {
  return request<ToolTypeSimple[]>("/mes/tm/tool-type/simple-list", { header: header(accessToken) });
}
export function getWorkstationToolList(accessToken: string, workstationId: number) {
  return request<WorkstationTool[]>(`/mes/md-workstation-tool/list-by-workstation${query({ workstationId })}`, { header: header(accessToken) });
}
export function createWorkstationTool(accessToken: string, data: WorkstationTool) {
  return request<number>("/mes/md-workstation-tool/create", { method: "POST", data, header: header(accessToken) });
}
export function updateWorkstationTool(accessToken: string, data: WorkstationTool) {
  return request<boolean>("/mes/md-workstation-tool/update", { method: "PUT", data, header: header(accessToken) });
}
export function deleteWorkstationTool(accessToken: string, id: number) {
  return request<boolean>(`/mes/md-workstation-tool/delete${query({ id })}`, { method: "DELETE", header: header(accessToken) });
}
export function getSimplePostList(accessToken: string) {
  return request<PostSimple[]>("/system/post/simple-list", { header: header(accessToken) });
}
export function getWorkstationWorkerList(accessToken: string, workstationId: number) {
  return request<WorkstationWorker[]>(`/mes/md-workstation-worker/list-by-workstation${query({ workstationId })}`, { header: header(accessToken) });
}
export function getUserListByWorkstationId(accessToken: string, workstationId?: number) {
  if (!workstationId) return Promise.resolve([] as UserSimple[]);
  return request<UserSimple[]>(`/mes/md-workstation-worker/list-user-by-workstation${query({ workstationId })}`, { header: header(accessToken) });
}
export function createWorkstationWorker(accessToken: string, data: WorkstationWorker) {
  return request<number>("/mes/md-workstation-worker/create", { method: "POST", data, header: header(accessToken) });
}
export function updateWorkstationWorker(accessToken: string, data: WorkstationWorker) {
  return request<boolean>("/mes/md-workstation-worker/update", { method: "PUT", data, header: header(accessToken) });
}
export function deleteWorkstationWorker(accessToken: string, id: number) {
  return request<boolean>(`/mes/md-workstation-worker/delete${query({ id })}`, { method: "DELETE", header: header(accessToken) });
}