import request from '@/utils/request'
import _ from 'lodash'
import { getUser } from '@/api/uc'
import store from '@/store'

const bpmModel = window.context.bpmModel
const bpmRunTime = window.context.bpmRunTime
const portal = window.context.portal

//根据taskId获取对应的流程运行对象
export function getProcessRunByTaskId(taskId) {
  return request({
    url: `${portal}/runtime/instance/v1/getProcessRunByTaskId?taskId=${taskId}`,
    method: 'get',
  })
}

export function getFlowTree() {
  return request({
    url: `${portal}/sys/sysType/v1/getTypesByKey?typeKey=FLOW_TYPE`,
    method: 'get',
  })
}

//获取新建流程列表
export function getProcessList(data) {
  return request({
    url: `${bpmRunTime}/runtime/instance/v1/newProcess`,
    method: 'post',
    data,
  })
}

//待办列表
export function getTodoList(data) {
  return request({
    url: `${bpmRunTime}/runtime/task/v1/getTodoList`,
    method: 'post',
    data,
  })
}

//已办列表
export function getDoneList(data) {
  return request({
    url: `${bpmRunTime}/runtime/instance/v1/getDoneInstList`,
    method: 'post',
    data,
  })
}
//领导已办列表
export function getDoneListLeader(data) {
  return request({
    url: `${bpmRunTime}/runtime/instance/v1/getDoneInstList?status=1`,
    method: 'post',
    data,
  })
}

//已阅事项列表
export function getNoticeDoneReadList(data) {
  return request({
    url: `${bpmRunTime}/runtime/task/v1/getNoticeDoneReadList`,
    method: 'post',
    data,
  })
}

//我的请求
export function getMyRequestList(data) {
  return request({
    url: `${bpmRunTime}/runtime/instance/v1/myRequest`,
    method: 'post',
    data,
  })
}

//待阅事项
export function getNoticeTodoReadList(data) {
  return request({
    url: `${bpmRunTime}/runtime/task/v1/getNoticeTodoReadList`,
    method: 'post',
    data,
  })
}

//我传阅的
export function getMyNoticeReadList(data) {
  return request({
    url: `${bpmRunTime}/runtime/task/v1/getMyNoticeReadList`,
    method: 'post',
    data,
  })
}

//我转办的
export function getDelegateList(data) {
  return request({
    url: `${bpmRunTime}/runtime/task/v1/getDelegate`,
    method: 'post',
    data,
  })
}

//领导待办
export function getLeaderTodoList(data) {
  return request({
    url: `${bpmRunTime}/runtime/task/v1/getLeaderTodoList`,
    method: 'post',
    data,
  })
}
//根据实例id获取当前实例的办理环节
export function getDoneByInstId(data) {
  return request({
    url: `${bpmRunTime}/runtime/instance/v1/getDoneList?isCheckRevoke=true`,
    method: 'post',
    data,
  })
}
//传阅事项-我收到的 需要根据传阅人ownerId过滤数据
export function getDoneByInstIdAndAccount(data, ownerId) {
  return request({
    url: `${bpmRunTime}/runtime/instance/v1/getDoneList?isCheckRevoke=true&ownerId=${ownerId}`,
    method: 'post',
    data,
  })
}
//根据知会任务id获取当前任务的真实操作人
export function getNoticeTodoReadById(noticeId) {
  return request({
    url: `${bpmRunTime}/runtime/task/v1/getNoticeTodoReadById?noticeId=${noticeId}`,
    method: 'get',
  })
}
//提交批量处理
export function batchHandle(data) {
  return request({
    url: `${bpmRunTime}/runtime/task/v1/batchHandle`,
    method: 'post',
    data,
  })
}

//过滤非批量处理类型任务
export function filterUnBatchable(id) {
  return request({
    url: `${bpmRunTime}/runtime/task/v1/filterUnBatchable?taskIds=${id}`,
    method: 'get',
  })
}

//根据用户获取各分类下的新建流程列表
export function getNewProcessCount(data) {
  return request({
    url: `${bpmRunTime}/runtime/instance/v1/newProcessCount`,
    method: 'post',
    data,
  })
}

