import flow from '@/api/flow.js'
import utils from '@/hotent-ui-util.js'
const state = {
  defConfigData: {
    initData: {},
    nodeSetData: {},
    curEditNode: {}
  },
  copyDefConfigData: {},
  nodeBranches: {},
  signConfigs: {},
  mesageType: '',
  formPublic:null,//栏目的使用平台
}

const getters = {
  getFormPublic: function (state) {
    return state.formPublic
  },
}

const actions = {
  // 根据流出定义id和父流程key获取流程配置信息
  getDefSetting({commit, state}, param) {
    return new Promise((resolve, reject) => {
      commit('clearCacheData')
      flow.getDefSetting(param, resp => {
        commit('setDefSettingData', resp.data)
        resolve(resp.data)
      })
    })
  },

  //更新vuex里面的配置数据{path:value}
  updateConfig({commit, state}, param) {
    commit('updateConfig', param)
  },
  saveDefSetting({commit, state}, data) {
    commit('updateConfig', param)
  },
  //流程图
  getBpmImage({commit, state}, data) {
    return new Promise((resolve, reject) => {
      flow.instanceFlowImage(data, response => {
        let defId = response.data.instanceId ? '' : response.data.defId
        flow.getBpmImage('', response.data.instanceId, defId, res => {
          let data = {rows: response.data, img: res.data}
          resolve(data)
        })
      })
    })
  },
  //获取审批意见
  getNodeopinions({commit, state}, pagination) {
    return new Promise((resolve, reject) => {
      flow.getNodeopinions(pagination, response => {
        resolve(response.data)
      })
    })
  },
  //获取系统配置的通知类型
  getMessageType({commit, state}) {
    return new Promise((resolve, reject) => {
      if (state.mesageType) {
        resolve(state.mesageType)
      } else {
        flow.getMessageType(response => {
          commit('setMessageType', response.data)
          resolve(response.data)
        })
      }
    })
  },
  //获取节点分支规则
  getCurSelectBranches({commit, state}) {
    return new Promise((resolve, reject) => {
      let curNode = state.defConfigData.curEditNode
      if (
        !curNode.nodeId ||
        (curNode.nodeType != 'EXCLUSIVEGATEWAY' &&
          curNode.nodeType != 'INCLUSIVEGATEWAY')
      ) {
        reject()
      } else if (curNode && state.nodeBranches[curNode.nodeId]) {
        resolve(state.nodeBranches[curNode.nodeId])
      } else if (curNode && curNode.nodeId) {
        flow.getNodeBranches(
          {nodeId: curNode.nodeId, defId: curNode.defId},
          response => {
            commit('setNodeBranches', {
              nodeId: curNode.nodeId,
              data: response.data
            })
            resolve(response.data)
          }
        )
      }
    })
  },
  //获取会签配置
  getSignConfig({commit, state}) {
    return new Promise((resolve, reject) => {
      let curNode = state.defConfigData.curEditNode
      if (!curNode.nodeId || curNode.nodeType != 'SIGNTASK') {
        reject()
      } else if (curNode && state.signConfigs[curNode.nodeId]) {
        resolve(state.signConfigs[curNode.nodeId])
      } else {
        flow.getSignConfig(
          {nodeId: curNode.nodeId, defId: curNode.defId},
          response => {
            commit('setSignConfigs', {
              nodeId: curNode.nodeId,
              data: response.data
            })
            resolve(response.data)
          }
        )
      }
    })
  },
  updateDefRev({commit, state}) {
    flow.getBpmdefByDefId(
      state.defConfigData.initData.bpmDefinition.defId,
      response => {
        commit('updateBpmdef', response)
      }
    )
  },
  updateFormPublic({commit, state},param) {
    commit('setFormPublic',param)
  }
}

const mutations = {
  updateBpmdef(state, param) {
    state.defConfigData.initData.bpmDefinition = param
  },
  setSignConfigs(state, param) {
    state.signConfigs[param.nodeId] = param.data
  },
  setNodeBranches(state, param) {
    state.nodeBranches[param.nodeId] = param.data
  },
  clearCacheData(state) {
    state.defConfigData = {initData: {}, nodeSetData: {}, curEditNode: {}}
    state.nodeBranches = {}
    state.signConfigs = {}
  },
  setDefSettingData(state, data) {
    if (!data.initData.bpmDefLayout) {
      state.defConfigData = data
      state.copyDefConfigData = JSON.parse(JSON.stringify(state.defConfigData))
      return
    }
    for (
      var i = 0, layout;
      (layout = data.initData.bpmDefLayout.listLayout[i++]);

    ) {
      layout.nodeStyle = {
        position: 'absolute',
        cursor: 'hand',
        'text-align': 'center',
        left: layout.x + 'px',
        top: layout.y + 'px',
        width: layout.width + 'px',
        height: layout.height + 'px'
      }
    }

    if (!data.nodeSetData.bpmDefSetting.globalForm)
      data.nodeSetData.bpmDefSetting.globalForm = {
        type: 'INNER',
        formType: 'pc',
        name: '',
        formValue: '',
        formExtraConf: '',
        helpFile: ''
      }
    if (!data.nodeSetData.bpmDefSetting.globalMobileForm)
      data.nodeSetData.bpmDefSetting.globalMobileForm = {
        type: 'INNER',
        formType: 'mobile',
        name: '',
        formValue: '',
        helpFile: ''
      }
    if (!data.nodeSetData.bpmDefSetting.instForm)
      data.nodeSetData.bpmDefSetting.instForm = {
        type: 'INNER',
        formType: 'pc',
        name: '',
        formValue: ''
      }
    if (!data.nodeSetData.bpmDefSetting.instMobileForm)
      data.nodeSetData.bpmDefSetting.instMobileForm = {
        type: 'INNER',
        formType: 'mobile',
        name: '',
        formValue: ''
      }
    state.defConfigData.initData = data.initData
    state.defConfigData.nodeSetData = data.nodeSetData
    //获取通知类型
    data.nodeSetData.notifyType = []
    for (let key in data.initData.messageTypelist) {
      let obj = {key: key, value: data.initData.messageTypelist[key]}
      data.nodeSetData.notifyType.push(obj)
    }
    //屏蔽一些多余的按钮配置
    for (let key in data.nodeSetData.nodeBtnMap) {
      let item = data.nodeSetData.nodeBtnMap[key]
      for (let i = item.length - 1; i >= 0; i--) {
        if (
          item[i].alias == 'commu' ||
          item[i].alias == 'startCommu' ||
          item[i].alias == 'instanceTrans' ||
          item[i].alias == 'backToStart'
        ) {
          item.splice(i, 1)
        }
      }
    }
    state.copyDefConfigData = JSON.parse(JSON.stringify(state.defConfigData))
  },
  updateConfig(state, param) {
    if (param && param.constructor == Object) {
      for (let key in param) {
        if (
          key.indexOf('nodeBranches') > -1 ||
          key.indexOf('signConfigs') > -1
        ) {
          utils.setValueByPath(
            state,
            key,
            JSON.parse(JSON.stringify(param[key]))
          )
        } else {
          utils.setValueByPath(
            state,
            'defConfigData.' + key,
            JSON.parse(JSON.stringify(param[key]))
          )
        }
      }
    }
  },
  setMessageType(state, param) {
    state.mesageType = param
  },
  setFormPublic(state, param) {
    state.formPublic = param
  },
}

export default {
  namespaced: true,
  state,
  getters,
  actions,
  mutations
}