package com.gkhy.exam.system.service.impl;

import cn.hutool.core.util.ObjectUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.gkhy.exam.common.api.CommonPage;
import com.gkhy.exam.common.api.CommonResult;
import com.gkhy.exam.common.exception.ApiException;
import com.gkhy.exam.common.utils.PageUtils;
import com.gkhy.exam.common.utils.SecurityUtils;
import com.gkhy.exam.system.domain.ExpectContent;
import com.gkhy.exam.system.domain.ExpectContentMess;
import com.gkhy.exam.system.domain.ExpectDiscren;
import com.gkhy.exam.system.domain.ExpectEvaluate;
import com.gkhy.exam.system.mapper.ExpectContentMapper;
import com.gkhy.exam.system.mapper.ExpectDiscrenMapper;
import com.gkhy.exam.system.mapper.ExpectEvaluateMapper;
import com.gkhy.exam.system.service.ExpectDiscrenService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.List;

@Service
public class ExpectDiscrenServiceImpl extends ServiceImpl<ExpectDiscrenMapper, ExpectDiscren> implements ExpectDiscrenService {

    @Autowired
    private ExpectDiscrenMapper expectDiscrenMapper;

    @Autowired
    private ExpectContentMapper expectContentMapper;

    @Autowired
    private ExpectEvaluateMapper expectEvaluateMapper;


    @Override
    public CommonPage selectExpectDiscrenList(ExpectDiscren expectDiscren) {
        if (!SecurityUtils.adminUser()){
            if (expectDiscren.getCompanyId()==null){
                throw new ApiException("非管理员操作，企业id不可为空");
            }
        }
        PageUtils.startPage();
        List<ExpectDiscren> expectDiscrens = expectDiscrenMapper.selectDiscrenList(expectDiscren);
        for (ExpectDiscren discren : expectDiscrens) {
            List<ExpectContent> expectContents = expectContentMapper.selectByDiscrenId(discren.getId());
            for (ExpectContent expectContent : expectContents) {
                List<ExpectContentMess> expectContentMesses = expectContentMapper.selectByContentId(expectContent.getId());
                expectContent.setExpectContentMesses(expectContentMesses);
            }
            discren.setExpectContents(expectContents);
        }
        return CommonPage.restPage(expectDiscrens);
    }

    @Override
    @Transactional
    public CommonResult insertExpectDiscren(ExpectDiscren expectDiscren) {
        List<ExpectDiscren> expectDiscrens = expectDiscrenMapper.selectCompanyIdAndDeptId(expectDiscren);
        if (expectDiscrens.size()>0){
            throw new ApiException("当前企业已有数据，请删除后重试");
        }
        expectDiscren.setCreateBy(SecurityUtils.getUsername());
        expectDiscren.setCreateTime(LocalDateTime.now());
        expectDiscrenMapper.insert(expectDiscren);
        List<ExpectContent> expectContents = expectDiscren.getExpectContents();
        //循环新增相关方需求
        List<ExpectContentMess> expectContentMesseslist = new ArrayList<>();
        for (ExpectContent expectContent : expectContents) {

            expectContent.setExpectDiscrenId(expectDiscren.getId());
            expectContentMapper.insert(expectContent);

            //循环新增相关方需求详细内容
            List<ExpectContentMess> expectContentMesses = expectContent.getExpectContentMesses();
            for (ExpectContentMess expectContentMess : expectContentMesses) {
                expectContentMess.setExpectContentId(expectContent.getId());
            }
            expectContentMesseslist.addAll(expectContentMesses);
        }
        expectContentMapper.insertContentMess(expectContentMesseslist);

        return CommonResult.success();
    }

    @Override
    public CommonResult updateExpectDiscren(ExpectDiscren expectDiscren) {
        expectDiscren.setUpdateBy(SecurityUtils.getUsername());
        expectDiscren.setUpdateTime(LocalDateTime.now());
        expectDiscrenMapper.updateById(expectDiscren);
        List<ExpectContent> expectContents = expectDiscren.getExpectContents();
        expectContentMapper.deletedByDiscrenId(expectDiscren.getId());
        List<ExpectContentMess> expectContentMesses = new ArrayList<>();
        for (ExpectContent expectContent : expectContents) {
            expectContent.setId(null);
            expectContentMapper.insert(expectContent);
            List<ExpectContentMess> expectContentMesses1 = expectContent.getExpectContentMesses();
            for (ExpectContentMess expectContentMess : expectContentMesses1) {
                expectContentMess.setExpectContentId(expectContent.getId());
            }
            expectContentMesses.addAll(expectContentMesses1);
        }
        expectContentMapper.insertContentMess(expectContentMesses);
        return CommonResult.success();
    }

    @Override
    public CommonResult deletedExpectDiscren(Integer expectDiscrenId) {
        ExpectDiscren expectDiscren = new ExpectDiscren();
        expectDiscren.setId(expectDiscrenId);
        expectDiscren.setUpdateBy(SecurityUtils.getUsername());
        expectDiscren.setUpdateTime(LocalDateTime.now());
        expectDiscren.setDelFlag(2);
        expectDiscrenMapper.updateById(expectDiscren);
        return CommonResult.success();
    }