//逻辑删除草稿的流程实例
export function deleteProcessInstanceById(id) {
  return request({
    url: `${bpmRunTime}/runtime/instance/v1/removeDraftById?ids=${id}`,
    method: 'delete',
  })
}
// 逻辑删除流程实例
export function deleteProcInstById(id) {
  return request({
    url: `${bpmRunTime}/runtime/instance/v1/remove?ids=${id}`,
    method: 'delete',
  })
}
// 删除流程实例
export function deleteInstById(id) {
  return request({
    url: `${bpmRunTime}/runtime/instance/v1/instRemove?id=${id}`,
    method: 'delete',
  })
}
//终止流程
export function terminationProcess(id, cb) {
  const url = `${bpmRunTime}/runtime/instance/v1/doEndProcessById?id=${id}`
  request.get(url).then((response) => {
    cb(response)
  })
}
//保存表单数据
export function getCurNodeProperties(data) {
  return request({
    url: `${bpmRunTime}/runtime/task/v1/getCurNodeProperties?defId=${data.defId}&instId=${data.instId}&taskId=${data.taskId}`,
    method: 'get',
  })
}

//获取任务是否能锁定
export function canLock(query, cb) {
  const hasTaskId = query.taskId
  const hasTaskIdUrl = `${bpmRunTime}/runtime/task/v1/canLock?taskId=${query.taskId}&leaderId=${query.leaderId}`
  const notTaskIdUrl = `${bpmRunTime}/runtime/task/v1/canLock?taskId=${query.taskId}`
  const url = hasTaskId ? hasTaskIdUrl : notTaskIdUrl
  return request.get(url)
}
// 获取任务锁定状态
export function getTaskLockStatus(query, cb) {
  const { taskId, leaderId } = query
  const url = `${bpmRunTime}/runtime/task/v1/lockUnlock?taskId=${taskId}&leaderId=${leaderId}`
  request.get(url).then((response) => {
    cb(response)
  })
}
//处理任务
export function savaTaskComplete(data) {
  return request({
    url: `${bpmRunTime}/runtime/task/v1/complete`,
    method: 'post',
    data,
  })
}
//根据流程定义ID获取该流程的其它待办，如果获取不到，则返回其它待办(返回一条)
export function getNextTaskByDefId(query) {
  const { defKey, defId } = query
  const url = `${bpmRunTime}/runtime/task/v1/nextTask?defId=${defId}&defKey=${defKey}`
  return request.get(url)
}
//获取驳回任务页面参数
export function getRejectTaskParams(query, cb) {
  const { taskId, backModel } = query
  const url = `${bpmRunTime}/runtime/task/v1/taskToReject?taskId=${taskId}&backModel=${backModel}`
  request.get(url).then((response) => {
    cb(response)
  })
}

export function getTaskInfo(procIds) {
  const url = `${bpmRunTime}/runtime/task/v1/instanceDetail`
  return request.post(url, procIds)
}
export function getMyRequestTask(procId) {
  const url = `${bpmRunTime}/runtime/task/v1/getMyRequestTask`
  return request.post(url, procId)
}

export function getCandidatesListByTaskId(taskId) {
  const url = `${bpmRunTime}/runtime/task/v1/getCandidatesListByTaskId?taskId=${taskId}`
  return request.get(url)
}
//征询设置
export function savaInquiry(data) {
  return request({
    url: `${bpmRunTime}/runtime/task/v1/taskToInqu`,
    method: 'post',
    data,
  })
}
//征询回复
export function savaInquiryReply(data) {
  return request({
    url: `${bpmRunTime}/runtime/task/v1/taskToInquReply`,
    method: 'post',
    data,
  })
}
//保存表单为草稿(审批页面保存按钮)
export function savaTaskDraft(data) {
  return request({
    url: `${bpmRunTime}/runtime/task/v1/saveDraft`,
    method: 'post',
    data,
  })
}

