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

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.gkhy.exam.common.exception.ApiException;
import com.gkhy.exam.system.domain.*;
import com.gkhy.exam.system.domain.req.EmployeeRecordReq;
import com.gkhy.exam.system.domain.vo.EmployeeRecordVO;
import com.gkhy.exam.system.domain.vo.statistic.CompanyStatisticsVo;
import com.gkhy.exam.system.mapper.*;
import com.gkhy.exam.system.service.StatisticsService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;
import java.util.stream.Collectors;

@Service
public class StatisticsServiceImpl implements StatisticsService {

    @Autowired
    private CompanySummaryMapper companySummaryMapper;
    @Autowired
    private EmployeeRecordMapper employeeRecordMapper;

    @Autowired
    private StandingBookMapper standingBookMapper;

    @Autowired
    private AnnualVerificationPlanMapper annualVerificationPlanMapper;

    @Autowired
    private AnnualVerificationDeviceMapper annualVerificationDeviceMapper;
    @Autowired
    private CompanyQualityPolicyMapper companyQualityPolicyMapper;

    @Autowired
    private QualityMapper qualityMapper;
    @Autowired
    private QualityTargetMapper qualityTargetMapper;

    @Autowired
    private ContractLedgerMapper contractLedgerMapper;

    @Autowired
    private AnnualReportMapper annualReportMapper;

    @Autowired
    private InternalKnowledgeMapper internalKnowledgeMapper;

    @Autowired
    private TrainPlanMapper trainPlanMapper;

    @Autowired
    private InternalAuditCheckMapper internalAuditCheckMapper;

    @Autowired
    private ContinuousImproveMapper continuousImproveMapper;

    @Autowired
    private OutsourcedProductMapper outsourcedProductMapper;

