import { getMap, formatTreeData } from '@src/services/Tools';
import main from './main';
import course from './course';
import tools from './tools';
import error from './error';
import note from './note';
import answer from './answer';
import report from './report';
import data from './data';
import collect from './collect';
import order from './order';
import message from './message';

import { TextbookMinYear, CourseModule } from '../../../Constant';
import { Main } from '../../stores/main';

export default [main, course, tools, error, note, answer, report, data, collect, order, message];


export function refreshQuestionType(compontent, subject, questionType, { all, needSentence, allSubject }) {
  return Main.getExercise().then(result => {
    const list = result.filter(row => (needSentence ? true : row.isExamination)).map(row => {
      row.title = `${row.titleZh}${row.titleEn}`;
      row.key = row.extend;
      return row;
    });
    const tree = formatTreeData(list, 'id', 'title', 'parentId');
    compontent.questionSubjectMap = getMap(tree, 'key', 'children');
    compontent.questionSubjectSelect = tree.filter(row => row.level === 1 && (allSubject ? true : row.children.length > 1));
    if (all) {
      compontent.questionSubjectSelect.forEach(row => {
        row.children.unshift({
          title: '全部',
          key: '',
        });
      });
      compontent.questionSubjectSelect.unshift({
        title: '全部',
        key: '',
      });
    }
    compontent.setState({
      questionSubjectSelect: compontent.questionSubjectSelect,
      questionSubjectMap: compontent.questionSubjectMap,
    });
    return {
      questionTypes: questionType || (subject ? compontent.questionSubjectMap[subject].map(row => row.key).filter(row => row) : null),
    };
  });
}

export function refreshStruct(compontent, questionTypes, module, one, two, { all, needTextbook, needPreview }) {
  switch (module) {
    case 'exercise':
      return Main.getExerciseAll().then(result => {
        const tmp = result.filter(row => row.level > 2).map(row => {
          row.title = `${row.titleZh}`;
          row.key = row.titleEn;
          return row;
        });
        const idsMap = getMap(tmp, 'id', 'key');
        const map = {};
        tmp.forEach(row => {
          if (!map[row.key]) {
            map[row.key] = {
              title: row.title,
              key: row.key,
              structIds: [],
              parentId: row.level > 3 ? idsMap[row.parentId] : null,
              questionTypes: [],
            };
          }
          const item = map[row.key];
          item.structIds.push(row.id);
          if (item.questionTypes.indexOf(row.extend) < 0) {
            item.questionTypes.push(row.extend);
          }
        });
        let list = Object.values(map);
        if (questionTypes && questionTypes.length > 0) {
          list = list.filter(row => row.questionTypes.filter((v) => questionTypes.indexOf(v) >= 0).length);
        }
        if (needPreview) {
          list.push({
            title: '预习作业',
            key: 'preview',
            id: 'preview',
          });
          CourseModule.forEach(row => {
            list.push({
              title: row.label,
              key: row.value,
              parentId: 'preview',
            });
          });
        }
        let courseModules = null;
        let structIds = null;
        if (one === 'preview') {
          if (!two) {
            courseModules = CourseModule.map(row => row.value);
          } else {
            courseModules = [two];
          }
        } else if (one) {
          const resultMap = getMap(list, 'key', 'structIds');
          if (!two) {
            structIds = resultMap[one];
          } else {
            structIds = resultMap[two];
          }
        }
        const tree = formatTreeData(list, 'key', 'title', 'parentId');
        const oneSelect = tree;
        const twoSelectMap = getMap(tree, 'key', 'children');
        if (all) {
          oneSelect.forEach(row => {
            row.children.unshift({
              title: '全部',
              key: '',
            });
          });
          oneSelect.unshift({
            title: '全部',
            key: '',
          });
        }
        compontent.setState({ oneSelect, twoSelectMap });

        return {
          structIds,
          courseModules,
        };
      });
    case 'examination':
      return Main.getExamination().then(result => {
        const list = result.map(row => {
          row.title = `${row.titleZh}${row.titleEn}`;
          row.key = `${row.id}`;
          return row;
        });
        if (needTextbook) {
          list.push({
            title: '数学机经',
            key: 'textbook',
            id: 'textbook',
          });
          list.push({
            title: '最新',
            key: 'latest',
            parentId: 'textbook',
          });

          const nowYear = new Date().getFullYear();
          for (let i = TextbookMinYear; i <= nowYear; i += 1) {
            list.push({
              title: i.toString(),
              key: i.toString(),
              parentId: 'textbook',
            });
          }
        }
        let latest = null;
        let year = null;
        let structIds = null;
        if (one === 'textbook') {
          if (!two) {
            latest = false;
          } else if (two === 'latest') {
            latest = true;
          } else {
            year = two;
          }
        } else if (one) {
          if (!two) {
            structIds = [Number(one)];
          } else {
            structIds = [Number(two)];
          }
        }

        const tree = formatTreeData(list, 'key', 'title', 'parentId');
        const oneSelect = tree;
        const twoSelectMap = getMap(tree, 'key', 'children');
        if (all) {
          oneSelect.forEach(row => {
            row.children.unshift({
              title: '全部',
              key: '',
            });
          });
          oneSelect.unshift({
            title: '全部',
            key: '',
          });
        }
        compontent.setState({ oneSelect, twoSelectMap });
        return {
          structIds,
          latest,
          year,
        };
      });
    default:
      return Promise.resolve({});
  }
}