//传阅回复提交
export function savaCirculationReply(data) {
  return request({
    url: `${bpmRunTime}/runtime/instance/v1/doNextCopyto`,
    method: 'post',
    data,
  })
}
//加签反馈
export function savaCountersignFeedback(data) {
  return request({
    url: `${bpmRunTime}/runtime/task/v1/userAddSignFeedback`,
    method: 'post',
    data,
  })
}
//会签任务加签
export function savaCountersign(data) {
  return request({
    url: `${bpmRunTime}/runtime/task/v1/taskSignUsers`,
    method: 'post',
    data,
  })
}
//用户任务加签
export function savaUserTaskCountersign(data) {
  return request({
    url: `${bpmRunTime}/runtime/task/v1/userTaskToSign`,
    method: 'post',
    data,
  })
}

//沟通反馈
export function savaCommunicateFeedback(data) {
  return request({
    url: `${bpmRunTime}/runtime/instance/v1/doNextcommu`,
    method: 'post',
    data,
  })
}
//转办设置
export function savaTransfer(data) {
  return request({
    url: `${bpmRunTime}/runtime/task/v1/delegate`,
    method: 'post',
    data,
  })
}
//流程终止
export function savaTermination(data) {
  return request({
    url: `${bpmRunTime}/runtime/instance/v1/doEndProcess`,
    method: 'post',
    data,
  })
}

//流程启动时获取表单和bo
export function getProcessFormAndBo(data) {
  return request({
    url: `${bpmRunTime}/runtime/instance/v1/getMobileFormAndBO`,
    method: 'post',
    data,
  })
}
//启动流程
export function startProcess(data) {
  return request({
    url: `${bpmRunTime}/runtime/instance/v1/start`,
    method: 'post',
    data,
  })
}
//发起人配置审批人后确认事件
export function assignBpmTask(data) {
  return request({
    url: `${bpmRunTime}/runtime/instance/v1/assignBpmTask`,
    method: 'post',
    data,
  })
}
//保存草稿
export function savaProcessDraft(data) {
  return request({
    url: `${bpmRunTime}/runtime/instance/v1/saveDraft`,
    method: 'post',
    data,
  })
}
//获取后续可跳转节点
export function getAfterJumpNodesByDefId(data) {
  return request({
    url: `${bpmRunTime}/runtime/task/v1/getAfterJumpNodes`,
    method: 'post',
    data,
  })
}
// 获取可跟踪的任务节点
export function getTaskNode(data, cb) {
  const { defId } = data
  const url = `${bpmRunTime}/runtime/task/v1/taskNode?defId=${defId}`
  request.get(url).then((res) => {
    cb(res)
  })
}

// 根据流程实例id获取已跟踪的节点
export function getFollowedNode(data, cb) {
  const { proInst } = data
  const url = `${bpmRunTime}/runtime/taskFollow/v1/getFollowedNode?instId=${proInst}`
  request.get(url).then((res) => {
    cb(res)
  })
}

// 更新任务跟踪表数据
export function taskFollowSave(data, cb) {
  const url = `${bpmRunTime}/runtime/taskFollow/v1/save`
  request.post(url, data).then((res) => {
    cb(res)
  })
}

// 根据实例ID判断流程是否结束
export function processIsOver(procInstId, cb) {
  const url = `${bpmRunTime}/runtime/task/v1/isEnd?procInstId=${procInstId}`
  request.post(url).then((res) => {
    cb(res)
  })
}

// 根据实例id获取实例对象
export function getInstanceByInstId(instId, cb) {
  const url = `${bpmRunTime}/runtime/instance/v1/getInstanceByInstId?instId=${instId}`
  request.get(url).then((res) => {
    cb(res)
  })
}

// 根据流程实例ID获取当前任务节点审批人
export function getExcutorByInstId(instId, cb) {
  const url = `${bpmRunTime}/runtime/instance/v1/getExcutorNameByInstId?instId=${instId}`
  request.get(url).then((res) => {
    cb(res)
  })
}

// 根据流程定义id获取流程信息
export function defGet(defId, cb) {
  const url = `${bpmModel}/flow/def/v1/defGet?defId=${defId}`
  request.get(url).then((res) => {
    cb(res)
  })
}

// 发送人工催办
export function sendBpmTaskUrgent(data, cb) {
  const url = `${bpmRunTime}/runtime/instance/v1/sendBpmTaskUrgent`
  request.post(url, data).then((res) => {
    cb(res)
  })
}

