import {
  queryFlowInfo,
  // commitSheet,
  querySheet,
  queryHistory,
  // queryHistoryDetail,
  queryComment,
  addComment,
  createExcel,
  queryExcel,
  updateFlowInfo,
  submitAudit,
  // approve,
  queryFiles,
  deleteFiles,
} from '@/services/PurchaseList';
import {
  queryAuditList,
  queryVersionsList,
  queryProjectRecord,
  queryRecord,
  commitSheet,
  queryDetail,
  queryHistoryList,
  queryHistoryDetail,
  submitNextNode,
  advanceSubmitNextNode,
  addBomComment,
  queryBomComment,
  approve,
  queryAuthority,
  queryVersionsTree,
  queryAuditExcel,
  queryAuditRecord,
  queryDingSchema,
  queryDingInstanceDetail,
  queryListParentByUser,
  queryClassify,
  queryBindClassify,
} from '@/services/boom';
import { queryRole } from '@/services/SysAdmin';
import { setCurrentUser } from '@/utils/authority';
import { queryProjectMenu } from '@/services/SysAdmin';
import { storeToken } from '@/utils/utils';
import { routerRedux } from 'dva/router';
import { message } from 'antd';

export default {
  namespace: 'detail',
  state: {
    template: {},
    versionList: [],
    historyList: [],
    auditList: [],

    flow: {
      active: 0,
      currentNode: {},
      list: {
        FlowNodes: [],
      },
    },
    history: {
      list: [],
      pagination: false,
    },
    project: {
      list: [],
      pagination: false,
    },
    excel: {
      list: [],
      pagination: false,
    },
    comment: { list: [] },
    bomComment: { list: [] },
    fileList: [],
    roleList: [],
    authority: [],
    versionTree: [],
    auditExcel: [],
    dingInstanceD: [],
    typeOptions: [],
    classifyList:[],
  },

  effects: {
    *queryAuthority({ payload, callback }, { call, put }) {
      const response = yield call(queryAuthority, payload);
      if (response) {
        yield put({
          type: 'save',
          payload: { authority: response.data },
        });
      }
    },
    *queryProjectRecord({ payload, callback }, { call, put }) {
      const response = yield call(queryProjectRecord, payload);
      if (response) {
        console.log(response);
        const flow = response.data.list[0];
        if (flow) {
          let { template_id, template_node_id } = flow;
          yield put({
            type: 'save',
            payload: { template: flow },
          });
          yield put({
            type: 'queryVersionsList',
            payload: {
              ...payload,
              // template_id,
              // template_node_id,
            },
            callback,
          });
        }
        // yield put({
        //   type: 'save',
        //   payload: { flow: flow },
        // });
      }
    },
    *queryVersionsList({ payload, callback }, { call, put }) {
      const response = yield call(queryVersionsList, payload);
      if (response) {
        callback && callback(response.data);
        yield put({
          type: 'save',
          payload: {
            versionList: response.data,
          },
        });
      }
    },
    *queryAuditList({ payload }, { call, put }) {
      const response = yield call(queryAuditList, payload);
      if (response) {
        console.log(response);
        yield put({
          type: 'save',
          payload: { auditList: response.data || [] },
        });
      }
    },
    // 查询子清单详情
    *queryRecord({ payload, callback }, { call, put }) {
      const response = yield call(queryRecord, payload);
      if (response && response.data) {
        let sheet = response.data;
        sheet.data = JSON.parse(sheet.data || '[]');
        sheet.data.forEach(item => {
          item.config = JSON.parse(item.config || '{}');
          item.celldata = JSON.parse(item.cell_data || '[]');
          delete item.cell_data;
        });
        callback && callback(sheet);
      } else {
        yield put({
          type: 'queryDetail',
          payload: {
            excel_id: payload.version_id,
          },
          callback,
        });
      }
    },
    *commitSheet({ payload, callback }, { call, put }) {
      let response = yield call(commitSheet, payload);
      if (response) {
        message.success('提交成功');
        yield put({
          type: 'queryVersionsList',
          payload: {
            project_id: payload.project_id,
            // template_id: payload.template_id,
            // template_node_id: payload.template_node_id,
          },
          callback: versionList => {
            let newVersion = versionList.find(item => item.id == response.data.id);
            callback && callback(newVersion);
          },
        });
      }
    },
    *saveSheet({ payload }, { call }) {
      yield call(commitSheet, payload);
    },
    *queryBomComment({ payload }, { call, put }) {
      const response = yield call(queryBomComment, payload);
      if (response) {
        yield put({
          type: 'save',
          payload: { bomComment: response.data },
        });
      }
    },
    *addBomComment({ payload, callback }, { call, put }) {
      try {
        const response = yield call(addBomComment, payload);
        if (response) {
          yield put({
            type: 'queryBomComment',
            payload: {
              excel_id: payload.excel_id,
            },
          });
          message.success('评论成功');
          callback && callback();
        }
      } catch (error) {
        console.log(error);
      }
    },
    // 提交流转
    *submitNextNode({ payload, callback }, { call, put }) {
      let response = yield call(submitNextNode, payload);
      if (response) {
        message.success('提交成功');
        yield put({
          type: 'queryVersionsList',
          payload: {
            project_id: payload.project_id,
          },
          callback: () => {
            callback(response.data);
          },
        });
      }
    },
    // 实时计算审批人
    *advanceSubmitNextNode({ payload, callback }, { call, put }) {
      let response = yield call(advanceSubmitNextNode, payload);
      if (response) {
        console.log(response);
        callback?.(response.data);

        // message.success('提交成功');
        // yield put({
        //   type: 'queryVersionsList',
        //   payload: {
        //     project_id: payload.project_id,
        //   },
        //   callback: () => {
        //     callback(response.data);
        //   },
        // });
      }
    },
    *queryDetail({ payload, callback }, { call, put }) {
      const sheet = yield call(queryDetail, payload);
      if (sheet) {
        callback?.(sheet);
      }
    },
    *queryHistoryList({ payload, callback }, { call, put, select }) {
      const response = yield call(queryHistoryList, {
        ...payload,
        pageSize: 9999,
      });
      if (response) {
        console.log(response);
        yield put({
          type: 'saveHistory',
          payload: {
            [payload.version_id]: response.data.list,
          },
        });
      }
    },
    // 审批
    *approve({ payload, callback }, { call, put }) {
      try {
        const response = yield call(approve, payload);
        if (response) {
          message.success('操作成功');

          yield put({
            type: 'queryVersionsList',
            payload: {
              project_id: payload.project_id,
            },
            callback: () => {
              callback(response.data);
            },
          });
        }
      } catch (error) {
        console.error(error);
      }
    },

    // =================================================================================================================================
    *queryFlowInfo({ payload, callback }, { call, put }) {
      const response = yield call(queryFlowInfo, payload);
      if (response) {
        var flow = response.data[0];
        flow.current = flow.list.FlowNodes.findIndex(item => item.id == flow.active);
        flow.currentNode = flow.list.FlowNodes[flow.current];
        yield put({
          type: 'save',
          payload: { flow: flow },
        });
        // 查询当前节点的最新sheet信息
        yield put({
          type: 'querySheet',
          payload: {
            project_id: payload.projectId,
            flow_id: flow.currentNode.flow_id,
            node_id: flow.currentNode.id,
          },
          callback: sheets => {
            callback && callback(flow, sheets);
          },
        });
      }
    },
    *queryFlowInfoList({ payload, callback }, { call, put }) {
      const response = yield call(queryFlowInfo, payload);
      if (response) {
        var flow = response.data[0];
        flow.current = flow.list.FlowNodes.findIndex(item => item.id == flow.active);
        flow.currentNode = flow.list.FlowNodes[flow.current];
        yield put({
          type: 'save',
          payload: { flow: flow },
        });
        callback && callback();
      }
    },
    *updateFlowInfo({ payload }, { call, put }) {
      const response = yield call(updateFlowInfo, payload);
      if (response) {
        message.success('修改成功');
        yield put({
          type: 'queryFlowInfoList',
          payload: {
            projectId: payload.projectId,
          },
        });
      }
    },
    // *queryHistory({ payload, callback }, { call, put }) {
    //   payload.pageSize = '9999';
    //   const response = yield call(queryHistory, payload);
    //   if (response) {
    //     yield put({
    //       type: 'save',
    //       payload: { history: response.data },
    //     });
    //     callback(response.data);
    //   }
    // },
    *submitAudit({ payload, callback }, { call, put }) {
      const response = yield call(submitAudit, payload);
      if (response) {
        message.success('提交审核成功');
        yield put({
          type: 'queryHistory',
          payload: {
            projectId: payload.projectId,
            excel_id: payload.id,
          },
        });
        yield put({
          type: 'queryFlowInfo',
          payload: {
            projectId: payload.projectId,
          },
        });
      }
    },
    // *approve({ payload, callback }, { call, put }) {
    //   try {
    //     const response = yield call(approve, payload);
    //     if (response) {
    //       message.success('操作成功');
    //       yield put({
    //         type: 'queryHistory',
    //         payload: {
    //           projectId: payload.projectId,
    //           excel_id: payload.id,
    //         },
    //       });
    //       yield put({
    //         type: 'queryFlowInfo',
    //         payload: {
    //           projectId: payload.project_id,
    //         },
    //         callback,
    //       });
    //     }
    //   } catch (error) {
    //     console.error(error);
    //   }
    // },

    *queryHistoryDetail({ payload, callback }, { call, put }) {
      const response = yield call(queryHistoryDetail, payload);
      if (response) {
        let sheets = response.data;
        sheets.forEach(item => {
          item.config = JSON.parse(item.config) || {};
          item.celldata = JSON.parse(item.cell_data) || [];
          delete item.cell_data;
        });
        callback && callback(sheets);
      }
    },
    *queryComment({ payload }, { call, put }) {
      const response = yield call(queryComment, payload);
      if (response) {
        yield put({
          type: 'save',
          payload: { comment: response.data },
        });
      }
    },
    *addComment({ payload, callback }, { call, put }) {
      const response = yield call(addComment, payload);
      if (response) {
        yield put({
          type: 'queryComment',
          payload,
        });
        message.success('评论成功');
        callback && callback();
      }
    },
    *createExcel({ payload, callback }, { call, put }) {
      const response = yield call(createExcel, payload);
      if (response) {
        yield put({
          type: 'queryExcel',
        });
        message.success('创建成功');
        callback && callback();
      }
    },
    *queryExcel({ payload }, { call, put }) {
      const response = yield call(queryExcel, payload);
      if (response) {
        yield put({
          type: 'save',
          payload: { excel: response.data },
        });
      }
    },
    // *commitSheet({ payload, callback }, { call, put }) {
    //   const response = yield call(commitSheet, payload);
    //   if (response) {
    //     const res = yield call(queryHistory, {
    //       excel_id: payload.id,
    //       project_id: payload.project_id,
    //     });
    //     yield put({
    //       type: 'save',
    //       payload: { history: res.data },
    //     });
    //     const lastCommit = res.data.list[0];
    //     message.success('提交成功');
    //     yield put({
    //       type: 'queryHistoryDetail',
    //       payload: {
    //         excel_id: lastCommit.excel_id,
    //         history_id: lastCommit.id,
    //       },
    //       callback: sheets => {
    //         lastCommit.data = sheets;
    //         lastCommit.name = lastCommit.version_name;
    //         callback(lastCommit);
    //       },
    //     });
    //   }
    // },
    *querySheet({ payload, callback }, { call, put }) {
      const response = yield call(querySheet, payload);
      if (response) {
        let sheet = response.data;
        sheet.data = JSON.parse(sheet.data || '[]');
        sheet.data.forEach(item => {
          item.config = JSON.parse(item.config || '{}');
          item.celldata = JSON.parse(item.cell_data || '[]');
          delete item.cell_data;
        });
        callback && callback(sheet);
      }
    },
    *queryFiles({ payload }, { call, put }) {
      const response = yield call(queryFiles, payload);
      if (response) {
        yield put({
          type: 'save',
          payload: { fileList: response.data.list },
        });
      }
    },
    *deleteFiles({ id, callback }, { call }) {
      const response = yield call(deleteFiles, id);
      if (response) {
        callback && callback();
      }
    },
    *getPermission({ payload }, { call, put }) {
      const response = yield call(queryProjectMenu, payload);
      if (response) {
        console.log(response.data);
        // yield put({
        //   type: 'save',
        //   payload: { fileList: response.data.list },
        // });
      }
    },
    *getRoleList({ payload }, { call, put }) {
      const response = yield call(queryRole, payload);
      if (response) {
        yield put({
          type: 'save',
          payload: { roleList: response.data.list },
        });
      }
    },
    *queryVersionsTree({ payload }, { call, put }) {
      const response = yield call(queryVersionsTree, payload);
      if (response) {
        yield put({
          type: 'save',
          payload: { versionTree: response.data },
        });
      }
    },
    *queryAuditExcel({ payload, callback }, { call, put }) {
      const response = yield call(queryAuditExcel, payload);
      if (response) {
        callback && callback(response.data?.all);
      }
    },
    *queryAuditRecord({ payload, callback }, { call, put }) {
      const response = yield call(queryAuditRecord, payload);
      if (response) {
        callback && callback(response.data?.all);
      }
    },
    *queryDingSchema({ payload, callback }, { call, put }) {
      const response = yield call(queryDingSchema, payload);
      if (response) {
        callback && callback(response.data?.all);
      }
    },
    *queryDingInstanceDetail({ payload, callback }, { call, put }) {
      const response = yield call(queryDingInstanceDetail, payload);
      if (response) {
        yield put({
          type: 'save',
          payload: { dingInstanceDetail: response.data?.process_instance },
        });
      }
    },
    *queryListParentByUser({ payload, callback }, { call, put }) {
      const response = yield call(queryListParentByUser, payload);
      if (response) {
        yield put({
          type: 'save',
          payload: { parentDepList: response.data?.result },
        });
      }
    },
    *queryClassify ({ payload, callback }, { call, put }) {
      const data = yield call(queryClassify, payload);
      if (data) {
         yield put({
          type: 'save',
          payload: {
            typeOptions: data?.map(item=>{return {...item, label:item.name, value:item.id}}),
          },
        });
      }
    },
    *queryBindClassify({ payload, callback }, { call, put }) {
      const data = yield call(queryBindClassify, payload);
      if (data) {
         yield put({
          type: 'save',
          payload: {
            classifyList: data?.map(item=>{return {...item, label:item.name, value:item.id}}),
          },
        });
      }
    },
  },

  reducers: {
    saveHistory(state, action) {
      return {
        ...state,
        historyList: {
          ...state.historyList,
          ...action.payload,
        },
      };
    },
    save(state, action) {
      return {
        ...state,
        ...action.payload,
      };
    },
  },
};