package com.seecoder.dataanalysis.logic.parser.impl;

import com.alibaba.fastjson.JSONException;
import com.seecoder.dataanalysis.analysis.DevcloudDataAnalysisService;
import com.seecoder.dataanalysis.analysis.EvalDataAnalysisService;
import com.seecoder.dataanalysis.data.dao.devcloud.DevcloudInfoDao;
import com.seecoder.dataanalysis.data.dao.eval.EvalExamInfoDao;
import com.seecoder.dataanalysis.data.dao.eval.EvalExamRecordDao;
import com.seecoder.dataanalysis.data.entity.devcloud.*;
import com.seecoder.dataanalysis.data.entity.eval.EvalExamInfo;
import com.seecoder.dataanalysis.data.entity.eval.EvalExamRecord;
import com.seecoder.dataanalysis.data.entity.eval.User;
import com.seecoder.dataanalysis.logic.parser.LogParsingService;
import com.seecoder.dataanalysis.logic.parser.ParsingException;
import com.seecoder.dataanalysis.logic.parser.convertor.LogConvertor;
import com.seecoder.dataanalysis.util.JsonUtil;
import com.seecoder.dataanalysis.util.Messages;
import com.seecoder.dataanalysis.vo.*;
import com.seecoder.dataanalysis.vo.devcloud.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import javax.annotation.PostConstruct;
import java.util.*;

/**
 * @author miaomuzhi
 * @since 2022/1/30
 */
@Service
public class LogParsingServiceImpl implements LogParsingService {

    @Autowired
    private DevcloudDataAnalysisService devcloudDataAnalysisService;

    @Autowired
    private EvalDataAnalysisService evalDataAnalysisService;


    /**
     * 根据日志元数据操作类型(op_type)查找对应的类名
     */
    private Map<Integer, String> opTypesTable;

    private EvalExamRecordDao evalExamRecordDao;
    private EvalExamInfoDao evalExamInfoDao;
    private DevcloudInfoDao devcloudInfoDao;

    @Autowired
    public void setEvalExamRecordDao(EvalExamRecordDao evalExamRecordDao) {
        this.evalExamRecordDao = evalExamRecordDao;
    }
    @Autowired
    public void setEvalExamInfoDao(EvalExamInfoDao evalExamInfoDao) {
        this.evalExamInfoDao = evalExamInfoDao;
    }
    @Autowired
    public void setDevcloudInfoDao(DevcloudInfoDao devcloudInfoDao) {
        this.devcloudInfoDao = devcloudInfoDao;
    }


    @Override
    public SimpleLog parseLog(String log) throws ParsingException{
        try {
            return JsonUtil.toObject(log, SimpleLog.class);
        } catch (JSONException e) {
            e.printStackTrace();
            throw new ParsingException(e.toString(), 0, log);
        }
    }

    @Override
    @SuppressWarnings("unchecked")
    public <T> T parseLogData(SimpleLog simpleLog, boolean save) throws ParsingException{
        if (simpleLog == null) {
            return null;
        }

        try {
            String className = parseOpType(simpleLog.getOpType());
            Class clazz = Class.forName(className);
            Object data = JsonUtil.toObject(simpleLog.getData(), clazz);

            if (save) {
                saveToDb(data, className);
            }
            return (T) data;
        } catch (ClassNotFoundException|ClassCastException e){
            e.printStackTrace();
            throw new ParsingException(e.toString(), 4, simpleLog.getData());
        }  catch (JSONException e) {
            e.printStackTrace();
            throw new ParsingException(e.toString(), 1, simpleLog.getData());
        }
    }

    @Override
    public String parseOpType(int opType) throws ParsingException {
        if (!opTypesTable.containsKey(opType)) {
            throw new ParsingException("不支持的操作类型：" + opType, 2);
        }
        return opTypesTable.get(opType);
    }


    @PostConstruct
    protected void buildOpTypesTable(){
        opTypesTable = new HashMap<>();
        opTypesTable.put(0, EvalExamInfoDTO.class.getName());  //试卷数据
        opTypesTable.put(1, EvalExamInfoDTO.class.getName());  //诗句更新数据
        opTypesTable.put(2, EvalExamRecordDTO.class.getName());  //学生提交试卷

        opTypesTable.put(100, BugInfoDTO.class.getName());  //新建/修改缺陷信息
        opTypesTable.put(101, CommitInfoDTO.class.getName());  //用户进行commit
        opTypesTable.put(102, TestInfoDTO.class.getName());  //用户创建并执行接口测试
        opTypesTable.put(103, PipelineCreationDTO.class.getName());  //用户创建流水线
        opTypesTable.put(104, PipelineDeletionDTO.class.getName());  //用户删除流水线
        opTypesTable.put(105, PipelineDeployDTO.class.getName());  //用户部署流水线
        opTypesTable.put(106, TreeNodeInfoDTO.class.getName());  //用户插入/更新节点
        opTypesTable.put(107, TreeNodeDeletionDTO.class.getName());  //用户删除节点
        opTypesTable.put(108, AddProjectDTO.class.getName());//将成员加入项目
        opTypesTable.put(109, RelateProjectDTO.class.getName());//项目A和项目B关联
        opTypesTable.put(110, ProjectDTO.class.getName());//创建项目
        opTypesTable.put(111, UserDTO.class.getName());//创建用户
    }


