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

/* ==================================================================
 * 产品设计（mes/pd）接口层
 * 与 web 端 mom-pro2-before/src/api/mes/pd/** 逐字对齐
 * ================================================================== */

const header = (accessToken: string) => ({ Authorization: `Bearer ${accessToken}` });

type QueryValue = string | number | boolean | string[] | undefined;

/** 过滤 undefined / ""，数组展开为多个同名参数，全部 encodeURIComponent */
function query(params: Record<string, QueryValue>) {
  const parts: string[] = [];
  Object.entries(params).forEach(([key, value]) => {
    if (value === undefined || value === null || value === "") return;
    const list = Array.isArray(value) ? value : [value];
    list.forEach(item => {
      if (item === undefined || item === null || item === "") return;
      parts.push(`${encodeURIComponent(key)}=${encodeURIComponent(String(item))}`);
    });
  });
  return parts.length ? `?${parts.join("&")}` : "";
}

/* ==================== 设计项目（/mes/pd/project） ==================== */

/** 产品设计项目 */
export interface PdProject {
  id?: number;
  /** 任务编码 */
  taskCode?: string;
  /** 任务名称 */
  taskName?: string;
  /** 产品ID（选择产品时使用，提交前需剥离） */
  productId?: number;
  /** 产品编码 */
  productCode?: string;
  /** 产品名称 */
  productName?: string;
  /** 版本号 */
  version?: string;
  /** 状态：0待发布 1待上传 2待审核 5审批中 3待归档 4已归档 */
  status?: number;
  /** 主设计师（用户ID） */
  chiefDesigner?: number;
  /** 主设计师名称 */
  chiefDesignerNickname?: string;
  /** 审核人（用户ID） */
  reviewer?: number;
  /** 审核人名称 */
  reviewerNickname?: string;
  /** 计划完成时间 */
  planFinishTime?: number;
  /** 备注 */
  remark?: string;
  /** 创建时间 */
  createTime?: number;
  /** BPM 流程实例编号 */
  processInstanceId?: string;
  /** 待审核文件数（auditStatus=0 的审核记录数） */
  pendingAuditCount?: number;
}

export interface PdProjectPageParams {
  pageNo: number;
  pageSize: number;
  taskCode?: string;
  taskName?: string;
  productCode?: string;
  productName?: string;
  status?: number;
  planFinishTime?: number[];
}

export function getPdProjectPage(accessToken: string, params: PdProjectPageParams) {
  return request<PageResult<PdProject>>(`/mes/pd/project/page${query(params)}`, { header: header(accessToken) });
}

export function getPdProject(accessToken: string, id: number) {
  return request<PdProject>(`/mes/pd/project/get${query({ id })}`, { header: header(accessToken) });
}

export function createPdProject(accessToken: string, data: PdProject) {
  return request<number>("/mes/pd/project/create", { method: "POST", data, header: header(accessToken) });
}

export function updatePdProject(accessToken: string, data: PdProject) {
  return request<boolean>("/mes/pd/project/update", { method: "PUT", data, header: header(accessToken) });
}

export function deletePdProject(accessToken: string, id: number) {
  return request<boolean>(`/mes/pd/project/delete${query({ id })}`, { method: "DELETE", header: header(accessToken) });
}

/** 发布（待发布→待上传） */
export function publishPdProject(accessToken: string, id: number) {
  return request<boolean>(`/mes/pd/project/publish${query({ id })}`, { method: "PUT", header: header(accessToken) });
}

/** 上传资料（待上传→待审核），后端自动创建资料审核记录 */
export function uploadPdProject(accessToken: string, id: number) {
  return request<boolean>(`/mes/pd/project/upload${query({ id })}`, { method: "PUT", header: header(accessToken) });
}

/** 提交审批（待审核→审批中） */
export function submitPdProjectApproval(accessToken: string, id: number, processDefinitionKey: string) {
  return request<boolean>(`/mes/pd/project/submit-approval${query({ id, processDefinitionKey })}`, {
    method: "PUT",
    header: header(accessToken),
  });
}

/** 获得审批流程列表 */
export interface PdApproveProcess {
  id: string;
  name: string;
  key: string;
}

export function getPdProjectApproveProcessList(accessToken: string) {
  return request<PdApproveProcess[]>("/mes/pd/project/approve-process-list", { header: header(accessToken) });
}