// 流程抄送
export function transToMore(data, cb) {
  const url = `${bpmRunTime}/runtime/instance/v1/transToMore`
  request.post(url, data).then((res) => {
    cb(res)
  })
}

// 沟通设置
export function communicate(data, cb) {
  const url = `${bpmRunTime}/runtime/task/v1/communicate`
  request.post(url, data).then((res) => {
    cb(res)
  })
}
//根据流程流程实例id获取该流程在发起节点的任务
export function getStartNodeTaskByInstId(instId, cb) {
  const url = `${bpmRunTime}/runtime/instance/v1/getStartNodeTaskByInstId?instId=${instId}`
  request.get(url).then((res) => {
    cb(res)
  })
}
//流转设置
export function savaExchange(data) {
  return request({
    url: `${bpmRunTime}/runtime/task/v1/taskToTrans`,
    method: 'post',
    data,
  })
}
//根据defId或者procInstId或者taskId获取flowKey
export function getFlowKey(query, cb) {
  const key = Object.keys(query)[0]
  const url = `${bpmRunTime}/runtime/instance/v1/getFlowKey?${key}=${query[key]}`
  request.get(url).then((res) => {
    cb(res)
  })
}
//获取任务详情
export function getTaskDetailBo(query) {
  const url = `${bpmRunTime}/runtime/task/v1/taskMobileDetail?taskId=${query.taskId}&reqParams=${query.reqParams}&leaderId=${query.leaderId}`
  return request.get(
    query.isDefAuthorize ? `${url}&isDefAuthorize=${query.isDefAuthorize}` : url
  )
}
//获取流程实例表单
export function getInstFormAndBO(query) {
  let url = `${bpmRunTime}/runtime/instance/v1/getMobileInstFormAndBO?proInstId=${query.instId
    }&myApplication=${query.myApplication || false}`
  query.nodeId && (url += `&nodeId=${query.nodeId}`)
  query.formId && (url += `&formId=${query.formId}`)
  query.includData != null &&
    query.includData != undefined &&
    (url += `&includData=${query.includData}`)
  query.getStartForm != null &&
    query.getStartForm != undefined &&
    (url += `&getStartForm=${query.getStartForm}`)
  return request.get(
    query.isDefAuthorize ? `${url}&isDefAuthorize=${query.isDefAuthorize}` : url
  )
}
//根据流程实例id获取是否允许发起人撤回
export function getSponsorRevoke(instId, cb) {
  const url = `${bpmRunTime}/runtime/instance/v1/getSponsorRevokeByInstId?instId=${instId}`
  request.get(url).then((res) => {
    cb(res)
  })
}
//撤回设置
export function savaRevoke(data) {
  return request({
    url: `${bpmRunTime}/runtime/instance/v1/revokeInstance`,
    method: 'post',
    data,
  })
}
//获取顺序签署下一步执行人
export function getNextExecutor(taskId, cb) {
  const url = `${bpmRunTime}/runtime/task/v1/nextExecutor?taskId=${taskId}`
  request.get(url).then((res) => {
    cb(res)
  })
}
//获取各事项流程分类数量
export function getTodoProcessClassifyCount(data) {
  return request({
    url: `${bpmRunTime}/runtime/task/v1/getTodoCount`,
    method: 'post',
    data,
  })
}
//获取领导待办流程分类数量
export function getLeaderTodoProcessClassifyCount(data) {
  return request({
    url: `${bpmRunTime}/runtime/task/v1/getLeaderTodoCount`,
    method: 'post',
    data,
  })
}
//获取已办流程分类数量
export function getDoneProcessClassifyCount(data) {
  return request({
    url: `${bpmRunTime}/runtime/instance/v1/getDoneInstCount`,
    method: 'post',
    data,
  })
}
//获取领导已办流程分类数量
export function getLeaderDoneProcessClassifyCount(data) {
  return request({
    url: `${bpmRunTime}/runtime/task/v1/getLeaderDoneCount`,
    method: 'get',
    data,
  })
}
//获取我的转办流程分类数量
export function getDelegateProcessClassifyCount(data) {
  return request({
    url: `${bpmRunTime}/runtime/task/v1/getDelegateCount`,
    method: 'post',
    data,
  })
}
//获取新建流程流程分类数量
export function getNewProcessClassifyCount(data) {
  return request({
    url: `${bpmRunTime}/runtime/instance/v1/newProcessCount`,
    method: 'post',
    data,
  })
}
//获取我的收藏流程分类数量
export function getCollectionProcessClassifyCount(data) {
  return request({
    url: `${bpmRunTime}/bpmFlowCollect/v1/myCollectCount`,
    method: 'post',
    data,
  })
}
//获取我的请求流程分类数量
export function getRequestProcessClassifyCount(query) {
  const url = `${bpmRunTime}/runtime/instance/v1/myRequestCount`
  return request.get(url)
}
//获取我的收藏流程分类数量
export function getDraftProcessClassifyCount(data) {
  return request({
    url: `${bpmRunTime}/runtime/instance/v1/getMyDraftCount`,
    method: 'post',
    data,
  })
}
//获取我传阅的流程分类数量
export function getCirculatedProcessClassifyCount(data) {
  return request({
    url: `${bpmRunTime}/runtime/task/v1/getMyNoticeReadCount`,
    method: 'post',
    data,
  })
}
//获取我收到的流程分类数量
export function getReceivedProcessClassifyCount(data) {
  return request({
    url: `${bpmRunTime}/runtime/task/v1/getNoticeTodoReadCount`,
    method: 'post',
    data,
  })
}
//我的传阅根据流程id撤回流程
export function revokeProcessById(id) {
  return request({
    url: `${bpmRunTime}/runtime/task/v1/delBpmTaskNoticeById?id=${id}`,
    method: 'post',
  })
}
//批量处理接口
export function savaPatchProcessing(data) {
  return request({
    url: `${bpmRunTime}/runtime/task/v1/batchHandle`,
    method: 'post',
    data,
  })
}
//过滤未配置批量审批任务
export function filterUnBatchTask(taskIds, cb) {
  const url = `${bpmRunTime}/runtime/task/v1/filterUnBatchable?taskIds=${taskIds}`
  request.get(url).then((res) => {
    cb(res)
  })
}
//获取待办卡片列表
export function getTodoCard(data) {
  return request({
    url: `${bpmRunTime}/runtime/task/v1/getTodoCard?size=21`,
    method: 'post',
    data,
  })
}
//获取卡片模式时待办数量
export function getTodoCardCount() {
  return request({
    url: `${bpmRunTime}/runtime/task/v1/getTodoCardCount`,
    method: 'get',
  })
}
//获取新建流程卡片模式流程列表
export function getProcessCard(data) {
  return request({
    url: `${bpmRunTime}/runtime/instance/v1/newProcessCard?size=11`,
    method: 'post',
    data,
  })
}

