import {
  getProject,
  getFaultAnalysis,
  getIssueList,
  getProjectActive,
  getNotificationList,
  getMediaList,
  getMonitorList,
  getUserGuide,
  getDailyList,
  getProjectProgress,
  deleteFile,
  getProjectTotalProgress,
  getLayoutOptions,
  saveLayoutOptions,
  getProjectAlarm,
  getBreakdownRecord,
  getProjectList,
  getAutoPatrol,
  getBreakdownList,
  getPatrolRecord,
} from '@/services/DataMeter';
import { queryProjectFileList } from '@/services/FileAdmin';
import { getprojectPlanProgress, getProjectRealProgress } from '@/services/projectPlanProgress';
import { getRepairRecord } from '@/services/EquipmentMaintenance';
import { queryConfigList, queryTemplateList } from '@/services/CharUtils';
import { queryPatrolRecord } from '@/services/patrol';
import { message } from 'antd';
import { DEFAULT_LAYOUT, DEFAULT_MAP_LAYOUT } from '@/components/DataMeter/config';
import { getDefaultConfList } from '@/services/ProjectAdmin';
const PLAN_TYPE = {
  15: 1,
  3: 3,
  12: 4,
};

export default {
  namespace: 'dataMeterNew',
  state: {
    projectDetail: {},
    faultAnalysis: [],
    issueList: [],
    projectActive: [],
    news: [],
    memorabilia: [],
    awards: [],
    notificationList: [],
    projectAlarmList: [],
    repairList: [],
    breakdownList: [],
    mediaImgList: [],
    mediaVideo: null,
    monitorList: [],
    userGuideList: [],
    dailyList: [],
    projectProgress: null,
    projectTotalProgress: {
      AllProgress: 0,
    },
    layout: {
      0: {
        config_json: [],
      },
      1: {
        config_json: [],
      },
      2: {
        config_json: [],
      },
    },
    chartConfigList: [],
    realProgress: {},
    progress: {},
    // currentChart: {}
    projectList: [],
    autoReport: {},
    patrolRecordDetail: {},
    patrolList: [],
    fileList: [],
    defaultConf: {},
    layoutAdmin: {
      0: {
        config_json: [],
      },
      1: {
        config_json: [],
      },
      2: {
        config_json: [],
      },
    },
  },

  effects: {
    *getAutoPatrol({ payload, callback }, { call, put }) {
      const response = yield call(getAutoPatrol, payload);
      if (response) {
        // 查询数据报表详情
        const { data } = yield call(queryPatrolRecord, { recordId: response.data[0].Id });
        if (data) {
          const creatorName = data.CreatorUser && data.CreatorUser.CName;
          var status = {};
          let Items = [];
          const getItems = (item, patrolType) => {
            let key;
            if (patrolType == 1) {
              key = item.PatrolName;
            } else {
              key = item.DeviceCode + '-' + item.DeviceName;
            }
            item.patrolType = patrolType;
            item.ThresholdEnum = item.TemplateItem.ThresholdEnum;
            item.Type = item.TemplateItem.Type;
            if (!status[key]) status[key] = { normal: 0, error: 0 };
            if (item.Status == 1) {
              status[key].error++;
            } else {
              status[key].normal++;
            }
            return item;
          };
          data.ItemsExtend.forEach(item => {
            console.log(Items);
            if (item.PatrolCardRecordItemAssocThreshold) {
              var arr = item.PatrolCardRecordItemAssocThreshold.map(i => getItems(i, 1));
              Items = Items.concat(arr);
            } else {
              Items.push(getItems(item, 0));
            }
          });
          data.Items = Items;

          data.Points.forEach(item => {
            let key;
            if (item.PatrolType == 1) {
              key = item.DeviceName;
            } else {
              key = item.DeviceCode + '-' + item.DeviceName;
            }
            item.creatorName = creatorName;
            item.level = `${item.ExceptionLevel || '-'}/${item.DeviceLevel || '-'}`;
            item.status = status[key] || { normal: 0, error: 0 };
          });
          console.log(data);
          callback && callback(data);
          yield put({
            type: 'save',
            payload: { autoReport: data },
          });
        }
      }
    },
    *getProject({ payload }, { call, put }) {
      const response = yield call(getProject, payload);
      if (response) {
        yield put({
          type: 'save',
          payload: { projectDetail: response.data },
        });
      }
    },
    *getFaultAnalysis({ payload }, { call, put }) {
      const response = yield call(getFaultAnalysis, payload);
      if (response) {
        var list = [];
        response.data.forEach(item => {
          item.Details.forEach(err => {
            list.push({
              ...item,
              ...err,
            });
          });
        });
        yield put({
          type: 'save',
          payload: { faultAnalysis: list },
        });
      }
    },
    *getIssueList({ payload }, { call, put }) {
      const response = yield call(getIssueList, payload);
      if (response) {
        yield put({
          type: 'save',
          payload: { issueList: response.data.list },
        });
      }
    },
    *getRepairRecord({ payload }, { call, put }) {
      const response = yield call(getRepairRecord, payload);
      if (response) {
        yield put({
          type: 'save',
          payload: { repairList: response.data.list },
        });
      }
    },
    *getBreakdownRecord({ payload }, { call, put }) {
      const response = yield call(getBreakdownList, payload);
      if (response) {
        yield put({
          type: 'save',
          payload: { breakdownList: response.data.list },
        });
      }
    },
    *getPatrolRecord({ payload }, { call, put }) {
      const response = yield call(getPatrolRecord, payload);
      if (response) {
        yield put({
          type: 'save',
          payload: { patrolList: response.data.list },
        });
      }
    },
    *getProjectAlarm({ payload }, { call, put }) {
      const response = yield call(getProjectAlarm, payload);
      if (response) {
        yield put({
          type: 'save',
          payload: { projectAlarmList: response.data.list },
        });
      }
    },
    *getProjectActive({ payload }, { call, put }) {
      const response = yield call(getProjectActive, payload);
      if (response) {
        let stateName;

        // 0-项目动态 1-新闻动态 2-大事记 3-所获奖项
        switch (payload.type) {
          case 0:
            stateName = 'projectActive';
            break;
          case 1:
            stateName = 'news';
            break;
          case 2:
            stateName = 'memorabilia';
            break;
          case 3:
            stateName = 'awards';
            break;
        }
        if (!stateName) return;
        yield put({
          type: 'save',
          payload: { [stateName]: response.data.list },
        });
      }
    },
    *getNotificationList({ payload }, { call, put }) {
      const response = yield call(getNotificationList, payload);
      if (response) {
        yield put({
          type: 'save',
          payload: { notificationList: response.data.list },
        });
      }
    },
    *getMediaList({ payload }, { call, put }) {
      const response = yield call(getMediaList, payload);
      if (response) {
        var mediaVideo = null,
          mediaImgList = [];
        response.data.forEach(item => {
          if (/\.mp4$/.test(item.Name)) {
            if (!mediaVideo) {
              mediaVideo = item;
            }
          } else {
            mediaImgList.push(item);
          }
        });
        yield put({
          type: 'save',
          payload: {
            mediaVideo,
            mediaImgList,
          },
        });
      }
    },
    *getMonitorList({ payload }, { call, put }) {
      const response = yield call(getMonitorList, payload);
      if (response) {
        var obj = JSON.parse(response.data.config_json) || {};
        yield put({
          type: 'save',
          // payload: { monitorList: response.data.list },
          payload: { monitorList: Object.keys(obj).map(key => obj[key]) || [] },
        });
      }
    },
    *getUserGuide({ payload }, { call, put }) {
      const response = yield call(getUserGuide, payload);
      if (response) {
        var list = [];
        response.data.list.forEach(item => {
          item.UserGuideFiles.forEach(file => {
            list.push({
              ...item,
              ...file,
            });
          });
        });
        yield put({
          type: 'save',
          payload: { userGuideList: list },
        });
      }
    },
    *getDailyList({ payload }, { call, put }) {
      const response = yield call(getDailyList, payload);
      if (response) {
        yield put({
          type: 'save',
          payload: { dailyList: response.data.list },
        });
      }
    },

    *getProjectPlanProgress({ payload, callback }, { call, put }) {
      const response = yield call(getprojectPlanProgress, payload);
      if (response) {
        var progress = response.data;
        Object.keys(progress).forEach(k => {
          if (
            progress[k] == '0001-01-01T00:00:00Z' ||
            progress[k] == '0001-01-01 00:00:00' ||
            progress[k] == '0001-01-01 00:00:00 +0000 UTC'
          ) {
            progress[k] = '';
          }
        });
        yield put({
          type: 'save',
          payload: { progress },
        });
      }
    },
    *getProjectRealProgress({ payload }, { call, put, select }) {
      const calcProgress = data => {
        let count = 0,
          total = 0;
        data.forEach(item => {
          total += item.TotalCount;
          count += item.RealCount;
        });
        return ((count / total) * 100).toFixed(2);
      };
      let { realProgress } = yield select(s => s.dataMeterNew);
      console.log(realProgress);
      var keys = Object.keys(PLAN_TYPE);
      for (let i = 0; i < keys.length; i++) {
        let k = keys[i];
        var response = yield call(getProjectRealProgress, {
          ...payload,
          type: PLAN_TYPE[k],
        });
        if (response) {
          let tempRealProgress = response.data.Task.map(item => ({
            ...item,
            RealCount: item.FinishList.length || 0,
            TotalCount: item.DeviceCodes ? item.DeviceCodes.length : 0,
            children: null,
          }));
          console.log(tempRealProgress);
          realProgress[k] = calcProgress(tempRealProgress);
        }
      }
      yield put({
        type: 'save',
        payload: { realProgress: { ...realProgress } },
      });
    },
    *getProjectProgress({ payload }, { call, put }) {
      const response = yield call(getProjectProgress, payload);
      if (response) {
        yield put({
          type: 'save',
          payload: { projectProgress: response.data },
        });
      }
    },
    *deleteFile({ payload }, { call, put }) {
      const response = yield call(deleteFile, payload);
      if (response) {
        yield put({
          type: 'getMediaList',
          payload: payload,
        });
      }
    },
    *getProjectTotalProgress({ payload }, { call, put }) {
      const response = yield call(getProjectTotalProgress, payload);
      if (response) {
        yield put({
          type: 'save',
          payload: { projectTotalProgress: response.data },
        });
      }
    },
    *getLayoutOptions({ payload }, { call, put, select }) {
      // if (payload.is_default == 1) {
      //   // 默认配置的projectId为0
      //   payload.projectId = 0;
      // }
      const response = yield call(getLayoutOptions, payload);
      if (response) {
        var layout = yield select(state => state.dataMeterNew.layout);
        if (payload.is_default == 1) {
          layout = yield select(state => state.dataMeterNew.layoutAdmin);
        }
        var defaultLayout = payload.sub_module === 0 ? DEFAULT_MAP_LAYOUT : DEFAULT_LAYOUT;
        var data = response.data;
        try {
          data.config_json = JSON.parse(data.config_json);
          // response.data.config_json = defaultLayout;
        } catch (error) {
          // 解析失败则使用默认布局
          data.config_json = defaultLayout;
          console.log(error);
        }
        layout[payload.sub_module] = data;
        if (payload.is_default == 0)
          yield put({
            type: 'save',
            payload: { layout: { ...layout } },
          });
        else
          yield put({
            type: 'save',
            payload: { layoutAdmin: { ...layout } },
          });
      }
    },
    *saveLayoutOptions({ payload }, { call, put, select }) {
      // if (payload.is_default == 1) {
      //   // 默认配置的projectId为0
      //   payload.projectId = 0;
      // }
      if (payload.config_json == '[]') {
        message.error('保存的配置不能为空');
        return;
      }
      var response = yield call(saveLayoutOptions, payload);
      if (response) {
        var layout = yield select(state => state.dataMeterNew.layout);
        if (payload.is_default == 1) {
          layout = yield select(state => state.dataMeterNew.layoutAdmin);
        }
        console.log(payload.config_json);
        layout[payload.sub_module].config_json = JSON.parse(payload.config_json);
        if (payload.is_default == 0)
          yield put({
            type: 'save',
            payload: { layout: { ...layout } },
          });
        else
          yield put({
            type: 'save',
            payload: { layoutAdmin: { ...layout } },
          });
      }
    },
    *resizeLayout({ payload }, { call, select, put }) {
      // 默认配置的projectId为0
      const response = yield call(getLayoutOptions, {
        ...payload,
        // projectId: 0,
      });
      if (response) {
        var layout = yield select(state => state.dataMeterNew.layout);
        var defaultLayout = payload.sub_module === 0 ? DEFAULT_MAP_LAYOUT : DEFAULT_LAYOUT;
        var config_json = response.data.config_json
          ? JSON.parse(response.data.config_json)
          : defaultLayout;
        // response.data.config_json = defaultLayout;

        // 将默认配置保存到本地
        layout[payload.sub_module].config_json = config_json;
        yield put({
          type: 'save',
          payload: { layout: { ...layout } },
        });
        yield call(saveLayoutOptions, {
          ...payload,
          config_json: JSON.stringify(config_json),
          is_default: 0,
        });
      }
    },
    *resizeDefaultLayout({ payload }, { call, select, put }) {
      var layout = yield select(state => state.dataMeterNew.layout);
      var config_json = payload.sub_module === 0 ? DEFAULT_MAP_LAYOUT : DEFAULT_LAYOUT;

      // 将默认配置保存到本地
      layout[payload.sub_module].config_json = config_json;
      yield put({
        type: 'save',
        payload: { layout: { ...layout } },
      });
      yield call(saveLayoutOptions, {
        ...payload,
        config_json: JSON.stringify(config_json),
        is_default: 0,
      });
    },
    *queryConfigList({ payload, callback }, { call, put }) {
      const {
        data: { list: tplList },
      } = yield call(queryTemplateList, { pageSize: 999 });
      const {
        data: { list: configList },
      } = yield call(queryConfigList, {
        ...payload,
        isNew: 1,
        pageSize: 9999,
      });
      let list = [];
      configList.map(item => {
        let template = tplList.find(tpl => tpl.ID == item.type);
        item.options = JSON.parse(item.options);
        item.template = template;
        list.push(item);
      });
      callback && callback(list);
      yield put({
        type: 'save',
        payload: {
          chartConfigList: list,
        },
      });
    },
    *queryConfig({ payload, callback }, { call, put }) {
      const response = yield call(queryConfigList, payload);
      if (response) {
        var currentChart = response.data.list[0];
        currentChart.options = JSON.parse(currentChart.options);
        let { options, configs, type } = currentChart;

        // 将接口返回的实时数据更新到图表中
        if (type != 'pfd') {
          if (!options.series) {
            callback && callback(currentChart);
          }
          let series = options.series[0];
          if (type == 'pie') {
            configs.forEach((item, index) => {
              series.data[index].value = item.value;
            });
          } else if (series.type == 'bar') {
            configs.forEach((item, index) => {
              series.data[index] = item.value;
            });
          }
        }
        callback && callback(currentChart);
        // yield put({
        //   type: 'save',
        //   payload: {
        //     currentChart,
        //   },
        // });
      }
    },
    *getProjectList({ payload, callback }, { call, put }) {
      const response = yield call(getProjectList, payload);
      if (response) {
        let nowDate = new Date();
        (response.data.list || []).map(item => {
          let type;
          if (!item.EndDate) {
            type = 2;
          } else {
            type = nowDate >= new Date(item.EndDate) ? 2 : 1;
          }
          item.type = type;
        });
        yield put({
          type: 'save',
          payload: { projectList: response.data.list },
        });
        console.log(response.data.list);
        callback && callback(response.data.list);
      }
    },
    *queryProjectFileList({ payload }, { call, put, select }) {
      try {
        const response = yield call(queryProjectFileList, {
          ...payload,
          deviceCode: -1,
        });
        if (response) {
          yield put({
            type: 'save',
            payload: { fileList: response.data },
          });
        }
      } catch (e) {
        console.error(e);
      }
    },
    *getDefaultConfList({ payload }, { call, put }) {
      const response = yield call(getDefaultConfList, payload);
      if (response) {
        yield put({
          type: 'save',
          payload: { defaultConf: response.data },
        });
      }
    },
  },

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