/** 归档（待归档→已归档），后端自动创建归档台账记录 */
export function archivePdProject(accessToken: string, id: number) {
  return request<boolean>(`/mes/pd/project/archive${query({ id })}`, { method: "PUT", header: header(accessToken) });
}

/* ==================== 设计资料（/mes/pd/document） ==================== */

/** 设计资料 */
export interface PdDocument {
  id?: number;
  projectId?: number;
  /** 资料类型（字典 mes_pd_document_type，字符串） */
  documentType?: string;
  documentName?: string;
  documentVersion?: string;
  fileName?: string;
  fileUrl?: string;
  uploadUserId?: number;
  uploadUserNickname?: string;
  uploadTime?: number;
  blobIds?: number[];
  attachmentList?: StorageAttachment[];
  remark?: string;
  createTime?: number;
}

export interface PdDocumentPageParams {
  pageNo: number;
  pageSize: number;
  projectId: number;
  documentType?: string;
  documentName?: string;
  documentVersion?: string;
}

export function getPdDocumentPage(accessToken: string, params: PdDocumentPageParams) {
  return request<PageResult<PdDocument>>(`/mes/pd/document/page${query(params)}`, { header: header(accessToken) });
}

export function getPdDocument(accessToken: string, id: number) {
  return request<PdDocument>(`/mes/pd/document/get${query({ id })}`, { header: header(accessToken) });
}

export function createPdDocument(accessToken: string, data: PdDocument) {
  return request<number>("/mes/pd/document/create", { method: "POST", data, header: header(accessToken) });
}

export function updatePdDocument(accessToken: string, data: PdDocument) {
  return request<boolean>("/mes/pd/document/update", { method: "PUT", data, header: header(accessToken) });
}

export function deletePdDocument(accessToken: string, id: number) {
  return request<boolean>(`/mes/pd/document/delete${query({ id })}`, { method: "DELETE", header: header(accessToken) });
}

/* ==================== 资料审核（/mes/pd/document-audit） ==================== */

/** 资料审核（上传资料时后端自动创建，前端无需调用 create） */
export interface PdDocumentAudit {
  id?: number;
  auditNo?: string;
  documentId?: number;
  documentName?: string;
  documentVersion?: string;
  reviewer?: number;
  reviewerNickname?: string;
  /** 审核状态（字典 mes_pd_document_audit_status） */
  auditStatus?: number;
  auditTime?: number;
  remark?: string;
  createTime?: number;
}

export interface PdDocumentAuditPageParams {
  pageNo: number;
  pageSize: number;
  projectId?: number;
  auditNo?: string;
  documentId?: number;
  documentName?: string;
  auditStatus?: number;
}

export function getPdDocumentAuditPage(accessToken: string, params: PdDocumentAuditPageParams) {
  return request<PageResult<PdDocumentAudit>>(`/mes/pd/document-audit/page${query(params)}`, {
    header: header(accessToken),
  });
}

export function getPdDocumentAudit(accessToken: string, id: number) {
  return request<PdDocumentAudit>(`/mes/pd/document-audit/get${query({ id })}`, { header: header(accessToken) });
}

export function updatePdDocumentAudit(accessToken: string, data: PdDocumentAudit) {
  return request<boolean>("/mes/pd/document-audit/update", { method: "PUT", data, header: header(accessToken) });
}

export function deletePdDocumentAudit(accessToken: string, id: number) {
  return request<boolean>(`/mes/pd/document-audit/delete${query({ id })}`, {
    method: "DELETE",
    header: header(accessToken),
  });
}

/* ==================== 设计 BOM（/mes/pd/bom） ==================== */

/** 设计 BOM 行 */
export interface PdBomLine {
  id?: number;
  projectId?: number;
  itemId?: number;
  itemCode?: string;
  itemName?: string;
  specification?: string;
  unitMeasureName?: string;
  quantity?: number;
  remark?: string;
  createTime?: number;
}

export interface PdBomPageParams {
  pageNo: number;
  pageSize: number;
  projectId: number;
  itemCode?: string;
  itemName?: string;
}

export function getPdBomPage(accessToken: string, params: PdBomPageParams) {
  return request<PageResult<PdBomLine>>(`/mes/pd/bom/page${query(params)}`, { header: header(accessToken) });
}

export function createPdBomLine(accessToken: string, data: PdBomLine) {
  return request<number>("/mes/pd/bom/create", { method: "POST", data, header: header(accessToken) });
}