    @Override
    public CompanyStatisticsVo getCompanyStatistics(Integer companyId, String year) {

        String yearBegin = year + "-01-01 00:00:00";
        String yearEnd = year + "-12-31 23:59:59";

        CompanyStatisticsVo companyStatisticsVo = companySummaryMapper.selectCompanyStatistics(companyId);
        if (companyStatisticsVo == null) {
            return companyStatisticsVo;
        }
        companyStatisticsVo.setYear(year);
        EmployeeRecordReq req = new EmployeeRecordReq();
        req.setCompanyId(companyId.longValue());
        List<EmployeeRecordVO> sysUsers = employeeRecordMapper.selectEmployeeRecordList(req);
        int totalUser = sysUsers.size();
        long countJS = sysUsers.stream()
                .filter(user -> user.getPersonType() != null)
                .filter(user -> user.getPersonType() == 1)  // 技术类
                .count();
        companyStatisticsVo.setTotalEmployee(totalUser);
        companyStatisticsVo.setProfessionalEmployee(
                countJS > 0 ? (int) countJS : 0
        );

        //企业资源和能力情况

        LambdaQueryWrapper<StandingBook> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(StandingBook::getCompanyId, companyId);
        queryWrapper.eq(StandingBook::getDelFlag, 0);
        List<StandingBook> standingBooks = standingBookMapper.selectList(queryWrapper);
        //计算计算机总数
        long computerTotal = standingBooks.stream()
                .filter(st -> st.getDeviceType() != null)
                .filter(st -> st.getDeviceType() == 1)
                .count();
        //生成设备
        long productionEquipment = standingBooks.stream()
                .filter(st -> st.getDeviceType() != null)
                .filter(st -> st.getDeviceType() == 5)
                .count();
        companyStatisticsVo.setComputerTotal(computerTotal > 0 ? (int) computerTotal : 0);
        companyStatisticsVo.setProductionEquipment(productionEquipment > 0 ? (int) productionEquipment : 0);
        companyStatisticsVo.setOtherOfficeEquipment(standingBooks.size() - (int) computerTotal - (int) productionEquipment);

        LambdaQueryWrapper<AnnualVerificationPlan> queryWrapper1 = new LambdaQueryWrapper<>();
        queryWrapper1.eq(AnnualVerificationPlan::getCompanyId, companyId).eq(AnnualVerificationPlan::getDelFlag, 0).eq(AnnualVerificationPlan::getYear, year);
        List<AnnualVerificationPlan> annualVerificationPlans = annualVerificationPlanMapper.selectList(queryWrapper1);
        if (!annualVerificationPlans.isEmpty()) {
            AnnualVerificationPlan annualVerificationPlan = annualVerificationPlans.get(0);
            LambdaQueryWrapper<AnnualVerificationDevice> queryWrapper2 = new LambdaQueryWrapper<>();
            queryWrapper2.eq(AnnualVerificationDevice::getAnnualVerificationId, annualVerificationPlan.getId()).eq(AnnualVerificationDevice::getDelFlag, 0).eq(AnnualVerificationDevice::getPlanType, 2);
            List<AnnualVerificationDevice> annualVerificationDevices = annualVerificationDeviceMapper.selectList(queryWrapper2);
            companyStatisticsVo.setDetectionEquipment(annualVerificationDevices.size());
            queryWrapper2.between(AnnualVerificationDevice::getCreateTime, yearBegin, yearEnd);
            List<AnnualVerificationDevice> annualVerificationDevices1 = annualVerificationDeviceMapper.selectList(queryWrapper2);
            companyStatisticsVo.setDetectionEquipmentAdd(annualVerificationDevices1.size());
        } else {
            companyStatisticsVo.setDetectionEquipment(0);
        }

        LambdaQueryWrapper<CompanyQualityPolicy> queryWrapper3 = new LambdaQueryWrapper<>();
        queryWrapper3.eq(CompanyQualityPolicy::getCompanyId, companyId).eq(CompanyQualityPolicy::getDelFlag, 1);
        List<CompanyQualityPolicy> qualities = companyQualityPolicyMapper.selectList(queryWrapper3);
        if (!qualities.isEmpty()) {
            companyStatisticsVo.setCompanyQualityPolicy(qualities.get(0).getPolicy());
        }


        LambdaQueryWrapper<Quality> queryWrapper4 = new LambdaQueryWrapper<>();
        queryWrapper4.eq(Quality::getCompanyId, companyId).eq(Quality::getDelFlag, 1).eq(Quality::getYear, year);
        List<Quality> qualities1 = qualityMapper.selectList(queryWrapper4);
        if (!qualities1.isEmpty()) {
            LambdaQueryWrapper<QualityTarget> queryWrapper5 = new LambdaQueryWrapper<>();
            queryWrapper5.eq(QualityTarget::getQualityId, qualities1.get(0).getId()).eq(QualityTarget::getDelFlag, 1).orderByDesc(QualityTarget::getCreateTime);
            List<QualityTarget> qualityTargets = qualityTargetMapper.selectList(queryWrapper5);
            if (!qualityTargets.isEmpty()) {
                List<String> collect = qualityTargets.stream().map(QualityTarget::getMessage).collect(Collectors.toList());
                companyStatisticsVo.setCompanyQualityTarget(collect);
            }
        }
        LambdaQueryWrapper<ContractLedger> queryWrapper6 = new LambdaQueryWrapper<>();
        queryWrapper6.eq(ContractLedger::getCompanyId, companyId).eq(ContractLedger::getDelFlag, 1).between(ContractLedger::getSignDate, yearBegin, yearEnd);

        List<ContractLedger> contractLedgers = contractLedgerMapper.selectList(queryWrapper6);
        companyStatisticsVo.setContractLedger(contractLedgers.size());
        if (!contractLedgers.isEmpty()) {
            Long count = contractLedgers.stream().filter(contractLedger -> contractLedger.getDeliver() == 1).count();
            companyStatisticsVo.setDeliveredContract(count.intValue());
        } else {
            companyStatisticsVo.setDeliveredContract(0);
        }
        //满意度
        LambdaQueryWrapper<AnnualReport> queryWrapper7 = new LambdaQueryWrapper<>();
        queryWrapper7.eq(AnnualReport::getCompanyId, companyId).eq(AnnualReport::getDelFlag, 1).eq(AnnualReport::getYear, year);
        AnnualReport annualReport = annualReportMapper.selectOne(queryWrapper7);
        if (annualReport != null) {
            companyStatisticsVo.setSumSatisficing(annualReport.getSumSatisficing());
        } else {
            companyStatisticsVo.setSumSatisficing("0");
        }
        //只是产权数量
        LambdaQueryWrapper<InternalKnowledge> queryWrapper8 = new LambdaQueryWrapper<>();
        queryWrapper8.eq(InternalKnowledge::getCompanyId, companyId).eq(InternalKnowledge::getDelFlag, 0)
                .between(InternalKnowledge::getCreateTime, yearBegin, yearEnd);
        Long l = internalKnowledgeMapper.selectCount(queryWrapper8);
        companyStatisticsVo.setPatent(l.intValue());
        //培训计划名称
        LambdaQueryWrapper<TrainPlan> queryWrapper9 = new LambdaQueryWrapper<>();
        queryWrapper9.eq(TrainPlan::getCompanyId, companyId).eq(TrainPlan::getDelFlag, 1).between(TrainPlan::getTrainTime, yearBegin, yearEnd);
        List<TrainPlan> trainPlans = trainPlanMapper.selectList(queryWrapper9);
        if (!trainPlans.isEmpty()) {
            String courseNames = trainPlans.stream()
                    .map(TrainPlan::getTrainName)
                    .collect(Collectors.joining(","));
            companyStatisticsVo.setTrainPlanName(courseNames);
        }
        //内审检查不符合
        int statisticData = internalAuditCheckMapper.getStatisticData(companyId, yearBegin, yearEnd);
        companyStatisticsVo.setInternalAuditCheckResult(statisticData);
        //改进项
        int conStatistic = continuousImproveMapper.getConStatistic(companyId, year);
        companyStatisticsVo.setConStatisticNum(conStatistic);
        LambdaQueryWrapper<OutsourcedProduct> queryWrapper10 = new LambdaQueryWrapper<>();
        queryWrapper10.eq(OutsourcedProduct::getCompanyId, companyId).eq(OutsourcedProduct::getDelFlag, 0)
                .between(OutsourcedProduct::getCreateTime, yearBegin, yearEnd);
        List<OutsourcedProduct> outsourcedProducts = outsourcedProductMapper.selectList(queryWrapper10);
        if (!outsourcedProducts.isEmpty()){
            String ps = outsourcedProducts.stream()
                    .map(OutsourcedProduct::getProductName)
                    .collect(Collectors.joining(","));
            companyStatisticsVo.setOutsourcedProduct(ps);
        }

        req.setCompanyId(companyId.longValue());
        req.setStartTime(yearBegin);
        req.setEndTime(yearEnd);
        List<EmployeeRecordVO> sysUsersAdd = employeeRecordMapper.selectEmployeeRecordList(req);
        int totalUserAdd = sysUsersAdd.size();
        long countJSAdd = sysUsersAdd.stream()
                .filter(user -> user.getPersonType() != null)
                .filter(user -> user.getPersonType() == 1)  // 技术类
                .count();
        companyStatisticsVo.setTotalEmployeeAdd(totalUserAdd);
        companyStatisticsVo.setProfessionalEmployeeAdd(
                countJSAdd > 0 ? (int) countJSAdd : 0
        );

        queryWrapper9.eq(TrainPlan::getStatus, 0);
        Long l1 = trainPlanMapper.selectCount(queryWrapper9);
        companyStatisticsVo.setTrainPlanCompleted(l1.intValue());

        return companyStatisticsVo;
    }

}