//获取当前用户的领导
export function getCurrentAccountLeader() {
  return request({
    url: `${bpmRunTime}/runtime/bpmSecretaryManage/v1/getSecretaryByUserId`,
    method: 'get',
  })
}
//查询当前用户是否有领导审批权限
export function checkHasSecretary() {
  return request({
    url: `${bpmRunTime}/runtime/bpmSecretaryManage/v1/checkHasSecretary`,
    method: 'get',
  })
}
//流程收藏或者取消
export function collectionProcessOrCancel(data, type) {
  return request({
    url: `${bpmRunTime}/bpmFlowCollect/v1/${type}`,
    method: 'post',
    data,
  })
}
//获取已收藏流程
export function getCollectionProcess(data) {
  return request({
    url: `${bpmRunTime}/bpmFlowCollect/v1/myCollect`,
    method: 'post',
    data,
  })
}
//根据流程实例id获取流程实例信息
export function getProcessInfo(instId) {
  return request({
    url: `${bpmRunTime}/runtime/instance/v1/get?id=${instId}`,
    method: 'get',
  })
}
//获取领导待办卡片列表
export function getLeaderTodoCard(data) {
  return request({
    url: `${bpmRunTime}/runtime/task/v1/getLeaderTodoCard?size=6`,
    method: 'post',
    data,
  })
}
//获取已阅列表
export function getReadList(data) {
  return request({
    url: `${bpmRunTime}/runtime/task/v1/getNoticeDoneReadList`,
    method: 'post',
    data,
  })
}
//标记已阅
export function setRead(taskId) {
  return request({
    url: `${bpmRunTime}/runtime/task/v1/noticeTurnDode?taskId=${taskId}`,
    method: 'post',
    data: {},
  })
}
//根据id删除任务
export function deleteTask(ids) {
  return request({
    url: `${bpmRunTime}/runtime/task/v1/remove?ids=${ids}`,
    method: 'delete',
  })
}
//流程转办收回
export function takeBackTask(taskId) {
  return request({
    url: `${bpmRunTime}/runtime/task/v1/retrieveBpmTask?taskId=${taskId}`,
    method: 'get',
  })
}
//获取待办表头数据
export function getTodoExtendField() {
  const url = `${portal}/sys/sysProperties/v1/getDecryptByAlias?alias=taskListFiledConf`
  return request.get(url)
}
//获取紧急状态配置
export function getUrgentStateConf(data) {
  return request({
    url: `${bpmRunTime}/runtime/instance/v1/getUrgentStateConf`,
    method: 'post',
    data: data,
  })
}
//根据所传任务id标记该任务为已阅
export function markTaskAsRead(taskId) {
  return request({
    url: `${bpmRunTime}/runtime/task/v1/addReadRecord?taskId=${taskId}`,
    method: 'post',
    data: {},
  })
}
//根据流程定义id获取流程标题
export function getProcessTitle(defId) {
  const url = `${bpmModel}/flow/def/v1/getDefDesignByDefId?defId=${defId}`
  return request.get(url)
}