    @Override
    public CommonResult selectExpectDiscrenListAll(ExpectDiscren expectDiscren) {
        List<ExpectDiscren> expectDiscrens = expectDiscrenMapper.selectDiscrenList(expectDiscren);
        for (ExpectDiscren discren : expectDiscrens) {
            List<ExpectContent> expectContents = expectContentMapper.selectByDiscrenId(discren.getId());
            for (ExpectContent expectContent : expectContents) {
                List<ExpectContentMess> expectContentMesses = expectContentMapper.selectByContentId(expectContent.getId());
                expectContent.setExpectContentMesses(expectContentMesses);
            }
            discren.setExpectContents(expectContents);
        }
        return CommonResult.success(expectDiscrens);
    }

    @Override
    @Transactional
    public CommonResult copyExpectDiscren(Long companyId,String sourceYear, String targetYear) {
        if (companyId==null){
         companyId = SecurityUtils.getCompanyId();
        }
        LambdaQueryWrapper<ExpectDiscren> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(ExpectDiscren::getCompanyId, companyId)
                .eq(ExpectDiscren::getDelFlag, 1).eq(ExpectDiscren::getYear, targetYear);
        List<ExpectDiscren> expectDiscrensTarget = expectDiscrenMapper.selectList(queryWrapper);
        if (ObjectUtil.isNotEmpty(expectDiscrensTarget)){
            for (ExpectDiscren expectDiscren : expectDiscrensTarget) {
                deletedExpectDiscren(expectDiscren.getId());
                LambdaQueryWrapper<ExpectContent> queryWrapperContent = new LambdaQueryWrapper<>();
                queryWrapperContent.eq(ExpectContent::getExpectDiscrenId, expectDiscren.getId());
                List<ExpectContent> expectContents = expectContentMapper.selectList(queryWrapperContent);
                expectContentMapper.deletedByDiscrenId(expectDiscren.getId());
                if (ObjectUtil.isNotEmpty(expectContents)){
                    expectContentMapper.deletedByConentId(expectDiscren.getId());
                }

                LambdaUpdateWrapper<ExpectEvaluate> updateWrapper = new LambdaUpdateWrapper<>();
                updateWrapper.set(ExpectEvaluate::getDelFlag, 2).set(ExpectEvaluate::getUpdateBy, SecurityUtils.getUsername())
                        .eq(ExpectEvaluate::getUpdateTime, LocalDateTime.now()).eq(ExpectEvaluate::getExpectDiscrenId, expectDiscren.getId());
                expectEvaluateMapper.update(new ExpectEvaluate(), updateWrapper);
            }
        }

        LambdaQueryWrapper<ExpectDiscren> queryWrapperSource = new LambdaQueryWrapper<>();
        queryWrapperSource.eq(ExpectDiscren::getCompanyId, companyId)
                .eq(ExpectDiscren::getDelFlag, 1).eq(ExpectDiscren::getYear, sourceYear);
        List<ExpectDiscren> expectDiscrens = expectDiscrenMapper.selectList(queryWrapperSource);
        if (ObjectUtil.isEmpty(expectDiscrens)){
            return CommonResult.success("无相关数据");
        }
        for (ExpectDiscren expectDiscren : expectDiscrens) {
            Integer oldId = expectDiscren.getId();
            expectDiscren.setId(null);
            expectDiscren.setYear(targetYear);
            expectDiscren.setCreateBy(SecurityUtils.getUsername());
            expectDiscren.setCreateTime(LocalDateTime.now());
            expectDiscren.setUpdateBy(SecurityUtils.getUsername());
            expectDiscren.setUpdateTime(LocalDateTime.now());
            expectDiscren.setFictionTime(LocalDateTime.now());
            expectDiscrenMapper.insert(expectDiscren);
            List<ExpectContent> expectContents = expectContentMapper.selectByDiscrenId(oldId);
            if (ObjectUtil.isNotEmpty(expectContents)){
                for (ExpectContent expectContent : expectContents) {
                    List<ExpectContentMess> expectContentMesses = expectContentMapper.selectByContentId(expectContent.getId());
                    expectContent.setId(null);
                    expectContent.setExpectDiscrenId(expectDiscren.getId());
                    expectContentMapper.insert(expectContent);

                    if (ObjectUtil.isNotEmpty(expectContentMesses)){
                        for (ExpectContentMess expectContentMess : expectContentMesses) {
                            expectContentMess.setId(null);
                            expectContentMess.setExpectContentId(expectContent.getId());
                        }
                        expectContentMapper.insertContentMess(expectContentMesses);
                    }

                }
            }

            LambdaQueryWrapper<ExpectEvaluate> queryWrapper1 = new LambdaQueryWrapper<>();
            queryWrapper1.eq(ExpectEvaluate::getExpectDiscrenId, oldId).eq(ExpectEvaluate::getDelFlag, 1);
            List<ExpectEvaluate> expectEvaluates = expectEvaluateMapper.selectList(queryWrapper1);
            if (ObjectUtil.isNotEmpty(expectEvaluates)){
                for (ExpectEvaluate expectEvaluate : expectEvaluates) {
                    expectEvaluate.setId(null);
                    expectEvaluate.setExpectDiscrenId(expectDiscren.getId());
                    expectEvaluate.setCreateBy(SecurityUtils.getUsername());
                    expectEvaluate.setCreateTime(LocalDateTime.now());
                    expectEvaluate.setUpdateBy(SecurityUtils.getUsername());
                    expectEvaluate.setUpdateTime(LocalDateTime.now());
                    expectEvaluate.setEvaluateTime(LocalDateTime.now());
                    expectEvaluateMapper.insert(expectEvaluate);
                }
            }

        }
        return CommonResult.success();
    }
}