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

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

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

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("&")}` : "";
}

/* ---------- 通用结构 ---------- */

export interface BpmUser {
  id?: number;
  username?: string;
  nickname?: string;
  mobile?: string;
  avatar?: string;
  deptId?: number;
}

export interface BpmSummaryItem {
  key?: string;
  value?: string;
}

/** 流程分类（/bpm/category/simple-list） */
export interface BpmCategory {
  id?: number;
  name?: string;
  code?: string;
  status?: number;
  description?: string;
  sort?: number;
}

/** 表单字段权限：'1' 只读 / '2' 可写 / '3' 隐藏 */
export type BpmFieldPermission = Record<string, string>;

/** 流程定义（/bpm/process-definition/*） */
export interface BpmProcessDefinition {
  id?: string;
  key?: string;
  name?: string;
  description?: string;
  category?: string;
  icon?: string;
  /** 10 BPMN / 20 SIMPLE */
  modelType?: number;
  /** 10 流程表单 / 20 业务表单 */
  formType?: number;
  formCustomCreatePath?: string;
  formCustomViewPath?: string;
  /** 表单全局配置（JSON 字符串） */
  formConf?: string;
  /** 表单字段规则（每条为 JSON 字符串） */
  formFields?: string[];
  suspensionState?: number;
  version?: number;
}

/** 流程实例（/bpm/process-instance/*） */
export interface BpmProcessInstance {
  id?: string;
  name?: string;
  summary?: BpmSummaryItem[];
  category?: string;
  categoryName?: string;
  /** -1 未开始 / 1 审批中 / 2 通过 / 3 不通过 / 4 已取消 */
  status?: number;
  /** 毫秒时间戳，部分接口返回 "yyyy-MM-dd HH:mm:ss" 字符串 */
  startTime?: number | string;
  endTime?: number | string;
  createTime?: number | string;
  processDefinitionId?: string;
  processDefinitionKey?: string;
  processDefinition?: BpmProcessDefinition;
  startUser?: BpmUser;
  /** 字段名 -> 值 */
  formVariables?: Record<string, any>;
  businessKey?: string;
  tasks?: BpmTask[];
}

/** 任务（/bpm/task/*） */
export interface BpmTask {
  id?: string;
  name?: string;
  /** 0 待审批 / 1 审批中 / 2 通过 / 3 不通过 / 4 已取消 / 5 退回 / 7 审批通过中 */
  status?: number;
  /** 毫秒时间戳，部分接口返回 "yyyy-MM-dd HH:mm:ss" 字符串 */
  createTime?: number | string;
  endTime?: number | string;
  startTime?: number | string;
  durationInMillis?: number;
  reason?: string;
  processInstanceId?: string;
  processInstance?: BpmProcessInstance;
  taskDefinitionKey?: string;
  assigneeUser?: BpmUser;
  ownerUser?: BpmUser;
  formId?: number;
  signEnable?: boolean;
  children?: BpmTask[];
  buttonsSetting?: Record<string, { enable?: boolean; displayName?: string }>;
}

/** 抄送（/bpm/process-instance/copy/page） */
export interface BpmProcessInstanceCopy {
  id?: number;
  activityId?: string;
  activityName?: string;
  createTime?: number | string;
  createUser?: BpmUser;
  processInstanceId?: string;
  processInstanceName?: string;
  processInstanceStartTime?: number | string;
  reason?: string;
  startUser?: BpmUser;
  summary?: BpmSummaryItem[];
  taskId?: string;
}

/** 审批节点（时间线 / 流转记录） */
export interface BpmApprovalNode {
  id?: string;
  name?: string;
  nodeType?: number;
  candidateStrategy?: number;
  candidateUsers?: BpmUser[];
  status?: number;
  /** 毫秒时间戳，部分接口返回 "yyyy-MM-dd HH:mm:ss" 字符串 */
  startTime?: number | string;
  endTime?: number | string;
  processInstanceId?: string;
  tasks?: BpmApprovalTaskInfo[];
}

export interface BpmApprovalTaskInfo {
  id?: number;
  assigneeUser?: BpmUser;
  ownerUser?: BpmUser;
  reason?: string;
  signPicUrl?: string;
  status?: number;
  attachments?: string[];
}

/** 审批详情（/bpm/process-instance/get-approval-detail） */
export interface BpmApprovalDetail {
  activityNodes?: BpmApprovalNode[];
  formFieldsPermission?: BpmFieldPermission;
  processDefinition?: BpmProcessDefinition;
  processInstance?: BpmProcessInstance;
  status?: number;
  todoTask?: BpmTask;
}

/* ---------- 字典数据（复用 crm 的通用字典接口） ---------- */

export { getSimpleDictDataList, type DictData } from "./crm";

/* ---------- 用户 ---------- */

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

export function getBpmUserPage(accessToken: string, params: { pageNo: number; pageSize: number; nickname?: string; username?: string; mobile?: string; status?: number }) {
  return request<PageResult<BpmUser>>(`/system/user/page${query(params)}`, { header: header(accessToken) });
}

export function getBpmUserListByIds(accessToken: string, ids: number[]) {
  return request<BpmUser[]>(`/system/user/list${query({ ids: ids.join(",") })}`, { header: header(accessToken) });
}

/** 部门树（发起流程候选人、部门选择器用） */
export interface BpmDept {
  id?: number;
  name?: string;
  parentId?: number;
  children?: BpmDept[];
}

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

/* ---------- 流程分类 ---------- */

export function getCategorySimpleList(accessToken: string) {
  return request<BpmCategory[]>("/bpm/category/simple-list", { header: header(accessToken) });
}

export function getCategoryPage(accessToken: string, params: { pageNo: number; pageSize: number; name?: string }) {
  return request<PageResult<BpmCategory>>(`/bpm/category/page${query(params)}`, {
    header: header(accessToken),
  });
}

export function getCategory(accessToken: string, id: number) {
  return request<BpmCategory>(`/bpm/category/get${query({ id })}`, { header: header(accessToken) });
}

export function createCategory(accessToken: string, data: BpmCategory) {
  return request<number>("/bpm/category/create", { method: "POST", data, header: header(accessToken) });
}

export function updateCategory(accessToken: string, data: BpmCategory) {
  return request<boolean>("/bpm/category/update", { method: "PUT", data, header: header(accessToken) });
}

export function deleteCategory(accessToken: string, id: number) {
  return request<boolean>(`/bpm/category/delete${query({ id })}`, { method: "DELETE", header: header(accessToken) });
}

export interface BpmFormConfig {
  id?: number;
  name: string;
  conf?: string;
  fields?: string[];
  status?: number;
  remark?: string;
  createTime?: number | string;
}

export function getFormPage(accessToken: string, params: { pageNo: number; pageSize: number; name?: string }) {
  return request<PageResult<BpmFormConfig>>(`/bpm/form/page${query(params)}`, { header: header(accessToken) });
}

export function getForm(accessToken: string, id: number) {
  return request<BpmFormConfig>(`/bpm/form/get${query({ id })}`, { header: header(accessToken) });
}

export function createForm(accessToken: string, data: BpmFormConfig) {
  return request<number>("/bpm/form/create", { method: "POST", data, header: header(accessToken) });
}

export function updateForm(accessToken: string, data: BpmFormConfig) {
  return request<boolean>("/bpm/form/update", { method: "PUT", data, header: header(accessToken) });
}

export function deleteForm(accessToken: string, id: number) {
  return request<boolean>(`/bpm/form/delete${query({ id })}`, { method: "DELETE", header: header(accessToken) });
}

export function getFormSimpleList(accessToken: string) {
  return request<BpmFormConfig[]>("/bpm/form/simple-list", { header: header(accessToken) });
}

export interface BpmModelProcessDefinition {
  id?: string;
  key?: string;
  version?: number;
  deploymentTime?: number | string;
  suspensionState?: number;
}

export interface BpmModel {
  id?: number;
  key: string;
  name: string;
  icon?: string;
  description?: string;
  category?: string;
  formName?: string;
  formType?: number;
  formId?: number;
  formCustomCreatePath?: string;
  formCustomViewPath?: string;
  processDefinition?: BpmModelProcessDefinition;
  status?: number;
  remark?: string;
  createTime?: string;
  bpmnXml?: string;
  startUsers?: BpmUser[];
}

export function getModelList(accessToken: string, name?: string) {
  return request<BpmModel[]>(`/bpm/model/list${query({ name })}`, { header: header(accessToken) });
}

export function getModel(accessToken: string, id: number | string) {
  return request<BpmModel>(`/bpm/model/get${query({ id: String(id) })}`, { header: header(accessToken) });
}

export function createModel(accessToken: string, data: BpmModel) {
  return request<number>("/bpm/model/create", { method: "POST", data, header: header(accessToken) });
}

export function updateModel(accessToken: string, data: BpmModel) {
  return request<boolean>("/bpm/model/update", { method: "PUT", data, header: header(accessToken) });
}

export function updateModelState(accessToken: string, id: number, state: number) {
  return request<boolean>("/bpm/model/update-state", {
    method: "PUT",
    data: { id, state },
    header: header(accessToken),
  });
}

export function deployModel(accessToken: string, id: number) {
  return request<boolean>(`/bpm/model/deploy${query({ id })}`, { method: "POST", header: header(accessToken) });
}

export function cleanModel(accessToken: string, id: number) {
  return request<boolean>(`/bpm/model/clean${query({ id })}`, { method: "DELETE", header: header(accessToken) });
}

export function deleteModel(accessToken: string, id: number) {
  return request<boolean>(`/bpm/model/delete${query({ id })}`, { method: "DELETE", header: header(accessToken) });
}

export interface BpmUserGroup {
  id?: number;
  name: string;
  description?: string;
  userIds?: number[];
  status?: number;
  remark?: string;
  createTime?: string;
}

export function getUserGroupPage(accessToken: string, params: { pageNo: number; pageSize: number; name?: string }) {
  return request<PageResult<BpmUserGroup>>(`/bpm/user-group/page${query(params)}`, {
    header: header(accessToken),
  });
}

export function getUserGroup(accessToken: string, id: number) {
  return request<BpmUserGroup>(`/bpm/user-group/get${query({ id })}`, { header: header(accessToken) });
}

export function createUserGroup(accessToken: string, data: BpmUserGroup) {
  return request<number>("/bpm/user-group/create", { method: "POST", data, header: header(accessToken) });
}

export function updateUserGroup(accessToken: string, data: BpmUserGroup) {
  return request<boolean>("/bpm/user-group/update", { method: "PUT", data, header: header(accessToken) });
}

export function deleteUserGroup(accessToken: string, id: number) {
  return request<boolean>(`/bpm/user-group/delete${query({ id })}`, { method: "DELETE", header: header(accessToken) });
}

export interface BpmProcessListener {
  id?: number;
  name: string;
  type?: number;
  status?: number;
  event?: string;
  valueType?: number;
  value?: string;
  createTime?: number | string;
}

export function getProcessListenerPage(accessToken: string, params: { pageNo: number; pageSize: number; name?: string }) {
  return request<PageResult<BpmProcessListener>>(`/bpm/process-listener/page${query(params)}`, { header: header(accessToken) });
}

export function getProcessListener(accessToken: string, id: number) {
  return request<BpmProcessListener>(`/bpm/process-listener/get${query({ id })}`, { header: header(accessToken) });
}

export function createProcessListener(accessToken: string, data: BpmProcessListener) {
  return request<number>("/bpm/process-listener/create", { method: "POST", data, header: header(accessToken) });
}

export function updateProcessListener(accessToken: string, data: BpmProcessListener) {
  return request<boolean>("/bpm/process-listener/update", { method: "PUT", data, header: header(accessToken) });
}

export function deleteProcessListener(accessToken: string, id: number) {
  return request<boolean>(`/bpm/process-listener/delete${query({ id })}`, { method: "DELETE", header: header(accessToken) });
}

export interface BpmProcessExpression {
  id?: number;
  name: string;
  status?: number;
  expression?: string;
  createTime?: number | string;
}

export function getProcessExpressionPage(accessToken: string, params: { pageNo: number; pageSize: number; name?: string }) {
  return request<PageResult<BpmProcessExpression>>(`/bpm/process-expression/page${query(params)}`, { header: header(accessToken) });
}

export function getProcessExpression(accessToken: string, id: number) {
  return request<BpmProcessExpression>(`/bpm/process-expression/get${query({ id })}`, { header: header(accessToken) });
}

export function createProcessExpression(accessToken: string, data: BpmProcessExpression) {
  return request<number>("/bpm/process-expression/create", { method: "POST", data, header: header(accessToken) });
}

export function updateProcessExpression(accessToken: string, data: BpmProcessExpression) {
  return request<boolean>("/bpm/process-expression/update", { method: "PUT", data, header: header(accessToken) });
}

export function deleteProcessExpression(accessToken: string, id: number) {
  return request<boolean>(`/bpm/process-expression/delete${query({ id })}`, { method: "DELETE", header: header(accessToken) });
}

export interface BpmBusinessAttach {
  id?: number;
  name: string;
  code?: string;
  status?: number;
  processDefinitionKey?: string;
  taskDefinitionKey?: string;
  fileTypes?: string;
  maxSize?: number;
  required?: boolean;
  remark?: string;
  createTime?: number | string;
}

export function getBusinessAttachPage(accessToken: string, params: { pageNo: number; pageSize: number; name?: string }) {
  return request<PageResult<BpmBusinessAttach>>(`/bpm/business-attach/page${query(params)}`, { header: header(accessToken) });
}

export function getBusinessAttach(accessToken: string, id: number) {
  return request<BpmBusinessAttach>(`/bpm/business-attach/get${query({ id })}`, { header: header(accessToken) });
}

export function createBusinessAttach(accessToken: string, data: BpmBusinessAttach) {
  return request<number>("/bpm/business-attach/create", { method: "POST", data, header: header(accessToken) });
}

export function updateBusinessAttach(accessToken: string, data: BpmBusinessAttach) {
  return request<boolean>("/bpm/business-attach/update", { method: "PUT", data, header: header(accessToken) });
}

export function deleteBusinessAttach(accessToken: string, id: number) {
  return request<boolean>(`/bpm/business-attach/delete${query({ id })}`, { method: "DELETE", header: header(accessToken) });
}

/* ---------- 流程定义 ---------- */

/** 启用中的流程定义列表（发起流程页面用，suspensionState 为必填） */
export function getProcessDefinitionList(accessToken: string, suspensionState = 1) {
  return request<BpmProcessDefinition[]>(
    `/bpm/process-definition/list${query({ suspensionState })}`,
    { header: header(accessToken) },
  );
}

/**
 * 流程定义精简列表（筛选项下拉用）
 * 与 web 端 getSimpleProcessDefinitionList 一致，返回 PageResult（取 .list）
 * 注意：不能改用 /list —— 那个接口要求 suspensionState 必填
 */
export function getSimpleProcessDefinitionList(accessToken: string) {
  return request<PageResult<BpmProcessDefinition>>("/bpm/process-definition/simple-list", {
    header: header(accessToken),
  });
}

export function getProcessDefinition(accessToken: string, params: { id?: string; key?: string }) {
  return request<BpmProcessDefinition>(`/bpm/process-definition/get${query(params)}`, {
    header: header(accessToken),
  });
}

/* ---------- 流程实例 ---------- */

export interface ProcessInstancePageParams {
  pageNo: number;
  pageSize: number;
  name?: string;
  processDefinitionId?: string;
  processDefinitionKey?: string;
  category?: string;
  status?: number;
  createTime?: number[];
}

/** 我的流程分页 */
export function getProcessInstanceMyPage(accessToken: string, params: ProcessInstancePageParams) {
  return request<PageResult<BpmProcessInstance>>(`/bpm/process-instance/my-page${query(params)}`, {
    header: header(accessToken),
  });
}

/** 流程实例管理分页 */
export function getProcessInstanceManagerPage(accessToken: string, params: ProcessInstancePageParams) {
  return request<PageResult<BpmProcessInstance>>(`/bpm/process-instance/manager-page${query(params)}`, {
    header: header(accessToken),
  });
}

export function getProcessInstance(accessToken: string, id: string) {
  return request<BpmProcessInstance>(`/bpm/process-instance/get?id=${encodeURIComponent(id)}`, {
    header: header(accessToken),
  });
}

/** 审批详情（任务详情页核心接口） */
export function getApprovalDetail(
  accessToken: string,
  params: { processInstanceId: string; taskId?: string; activityId?: string },
) {
  return request<BpmApprovalDetail>(`/bpm/process-instance/get-approval-detail${query(params)}`, {
    header: header(accessToken),
  });
}

/**
 * 发起阶段的流程节点预测
 *
 * 与上面的 getApprovalDetail 形态不同：web 端发起时传的是**流程定义 id**（不是 processInstanceId）
 * 加 processVariablesStr，后端依此预测审批节点与「发起人自选审批人」候选。
 * 见 web 端 create/modules/form.vue 第 152、182 行。
 */
export function getStartApprovalNodes(
  accessToken: string,
  params: { processDefinitionId: string; activityId?: string; processVariablesStr?: string },
) {
  return request<BpmApprovalDetail>(`/bpm/process-instance/get-approval-detail${query(params)}`, {
    header: header(accessToken),
  });
}

/** 发起流程 */
export function createProcessInstance(
  accessToken: string,
  data: {
    processDefinitionId?: string;
    variables: Record<string, any>;
    startUserSelectAssignees?: Record<string, number[]>;
  },
) {
  return request<BpmProcessInstance>("/bpm/process-instance/create", {
    method: "POST",
    data,
    header: header(accessToken),
  });
}

/** 发起人取消流程（DELETE + body） */
export function cancelProcessInstanceByStartUser(
  accessToken: string,
  data: { id: string; reason: string },
) {
  return request<boolean>("/bpm/process-instance/cancel-by-start-user", {
    method: "DELETE",
    data,
    header: header(accessToken),
  });
}

/** 抄送我的分页 */
export function getProcessInstanceCopyPage(
  accessToken: string,
  params: ProcessInstancePageParams,
) {
  return request<PageResult<BpmProcessInstanceCopy>>(
    `/bpm/process-instance/copy/page${query(params)}`,
    { header: header(accessToken) },
  );
}

/** 审批时获取下一个节点的审批人（自选审批人 / 网关分支） */
export function getNextApprovalNodes(
  accessToken: string,
  params: { processInstanceId: string; taskId?: string; activityId?: string; processVariablesStr?: string },
) {
  return request<BpmApprovalDetail>(`/bpm/process-instance/get-next-approval-nodes${query(params)}`, {
    header: header(accessToken),
  });
}

/* ---------- 任务 ---------- */

export interface TaskPageParams {
  pageNo: number;
  pageSize: number;
  name?: string;
  processDefinitionKey?: string;
  category?: string;
  status?: number;
  createTime?: number[];
}

/** 待办任务分页 */
export function getTaskTodoPage(accessToken: string, params: TaskPageParams) {
  return request<PageResult<BpmTask>>(`/bpm/task/todo-page${query(params)}`, {
    header: header(accessToken),
  });
}

/** 已办任务分页 */
export function getTaskDonePage(accessToken: string, params: TaskPageParams) {
  return request<PageResult<BpmTask>>(`/bpm/task/done-page${query(params)}`, {
    header: header(accessToken),
  });
}

/** 流程任务管理分页 */
export function getTaskManagerPage(accessToken: string, params: TaskPageParams) {
  return request<PageResult<BpmTask>>(`/bpm/task/manager-page${query(params)}`, {
    header: header(accessToken),
  });
}

export interface OaNotice {
  id?: number; title: string; content: string; type: number; status: number; sendScope: number;
  isTop?: number; publishUserId?: number; publishTime?: string; createTime?: string; userIds?: number[];
}
export function getNoticePage(accessToken: string, params: { pageNo: number; pageSize: number; title?: string; type?: number; status?: number; sendScope?: number }) {
  return request<PageResult<OaNotice>>(`/bpm/oa/notice/page${query(params)}`, { header: header(accessToken) });
}
export function getNotice(accessToken: string, id: number) { return request<OaNotice>(`/bpm/oa/notice/get${query({ id })}`, { header: header(accessToken) }); }
export function createNotice(accessToken: string, data: OaNotice) { return request<number>("/bpm/oa/notice/create", { method: "POST", data, header: header(accessToken) }); }
export function updateNotice(accessToken: string, data: OaNotice) { return request<boolean>("/bpm/oa/notice/update", { method: "PUT", data, header: header(accessToken) }); }
export function deleteNotice(accessToken: string, id: number) { return request<boolean>(`/bpm/oa/notice/delete${query({ id })}`, { method: "DELETE", header: header(accessToken) }); }

/** 审批通过 */
export function approveTask(
  accessToken: string,
  data: {
    id: string;
    reason?: string;
    attachments?: string[];
    variables?: Record<string, any>;
    nextAssignees?: Record<string, number[]>;
    signPicUrl?: string;
  },
) {
  return request<boolean>("/bpm/task/approve", {
    method: "PUT",
    data,
    header: header(accessToken),
  });
}

/** 审批驳回（拒绝后直接结束流程） */
export function rejectTask(
  accessToken: string,
  data: { id: string; reason?: string; attachments?: string[] },
) {
  return request<boolean>("/bpm/task/reject", {
    method: "PUT",
    data,
    header: header(accessToken),
  });
}

/** 退回到指定节点 */
export function returnTask(
  accessToken: string,
  data: { id: string; reason?: string; targetTaskDefinitionKey: string },
) {
  return request<boolean>("/bpm/task/return", {
    method: "PUT",
    data,
    header: header(accessToken),
  });
}

/** 可退回的节点列表 */
export function getTaskListByReturn(accessToken: string, id: string) {
  return request<Array<{ taskDefinitionKey?: string; name?: string }>>(
    `/bpm/task/list-by-return?id=${encodeURIComponent(id)}`,
    { header: header(accessToken) },
  );
}

/** 转办 */
export function transferTask(
  accessToken: string,
  data: { id: string; reason?: string; assigneeUserId: number },
) {
  return request<boolean>("/bpm/task/transfer", {
    method: "PUT",
    data,
    header: header(accessToken),
  });
}

/** 委派 */
export function delegateTask(
  accessToken: string,
  data: { id: string; reason?: string; delegateUserId: number },
) {
  return request<boolean>("/bpm/task/delegate", {
    method: "PUT",
    data,
    header: header(accessToken),
  });
}

/** 加签 */
export function signCreateTask(
  accessToken: string,
  data: { id: string; type: "after" | "before"; reason?: string; userIds: number[] },
) {
  return request<boolean>("/bpm/task/create-sign", {
    method: "PUT",
    data,
    header: header(accessToken),
  });
}

/** 减签（id 为被减签的子任务 id） */
export function signDeleteTask(accessToken: string, data: { id: string; reason?: string }) {
  return request<boolean>("/bpm/task/delete-sign", {
    method: "DELETE",
    data,
    header: header(accessToken),
  });
}

/** 抄送 */
export function copyTask(
  accessToken: string,
  data: { id: string; reason?: string; copyUserIds: number[] },
) {
  return request<boolean>("/bpm/task/copy", {
    method: "PUT",
    data,
    header: header(accessToken),
  });
}

/** 撤回任务（PUT + query，body 为 null） */
export function withdrawTask(accessToken: string, taskId: string) {
  return request<boolean>(`/bpm/task/withdraw?taskId=${encodeURIComponent(taskId)}`, {
    method: "PUT",
    header: header(accessToken),
  });
}

/** 按流程实例查询全部审批任务（流转记录） */
export function getTaskListByProcessInstanceId(accessToken: string, processInstanceId: string) {
  return request<BpmTask[]>(
    `/bpm/task/list-by-process-instance-id?processInstanceId=${encodeURIComponent(processInstanceId)}`,
    { header: header(accessToken) },
  );
}

/* ---------- 文件上传 ---------- */

export interface BpmUploadResult {
  id?: number;
  name?: string;
  url?: string;
  path?: string;
  size?: number;
  type?: string;
}

/** 上传 BPM 附件 / 签名图片（字段名 file，与 web 端 requestClient.upload 一致） */
export function uploadBpmFile(accessToken: string, filePath: string, directory = "bpm/task-attachment") {
  return new Promise<BpmUploadResult>((resolve, reject) => {
    uni.uploadFile({
      url: `${API_BASE_URL}/infra/file/upload`,
      filePath,
      name: "file",
      header: { Authorization: `Bearer ${accessToken}` },
      formData: { directory },
      success: response => {
        try {
          const data = JSON.parse(response.data) as {
            code?: number;
            msg?: string;
            data?: BpmUploadResult;
          };
          if (data.code === 0 && data.data) resolve(data.data);
          else reject(new Error(data.msg || "文件上传失败"));
        } catch {
          reject(new Error("文件上传响应解析失败"));
        }
      },
      fail: () => reject(new Error("文件上传失败，请检查网络后重试")),
    });
  });
}

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

/**
 * 跨端文件选择（H5 / 微信小程序 / App 三端兼容）
 * - H5 / App：uni.chooseFile
 * - 微信小程序：uni.chooseMessageFile（uni.chooseFile 在小程序不可用）
 */
export function chooseBpmFile(count = 9): Promise<BpmPickedFile[]> {
  return new Promise((resolve, reject) => {
    const onSuccess = (files: BpmPickedFile[]) => 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
  });
}

/** 跨端选择图片（签名图片、图片类附件） */
export function chooseBpmImage(count = 1): Promise<BpmPickedFile[]> {
  return new Promise((resolve, reject) => {
    uni.chooseImage({
      count,
      success: result => {
        resolve((result.tempFilePaths || []).map(path => ({ path })));
      },
      fail: reject,
    });
  });
}