export function updatePdBomLine(accessToken: string, data: PdBomLine) {
  return request<boolean>("/mes/pd/bom/update", { method: "PUT", data, header: header(accessToken) });
}

export function deletePdBomLine(accessToken: string, id: number) {
  return request<boolean>(`/mes/pd/bom/delete${query({ id })}`, { method: "DELETE", header: header(accessToken) });
}

/* ==================== 设计任务（/mes/pd/task） ==================== */

/** 产品设计任务 */
export interface PdTask {
  id?: number;
  code?: string;
  projectId?: number;
  projectCode?: string;
  projectName?: string;
  taskName?: string;
  taskType?: number;
  assigneeId?: number;
  assigneeName?: string;
  assignerId?: number;
  assignerName?: string;
  priority?: number;
  status?: number;
  planFinishDate?: number;
  actualFinishDate?: number;
  remark?: string;
  createTime?: number;
}

export interface PdTaskPageParams {
  pageNo: number;
  pageSize: number;
  code?: string;
  projectId?: number;
  taskName?: string;
  assigneeId?: number;
  status?: number;
}

export interface PdTaskDispatchParams {
  id: number;
  assigneeId: number;
  planFinishDate?: number;
  remark?: string;
}

export function getPdTaskPage(accessToken: string, params: PdTaskPageParams) {
  return request<PageResult<PdTask>>(`/mes/pd/task/page${query(params)}`, { header: header(accessToken) });
}

export function getPdTask(accessToken: string, id: number) {
  return request<PdTask>(`/mes/pd/task/get${query({ id })}`, { header: header(accessToken) });
}

export function createPdTask(accessToken: string, data: PdTask) {
  return request<number>("/mes/pd/task/create", { method: "POST", data, header: header(accessToken) });
}

export function updatePdTask(accessToken: string, data: PdTask) {
  return request<boolean>("/mes/pd/task/update", { method: "PUT", data, header: header(accessToken) });
}

export function deletePdTask(accessToken: string, id: number) {
  return request<boolean>(`/mes/pd/task/delete${query({ id })}`, { method: "DELETE", header: header(accessToken) });
}

export function dispatchPdTask(accessToken: string, data: PdTaskDispatchParams) {
  return request<boolean>("/mes/pd/task/dispatch", { method: "PUT", data, header: header(accessToken) });
}

export function completePdTask(accessToken: string, id: number) {
  return request<boolean>(`/mes/pd/task/complete${query({ id })}`, { method: "PUT", header: header(accessToken) });
}

/* ==================== 版本变更（/mes/pd/version-change） ==================== */

/** 版本变更 */
export interface PdVersionChange {
  id?: number;
  code?: string;
  projectId?: number;
  projectCode?: string;
  projectName?: string;
  /** 变更类型：1主版本 2次版本 3修订 */
  changeType?: number;
  fromVersion?: string;
  toVersion?: string;
  changeReason?: string;
  changeContent?: string;
  applicantId?: number;
  applicantName?: string;
  remark?: string;
  createTime?: number;
}

export interface PdVersionChangePageParams {
  pageNo: number;
  pageSize: number;
  code?: string;
  projectId?: number;
  changeType?: number;
}

export function getPdVersionChangePage(accessToken: string, params: PdVersionChangePageParams) {
  return request<PageResult<PdVersionChange>>(`/mes/pd/version-change/page${query(params)}`, {
    header: header(accessToken),
  });
}

export function getPdVersionChange(accessToken: string, id: number) {
  return request<PdVersionChange>(`/mes/pd/version-change/get${query({ id })}`, { header: header(accessToken) });
}

export function createPdVersionChange(accessToken: string, data: PdVersionChange) {
  return request<number>("/mes/pd/version-change/create", { method: "POST", data, header: header(accessToken) });
}

export function updatePdVersionChange(accessToken: string, data: PdVersionChange) {
  return request<boolean>("/mes/pd/version-change/update", { method: "PUT", data, header: header(accessToken) });
}

export function deletePdVersionChange(accessToken: string, id: number) {
  return request<boolean>(`/mes/pd/version-change/delete${query({ id })}`, {
    method: "DELETE",
    header: header(accessToken),
  });
}