    private void saveToDb(Object data, String className) throws ParsingException {
        if (className.equals(EvalExamInfoDTO.class.getName())) {
            EvalExamInfo info = LogConvertor.convertToEvalExamInfoEntity((EvalExamInfoDTO) data);
            evalExamInfoDao.save(info);

        } else if (className.equals(EvalExamRecordDTO.class.getName())) {
            //TODO DTO的id和实体id的匹配似乎出了问题？
            EvalExamRecord record = LogConvertor.convertToEvalExamRecordEntity((EvalExamRecordDTO) data);
            evalExamRecordDao.save(record);
//            evalDataAnalysisService.updateCompetencyTreeType2((EvalExamRecordDTO) data);
            System.out.println("record_id: "+record.getRecordId());
            evalDataAnalysisService.getTreeAfterExam(record.getRecordId());
//            evalDataAnalysisService.getTreeAfterExam(((EvalExamRecordDTO) data).getRecordId());

        //Devcloud op_type100-111
        } else if (className.equals(BugInfoDTO.class.getName())) {
            BugInfoDTO bugInfoDTO = (BugInfoDTO) data;
            if (bugInfoDTO.getProjectId() == null) {
                throw new ParsingException(Messages.PROJECT_ID_NOT_FOUND, 3, data.toString());
            }

            devcloudDataAnalysisService.updateDevInfoType100(bugInfoDTO);

//            BugInfo info = LogConvertor.convertToBugInfoEntity(bugInfoDTO);
//            Optional<DevcloudInfo> devcloudInfo = devcloudInfoDao.findById(bugInfoDTO.getProjectId());
//            DevcloudInfo devcloudInfoEntity = devcloudInfo.orElseGet(() -> createDevCloudInfo(bugInfoDTO.getProjectId()));
//            devcloudInfoEntity.getBugList().add(info);
//            devcloudInfoDao.save(devcloudInfoEntity);

        } else if (className.equals(CommitInfoDTO.class.getName())) {
            CommitInfoDTO commitInfoDTO = (CommitInfoDTO) data;
            if (commitInfoDTO.getProjectId() == null) {
                throw new ParsingException(Messages.PROJECT_ID_NOT_FOUND, 3, data.toString());
            }

            devcloudDataAnalysisService.updateDevInfoType101(commitInfoDTO);

//            CommitInfo info = LogConvertor.convertToCommitInfoEntity(commitInfoDTO);
//            Optional<DevcloudInfo> devcloudInfo = devcloudInfoDao.findById(commitInfoDTO.getProjectId());
//            DevcloudInfo devcloudInfoEntity = devcloudInfo.orElseGet(() -> createDevCloudInfo(commitInfoDTO.getProjectId()));
//            devcloudInfoEntity.getCommitList().add(info);
//            devcloudInfoDao.save(devcloudInfoEntity);

        } else if (className.equals(TestInfoDTO.class.getName())) {
            TestInfoDTO testInfoDTO = (TestInfoDTO) data;
            if (testInfoDTO.getProjectId() == null) {
                throw new ParsingException(Messages.PROJECT_ID_NOT_FOUND, 3, data.toString());
            }

            devcloudDataAnalysisService.updateDevInfoType102(testInfoDTO);

//            TestInfo info = LogConvertor.convertToTestInfoEntity(testInfoDTO);
//            Optional<DevcloudInfo> devcloudInfo = devcloudInfoDao.findById(testInfoDTO.getProjectId());
//            DevcloudInfo devcloudInfoEntity = devcloudInfo.orElseGet(() -> createDevCloudInfo(testInfoDTO.getProjectId()));
//            devcloudInfoEntity.getTestList().add(info);
//            devcloudInfoDao.save(devcloudInfoEntity);

        } else if (className.equals(PipelineCreationDTO.class.getName())) {
            PipelineCreationDTO creationDTO = (PipelineCreationDTO) data;
            if (creationDTO.getProjectId() == null) {
                throw new ParsingException(Messages.PROJECT_ID_NOT_FOUND, 3, data.toString());
            }

            devcloudDataAnalysisService.updateDevInfoType103(creationDTO);

//            Optional<DevcloudInfo> devcloudInfo = devcloudInfoDao.findById(creationDTO.getProjectId());
//            DevcloudInfo devcloudInfoEntity = devcloudInfo.orElseGet(() -> createDevCloudInfo(creationDTO.getProjectId()));
//            PipelineInfo pipelineInfo = new PipelineInfo();
//            pipelineInfo.setPipelineId(creationDTO.getPipelineId());
//            devcloudInfoEntity.getPipelineList().add(pipelineInfo);
//            devcloudInfoDao.save(devcloudInfoEntity);

        } else if (className.equals(PipelineDeletionDTO.class.getName())) {
            PipelineDeletionDTO deletionDTO = (PipelineDeletionDTO) data;
//            Optional<DevcloudInfo> devcloudInfo = devcloudInfoDao.findById(deletionDTO.getProjectId());
//            //TODO 暂不处理删除部署
            devcloudDataAnalysisService.updateDevInfoType104(deletionDTO);

        } else if (className.equals(PipelineDeployDTO.class.getName())) {
            PipelineDeployDTO deployDTO = (PipelineDeployDTO) data;

            devcloudDataAnalysisService.updateDevInfoType105(deployDTO);

//            boolean foundPipeline = false;
//            for (DevcloudInfo devcloudInfo: devcloudInfoDao.findAll()) {
//                for (PipelineInfo info: devcloudInfo.getPipelineList()) {
//                    if (info.getPipelineId().equals(deployDTO.getPipelineId())) {
//                        info.setUserId(deployDTO.getUserId());  // 更新用户id
//                        int successInc = (deployDTO.getSuccess() ? 1 : 0);
//                        info.setSuccess(info.getSuccess() + successInc);
//                        info.setTotal(info.getTotal() + 1);
//                        foundPipeline = true;
//                        break;
//                    }
//                }
//
//                if (foundPipeline) {
//                    devcloudInfoDao.save(devcloudInfo);
//                    break;
//                }
//            }

        } else if (className.equals(TreeNodeInfoDTO.class.getName())) {
            TreeNodeInfoDTO nodeInfoDTO = (TreeNodeInfoDTO) data;
            if (nodeInfoDTO.getProjectId() == null) {
                throw new ParsingException(Messages.PROJECT_ID_NOT_FOUND, 3, data.toString());
            }

            devcloudDataAnalysisService.updateDevInfoType106(nodeInfoDTO);

//            TreeNodeInfo info = LogConvertor.convertToTreeNodeInfoEntity(nodeInfoDTO);
//            Optional<DevcloudInfo> devcloudInfo = devcloudInfoDao.findById(nodeInfoDTO.getProjectId());
//            DevcloudInfo devcloudInfoEntity = devcloudInfo.orElseGet(() -> createDevCloudInfo(nodeInfoDTO.getProjectId()));
//            devcloudInfoEntity.getTreeNodeList().add(info);
//            devcloudInfoDao.save(devcloudInfoEntity);

        } else if (className.equals(TreeNodeDeletionDTO.class.getName())) {
            TreeNodeDeletionDTO deletionDTO = (TreeNodeDeletionDTO) data;

            devcloudDataAnalysisService.updateDevInfoType107(deletionDTO);

//            for (DevcloudInfo devcloudInfo: devcloudInfoDao.findAll()) {
//                boolean updated = false;
//                List<TreeNodeInfo> deleteList = new ArrayList<>();
//                for (TreeNodeInfo info: devcloudInfo.getTreeNodeList()) {
//                    if (deletionDTO.getNodeIds().contains(info.getNodeId())) {
//                        deleteList.add(info);
//                        updated = true;
//                    }
//                }
//
//                if (updated) {
//                    devcloudInfo.getTreeNodeList().removeAll(deleteList);
//                    devcloudInfoDao.save(devcloudInfo);
//                }
//            }
        } else if (className.equals(AddProjectDTO.class.getName())){
            AddProjectDTO addProjectDTO = (AddProjectDTO) data;

            devcloudDataAnalysisService.updateDevInfoType108(addProjectDTO);

        } else if (className.equals(RelateProjectDTO.class.getName())){
            RelateProjectDTO relateProjectDTO = (RelateProjectDTO) data;

            devcloudDataAnalysisService.updateDevInfoType109(relateProjectDTO);

        } else if (className.equals(ProjectDTO.class.getName())){
            ProjectDTO projectDTO = (ProjectDTO) data;

            devcloudDataAnalysisService.updateDevInfoType110(projectDTO);

        } else if (className.equals(UserDTO.class.getName())){
            UserDTO userDTO = (UserDTO) data;

            devcloudDataAnalysisService.updateDevInfoType111(userDTO);

        }
    }

    private DevcloudInfo createDevCloudInfo(Integer projectId) {
        DevcloudInfo devcloudInfo = new DevcloudInfo(projectId, new ArrayList<>(), new ArrayList<>(),
                new ArrayList<>(), new ArrayList<>(), new ArrayList<>());
        this.devcloudInfoDao.save(devcloudInfo);
        return devcloudInfo;
    }
}