//根据流程key获取流程的主版本
export function getMainByDefIdOrKey(defId, defKey) {
  defId = defId || ''
  defKey = defKey || ''
  const url = `${bpmModel}/flow/def/v1/getMainByDefIdOrKey?defId=${defId}&&defKey=${defKey}`
  return request.get(url)
}

//任务延后处理
export function taskDelayById(taskId) {
  const url = `${bpmRunTime}/runtime/task/v1/taskDelayById?taskId=${taskId}`
  return request.get(url)
}

// 获取用户是否拥有指定流程的发起权限
export function checkStartRight(userId, defId, leaderId) {
  return request.get(
    `${bpmModel}/flow/defAuthorize/v1/startRight?userId=${userId}&defId=${defId}&leadId=${leaderId}`
  )
}
//根据实例id获取节点套打模版
export function getNodePrintTemplate(query) {
  return request.get(
    `${bpmRunTime}/runtime/task/v1/getNodePropertiesByNodeId?instId=${query.instId}&nodeId=${query.nodeId}`
  )
}

//根据流程实例ID获取相关信息
export function getRelatedInformationById(id) {
  return request({
    url: `${bpmRunTime}/runtime/instance/v1/getRelatedInformationById?id=${id}`,
    method: 'get',
  })
}

//获取相关信息的阅读记录列表
export function getByRecordInstId(data) {
  return request({
    url: `${bpmRunTime}/runtime/instance/v1/getByRecordInstId`,
    method: 'post',
    data,
  })
}

//获取催办记录列表
export function getUrgentById(data) {
  return request({
    url: `${bpmRunTime}/runtime/instance/v1/getUrgrntById`,
    method: 'post',
    data,
  })
}
// 根据任务id获取实例对象
export function getTasksByInstId(instId) {
  return request({
    url: `${bpmRunTime}/runtime/task/v1/getTasksByInstId?instId=${instId}`,
    method: 'get',
  })
}

export function getProcessCreatorAvatars(id) {
  return memoize(id)
}

const memoize = _.memoize(
  async (id) => {
    let user = await getUser(id)
    if (user) {
      return await store.dispatch('menu/downloadImg', user.photo)
    }
  },
  (id) => {
    return id
  }
)
//当前账号是否有启动该流程的权限
export function flowHasStartRights(defKey) {
  return request({
    url: `${bpmModel}/flow/def/v1/flowHasStartRights?defKey=${defKey}`,
    method: 'get',
  })
}