export function approvePdVersionChange(accessToken: string, id: number) {
  return request<boolean>(`/mes/pd/version-change/approve${query({ id })}`, {
    method: "PUT",
    header: header(accessToken),
  });
}

/* ==================== 图纸审核（/mes/pd/drawing-review） ==================== */

/** 图纸审核 */
export interface PdDrawingReview {
  id?: number;
  code?: string;
  projectId?: number;
  projectCode?: string;
  projectName?: string;
  documentId?: number;
  documentName?: string;
  documentVersion?: string;
  reviewerId?: number;
  reviewerName?: string;
  status?: number;
  reviewComment?: string;
  reviewTime?: number;
  createTime?: number;
}

export interface PdDrawingReviewPageParams {
  pageNo: number;
  pageSize: number;
  code?: string;
  projectId?: number;
  status?: number;
  reviewerId?: number;
}

export interface PdDrawingReviewParams {
  id: number;
  status: number;
  reviewComment?: string;
}

export function getPdDrawingReviewPage(accessToken: string, params: PdDrawingReviewPageParams) {
  return request<PageResult<PdDrawingReview>>(`/mes/pd/drawing-review/page${query(params)}`, {
    header: header(accessToken),
  });
}

export function getPdDrawingReview(accessToken: string, id: number) {
  return request<PdDrawingReview>(`/mes/pd/drawing-review/get${query({ id })}`, { header: header(accessToken) });
}

export function createPdDrawingReview(accessToken: string, data: PdDrawingReview) {
  return request<number>("/mes/pd/drawing-review/create", { method: "POST", data, header: header(accessToken) });
}

export function reviewPdDrawing(accessToken: string, data: PdDrawingReviewParams) {
  return request<boolean>("/mes/pd/drawing-review/review", { method: "PUT", data, header: header(accessToken) });
}

/* ==================== 设计流程节点（/mes/pd/workflow） ==================== */

/** 设计流程节点 */
export interface PdWorkflowNode {
  id?: number;
  projectId?: number;
  nodeName?: string;
  nodeType?: string;
  operatorName?: string;
  status?: number;
  operateTime?: number;
  remark?: string;
}

export function getPdWorkflowList(accessToken: string, projectId: number) {
  return request<PdWorkflowNode[]>(`/mes/pd/workflow/list${query({ projectId })}`, {
    header: header(accessToken),
  });
}

/* ==================== 设计归档台账（/mes/pd/archive） ==================== */

/** 归档台账（分页聚合） */
export interface PdArchive {
  id?: number;
  /** 最新归档编号 */
  archiveCode?: string;
  /** 设计项目ID */
  projectId?: number;
  taskCode?: string;
  taskName?: string;
  productCode?: string;
  productName?: string;
  /** 该项目下归档记录总数 */
  archiveCount?: number;
  archiver?: number;
  archiverNickname?: string;
  /** 归档状态（字典 mes_pd_archive_status） */
  archiveStatus?: number;
  archiveTime?: number;
  remark?: string;
  createTime?: number;
  updater?: string;
  updaterNickname?: string;
  updateTime?: number;
}

export interface PdArchivePageParams {
  pageNo: number;
  pageSize: number;
  archiveCode?: string;
  projectId?: number;
  archiveStatus?: number;
  productCode?: string;
  productName?: string;
}

/** 归档详情 - 项目信息 */
export interface PdArchiveProjectInfo {
  id?: number;
  taskCode?: string;
  taskName?: string;
  productCode?: string;
  productName?: string;
  version?: string;
  status?: number;
  chiefDesigner?: number;
  chiefDesignerNickname?: string;
  reviewer?: number;
  reviewerNickname?: string;
  planFinishTime?: number;
  remark?: string;
  createTime?: number;
}

/** 归档详情 - 归档记录 */
export interface PdArchiveInfo {
  id?: number;
  archiveCode?: string;
  archiver?: number;
  archiverNickname?: string;
  archiveStatus?: number;
  archiveTime?: number;
  remark?: string;
  createTime?: number;
}

/** 归档详情 - 设计资料 */
export interface PdArchiveDocumentInfo {
  id?: number;
  documentType?: string;
  documentName?: string;
  documentVersion?: string;
  fileName?: string;
  fileUrl?: string;
  uploadUserId?: number;
  uploadUserNickname?: string;
  uploadTime?: number;
  remark?: string;
  createTime?: number;
}

/** 归档详情（按产品聚合的多项目） */
export interface PdArchiveDetailItem {
  project: PdArchiveProjectInfo;
  archives: PdArchiveInfo[];
  documents: PdArchiveDocumentInfo[];
}

export function getPdArchivePage(accessToken: string, params: PdArchivePageParams) {
  return request<PageResult<PdArchive>>(`/mes/pd/archive/page${query(params)}`, { header: header(accessToken) });
}

/** 归档台账详情（按产品编码查询，返回该产品下所有项目的归档与资料） */
export function getPdArchiveDetailByProduct(accessToken: string, productCode: string) {
  return request<PdArchiveDetailItem[]>(`/mes/pd/archive/detail-by-product${query({ productCode })}`, {
    header: header(accessToken),
  });
}

export function getPdArchive(accessToken: string, id: number) {
  return request<PdArchive>(`/mes/pd/archive/get${query({ id })}`, { header: header(accessToken) });
}

export function updatePdArchive(accessToken: string, data: PdArchive) {
  return request<boolean>("/mes/pd/archive/update", { method: "PUT", data, header: header(accessToken) });
}

export function deletePdArchive(accessToken: string, id: number) {
  return request<boolean>(`/mes/pd/archive/delete${query({ id })}`, { method: "DELETE", header: header(accessToken) });
}

/* ==================== 通用支撑（人员 / 编码 / 文件上传） ==================== */

/** 简单用户（审批人/设计师选择） */
export interface PdSimpleUser {
  id: number;
  nickname?: string;
  username?: string;
}

export function getPdSimpleUserList(accessToken: string) {
  return request<PdSimpleUser[]>("/system/user/simple-list", { header: header(accessToken) });
}

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

/** 存储文件（上传返回体） */
export interface StorageAttachment {
  id?: number;
  name?: string;
  url?: string;
  path?: string;
  size?: number;
  type?: string;
  createTime?: number;
}

/**
 * 文件上传（设计资料 blobIds）
 * 与 web 端 FileUpload 组件走同一后端接口 /system/storage-blob/upload
 */
export function uploadPdFile(accessToken: string, filePath: string) {
  return new Promise<StorageAttachment>((resolve, reject) => {
    uni.uploadFile({
      url: `${API_BASE_URL}/system/storage-blob/upload`,
      filePath,
      name: "files",
      header: { Authorization: `Bearer ${accessToken}` },
      formData: { directory: "mes/pd" },
      success: response => {
        try {
          const data = JSON.parse(response.data) as ApiResponse<StorageAttachment[]>;
          if (data.code === 0 && data.data?.[0]) resolve(data.data[0]);
          else reject(new Error(data.msg || "文件上传失败"));
        } catch {
          reject(new Error("文件上传响应解析失败"));
        }
      },
      fail: () => reject(new Error("文件上传失败，请检查网络后重试")),
    });
  });
}

/** 本地选中的待上传文件 */
export interface PickedFile {
  path: string;
  name?: string;
}

/**
 * 跨端文件选择（H5 / 微信小程序 / App 三端兼容）
 *
 * 平台差异（uni-app 官方支持矩阵）：
 * - H5     ：uni.chooseFile 可用（浏览器是 <input type="file">）
 * - 微信小程序：uni.chooseFile **不可用**；需用 uni.chooseMessageFile 从聊天记录选文件
 * - App    ：uni.chooseFile 可用
 *
 * 因此这里用条件编译分流，统一返回 { path, name }[]，调用方无需关心平台。
 */
export function choosePdFile(count = 9): Promise<PickedFile[]> {
  return new Promise((resolve, reject) => {
    const onSuccess = (files: PickedFile[]) => resolve(files);
    const onFail = (error: unknown) => reject(error);

    // #ifdef MP-WEIXIN
    uni.chooseMessageFile({
      count,
      type: "file",
      success: result => {
        onSuccess(
          (result.tempFiles || [])
            .map(item => ({ path: item.path, name: item.name }))
            .filter(item => Boolean(item.path)),
        );
      },
      fail: onFail,
    });
    // #endif

    // #ifndef MP-WEIXIN
    uni.chooseFile({
      count,
      success: result => {
        onSuccess(
          (result.tempFiles || [])
            .map(item => ({ path: item.path, name: item.name }))
            .filter(item => Boolean(item.path)),
        );
      },
      fail: onFail,
    });
    // #endif
  });
}
