package cn.palmte.work.service;

import cn.palmte.work.bean.ApproveStatusEnum;
import cn.palmte.work.bean.EstimateBean;
import cn.palmte.work.bean.StatusEnum;
import cn.palmte.work.bean.TypeEnum;
import cn.palmte.work.model.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import top.jfunc.common.db.QueryHelper;
import top.jfunc.common.db.bean.Page;
import top.jfunc.common.db.utils.Pagination;
import top.jfunc.common.utils.CollectionUtil;
import top.jfunc.common.utils.StrUtil;

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

/**
 * @author xiongshiyan at 2021/10/29 , contact me with email yanshixiong@126.com or phone 15208384257
 */
@Service
public class ProjectService {
    @Autowired
    private Pagination pagination;
    @Autowired
    private ProjectRepository projectRepository;
    @Autowired
    private ProjectEstimateIncomeRepository projectEstimateIncomeRepository;
    @Autowired
    private ProjectEstimateCostRepository projectEstimateCostRepository;
    @Autowired
    private ProjectEstimateCostManageRepository projectEstimateCostManageRepository;


    private QueryHelper getQueryHelper(Map<String, String> searchInfo, int pageNumber, int pageSize) {
        /*"CASE p.type WHEN 1 THEN '工程集成类' WHEN 2 THEN '设备集成类' WHEN 3 THEN '战略合作类' ELSE '未知' AS typeDesc," +
                "CASE p.status WHEN 0 THEN '草稿' WHEN 1 THEN '项目创建' WHEN 5 THEN '概算完成' WHEN 10 THEN '预算完成' WHEN 15 THEN '结算中' WHEN 20 THEN '决算完成' ELSE '未知' AS statusDesc," +
                "CASE p.approve_status WHEN 0 THEN '待审核' WHEN 1 THEN '审核通过' WHEN 2 THEN '审核不通过' ELSE '未知' AS approveStatusDesc," +
                */
        QueryHelper queryHelper = new QueryHelper("SELECT p.*","project","p");
        if(StrUtil.isNotEmpty(searchInfo.get("status")) && !"-1".equals(searchInfo.get("status"))){
            queryHelper.addCondition("p.status=?", Integer.parseInt(searchInfo.get("status")));
        }
        if(StrUtil.isNotEmpty(searchInfo.get("approveStatus")) && !"-1".equals(searchInfo.get("approveStatus"))){
            queryHelper.addCondition("p.approve_status=?", Integer.parseInt(searchInfo.get("approveStatus")));
        }
        if(StrUtil.isNotEmpty(searchInfo.get("deptId")) && !"-1".equals(searchInfo.get("deptId"))){
            queryHelper.addCondition("p.dept_id=?", Integer.parseInt(searchInfo.get("deptId")));
        }
        if(StrUtil.isNotEmpty(searchInfo.get("type")) && !"-1".equals(searchInfo.get("type"))){
            queryHelper.addCondition("p.type=?", Integer.parseInt(searchInfo.get("type")));
        }
        queryHelper.addCondition(StrUtil.isNotEmpty(searchInfo.get("name")),"p.name LIKE ?", "%"+searchInfo.get("name")+"%");
        queryHelper.addCondition(StrUtil.isNotEmpty(searchInfo.get("creatorName")),"p.creator_name LIKE ?", "%"+searchInfo.get("creatorName")+"%");

        /**
         * 只选择了一个时间的情况，就项目时间包括这个时间的
         */
        if(StrUtil.isNotEmpty(searchInfo.get("startDate")) && StrUtil.isEmpty(searchInfo.get("endDate"))){
            String time = searchInfo.get("startDate") + " 00:00:00";
            queryHelper.addCondition("p.start_date<=? AND p.end_date>=?", time, time);
        }
        if(StrUtil.isNotEmpty(searchInfo.get("endDate")) && StrUtil.isEmpty(searchInfo.get("startDate"))){
            String time = searchInfo.get("endDate") + " 00:00:00";
            queryHelper.addCondition("p.start_date<=? AND p.end_date>=?", time, time);
        }
        /**
         * 两个时间都选了，则包含项目时间
         */
        if(StrUtil.isNotEmpty(searchInfo.get("startDate")) && StrUtil.isNotEmpty(searchInfo.get("endDate"))){
            String startTime = searchInfo.get("startDate") + " 00:00:00";
            String endTime = searchInfo.get("endDate") + " 23:59:59";
            queryHelper.addCondition("p.start_date>=? AND p.end_date<=?", startTime, endTime);
        }

        return queryHelper;
    }

    public Page<Project> list(Map<String, String> searchInfo, int pageNumber, int pageSize){
        QueryHelper queryHelper = getQueryHelper(searchInfo, pageNumber, pageSize);
        return pagination.paginate(queryHelper.getSql(), Project.class,pageNumber,pageSize);
    }

    /**
     * 新增概算保存项目
     */
    @Transactional(rollbackFor = RuntimeException.class)
    public Project estimateAddSave(Project project, EstimateBean estimateBean, Admin admin) {
        project.setTypeDesc(TypeEnum.parseType(project.getType()).getTypeDesc());
        project.setStatusDesc(StatusEnum.parseStatus(project.getStatus()).getStatusDesc());
        project.setApproveStatus(ApproveStatusEnum.APPROVAL_PENDING.getApproveStatus());
        project.setApproveStatusDesc(ApproveStatusEnum.APPROVAL_PENDING.getApproveStatusDesc());
        project.setCreatorId(admin.getId());
        project.setCreatorName(admin.getUserName());

        //TODO 审核人通过计算得到
        project.setApproveId(0);
        project.setApproveName("");

        //TODO 获取登录人的部门信息
        project.setDeptId(admin.getId());
        project.setDeptName("");

        project.setCreateTime(new Date());

        project = projectRepository.saveAndFlush(project);


        //收入记录
        income(project, estimateBean);
        //成本记录
        cost(project, estimateBean);
        //管理记录
        costManage(project, estimateBean);
        return project;
    }

    private void clearEstimate(Project project){
        List<ProjectEstimateIncome> incomes = projectEstimateIncomeRepository.findAllByProjectIdEquals(project.getId());
        if(CollectionUtil.isNotEmpty(incomes)){
            projectEstimateIncomeRepository.deleteInBatch(incomes);
        }

        List<ProjectEstimateCost> costs = projectEstimateCostRepository.findAllByProjectIdEquals(project.getId());
        if(CollectionUtil.isNotEmpty(costs)){
            projectEstimateCostRepository.deleteInBatch(costs);
        }

        List<ProjectEstimateCostManage> costManages = projectEstimateCostManageRepository.findAllByProjectIdEquals(project.getId());
        if(CollectionUtil.isNotEmpty(costManages)){
            projectEstimateCostManageRepository.deleteInBatch(costManages);
        }

    }
    /**
     * 编辑概算保存项目
     */
    @Transactional(rollbackFor = RuntimeException.class)
    public Project estimateEditSave(Project project, EstimateBean estimateBean, Admin admin) {
        //删除原来的
        projectRepository.delete(project.getId());
        //清空概算信息
        clearEstimate(project);

        return estimateAddSave(project, estimateBean, admin);
    }

    private void cost(Project project, EstimateBean estimateBean) {
        ProjectEstimateCost projectEstimateCostDevice = new ProjectEstimateCost();
        projectEstimateCostDevice.setProjectId(project.getId());
        projectEstimateCostDevice.setFee(1);
        projectEstimateCostDevice.setType(1);
        projectEstimateCostDevice.setCostTaxInclude(estimateBean.getCostPurchaseDeviceTaxInclude());
        projectEstimateCostDevice.setCostTaxExclude(estimateBean.getCostPurchaseDeviceTaxExclude());
        projectEstimateCostRepository.saveAndFlush(projectEstimateCostDevice);


        ProjectEstimateCost projectEstimateCostBuild = new ProjectEstimateCost();
        projectEstimateCostBuild.setProjectId(project.getId());
        projectEstimateCostBuild.setFee(1);
        projectEstimateCostBuild.setType(2);
        projectEstimateCostBuild.setCostTaxInclude(estimateBean.getCostPurchaseBuildTaxInclude());
        projectEstimateCostBuild.setCostTaxExclude(estimateBean.getCostPurchaseBuildTaxExclude());
        projectEstimateCostRepository.saveAndFlush(projectEstimateCostBuild);

        ProjectEstimateCost projectEstimateCostService = new ProjectEstimateCost();
        projectEstimateCostService.setProjectId(project.getId());
        projectEstimateCostService.setFee(1);
        projectEstimateCostService.setType(3);
        projectEstimateCostService.setCostTaxInclude(estimateBean.getCostPurchaseServiceTaxInclude());
        projectEstimateCostService.setCostTaxExclude(estimateBean.getCostPurchaseServiceTaxExclude());
        projectEstimateCostRepository.saveAndFlush(projectEstimateCostService);

        ProjectEstimateCost projectEstimateCostOther = new ProjectEstimateCost();
        projectEstimateCostOther.setProjectId(project.getId());
        projectEstimateCostOther.setFee(1);
        projectEstimateCostOther.setType(4);
        projectEstimateCostOther.setCostTaxInclude(estimateBean.getCostPurchaseOtherTaxInclude());
        projectEstimateCostOther.setCostTaxExclude(estimateBean.getCostPurchaseOtherTaxExclude());
        projectEstimateCostRepository.saveAndFlush(projectEstimateCostOther);

        ProjectEstimateCost projectEstimateCostProject = new ProjectEstimateCost();
        projectEstimateCostProject.setProjectId(project.getId());
        projectEstimateCostProject.setFee(2);
        projectEstimateCostProject.setType(5);
        projectEstimateCostProject.setCostTaxInclude(estimateBean.getCostProjectManageTaxInclude());
        projectEstimateCostProject.setCostTaxExclude(estimateBean.getCostProjectManageTaxExclude());
        projectEstimateCostRepository.saveAndFlush(projectEstimateCostProject);

        ProjectEstimateCost projectEstimateCostOtherOther = new ProjectEstimateCost();
        projectEstimateCostOtherOther.setProjectId(project.getId());
        projectEstimateCostOtherOther.setFee(3);
        projectEstimateCostOtherOther.setType(6);
        projectEstimateCostOtherOther.setCostTaxInclude(estimateBean.getCostOtherOtherTaxInclude());
        projectEstimateCostOtherOther.setCostTaxExclude(estimateBean.getCostOtherOtherTaxExclude());
        projectEstimateCostRepository.saveAndFlush(projectEstimateCostOtherOther);

    }
    private void costManage(Project project, EstimateBean estimateBean) {
        ProjectEstimateCostManage projectEstimateCostZijin = new ProjectEstimateCostManage();
        projectEstimateCostZijin.setProjectId(project.getId());
        projectEstimateCostZijin.setType(1);
        projectEstimateCostZijin.setCostTaxExclude(estimateBean.getCostExpropriationTaxExclude());
        projectEstimateCostManageRepository.saveAndFlush(projectEstimateCostZijin);

        ProjectEstimateCostManage projectEstimateCostManage = new ProjectEstimateCostManage();
        projectEstimateCostManage.setProjectId(project.getId());
        projectEstimateCostManage.setType(2);
        projectEstimateCostManage.setCostTaxExclude(estimateBean.getCostCompanyManageTaxExclude());
        projectEstimateCostManageRepository.saveAndFlush(projectEstimateCostManage);
    }
    private void income(Project project, EstimateBean estimateBean) {
        ProjectEstimateIncome projectEstimateIncomeDevice = new ProjectEstimateIncome();
        projectEstimateIncomeDevice.setProjectId(project.getId());
        projectEstimateIncomeDevice.setType(1);
        projectEstimateIncomeDevice.setIncomeTaxInclude(estimateBean.getIncomeDeviceTaxInclude());
        projectEstimateIncomeDevice.setIncomeTaxExclude(estimateBean.getIncomeDeviceTaxExclude());
        projectEstimateIncomeRepository.saveAndFlush(projectEstimateIncomeDevice);

        ProjectEstimateIncome projectEstimateIncomeEngineer = new ProjectEstimateIncome();
        projectEstimateIncomeEngineer.setProjectId(project.getId());
        projectEstimateIncomeEngineer.setType(2);
        projectEstimateIncomeEngineer.setIncomeTaxInclude(estimateBean.getIncomeEngineerTaxInclude());
        projectEstimateIncomeEngineer.setIncomeTaxExclude(estimateBean.getIncomeEngineerTaxExclude());
        projectEstimateIncomeRepository.saveAndFlush(projectEstimateIncomeEngineer);

        ProjectEstimateIncome projectEstimateIncomeService = new ProjectEstimateIncome();
        projectEstimateIncomeService.setProjectId(project.getId());
        projectEstimateIncomeService.setType(3);
        projectEstimateIncomeService.setIncomeTaxInclude(estimateBean.getIncomeServiceTaxInclude());
        projectEstimateIncomeService.setIncomeTaxExclude(estimateBean.getIncomeServiceTaxExclude());
        projectEstimateIncomeRepository.saveAndFlush(projectEstimateIncomeService);
    }

    public Project getProject(int id) {
        return projectRepository.findOne(id);
    }

    public EstimateBean estimate(Project project) {
        EstimateBean estimateBean = new EstimateBean();
        List<ProjectEstimateIncome> incomes = projectEstimateIncomeRepository.findAllByProjectIdEquals(project.getId());

        ProjectEstimateIncome projectEstimateIncomeDevice = incomes.stream().filter(d -> d.getType() == 1).collect(Collectors.toList()).get(0);
        estimateBean.setIncomeDeviceTaxInclude(projectEstimateIncomeDevice.getIncomeTaxInclude());
        estimateBean.setIncomeDeviceTaxExclude(projectEstimateIncomeDevice.getIncomeTaxExclude());

        ProjectEstimateIncome projectEstimateIncomeEngineer = incomes.stream().filter(d -> d.getType() == 2).collect(Collectors.toList()).get(0);
        estimateBean.setIncomeEngineerTaxInclude(projectEstimateIncomeEngineer.getIncomeTaxInclude());
        estimateBean.setIncomeEngineerTaxExclude(projectEstimateIncomeEngineer.getIncomeTaxExclude());

        ProjectEstimateIncome projectEstimateIncomeService = incomes.stream().filter(d -> d.getType() == 3).collect(Collectors.toList()).get(0);
        estimateBean.setIncomeServiceTaxInclude(projectEstimateIncomeService.getIncomeTaxInclude());
        estimateBean.setIncomeServiceTaxExclude(projectEstimateIncomeService.getIncomeTaxExclude());

        List<ProjectEstimateCost> costs = projectEstimateCostRepository.findAllByProjectIdEquals(project.getId());

        ProjectEstimateCost projectEstimateCostDevice = costs.stream().filter(d -> d.getType() == 1).collect(Collectors.toList()).get(0);
        estimateBean.setCostPurchaseDeviceTaxInclude(projectEstimateCostDevice.getCostTaxInclude());
        estimateBean.setCostPurchaseDeviceTaxExclude(projectEstimateCostDevice.getCostTaxExclude());

        ProjectEstimateCost projectEstimateCostBuild = costs.stream().filter(d -> d.getType() == 2).collect(Collectors.toList()).get(0);
        estimateBean.setCostPurchaseBuildTaxInclude(projectEstimateCostBuild.getCostTaxInclude());
        estimateBean.setCostPurchaseBuildTaxExclude(projectEstimateCostBuild.getCostTaxExclude());

        ProjectEstimateCost projectEstimateCostService = costs.stream().filter(d -> d.getType() == 3).collect(Collectors.toList()).get(0);
        estimateBean.setCostPurchaseServiceTaxInclude(projectEstimateCostService.getCostTaxInclude());
        estimateBean.setCostPurchaseServiceTaxExclude(projectEstimateCostService.getCostTaxExclude());

        ProjectEstimateCost projectEstimateCostOther = costs.stream().filter(d -> d.getType() == 4).collect(Collectors.toList()).get(0);
        estimateBean.setCostPurchaseOtherTaxInclude(projectEstimateCostOther.getCostTaxInclude());
        estimateBean.setCostPurchaseOtherTaxExclude(projectEstimateCostOther.getCostTaxExclude());

        ProjectEstimateCost projectEstimateCostProjectManage = costs.stream().filter(d -> d.getType() == 5).collect(Collectors.toList()).get(0);
        estimateBean.setCostProjectManageTaxInclude(projectEstimateCostProjectManage.getCostTaxInclude());
        estimateBean.setCostProjectManageTaxExclude(projectEstimateCostProjectManage.getCostTaxExclude());

        ProjectEstimateCost projectEstimateCostOtherOther = costs.stream().filter(d -> d.getType() == 6).collect(Collectors.toList()).get(0);
        estimateBean.setCostOtherOtherTaxInclude(projectEstimateCostOtherOther.getCostTaxInclude());
        estimateBean.setCostOtherOtherTaxExclude(projectEstimateCostOtherOther.getCostTaxExclude());

        List<ProjectEstimateCostManage> manages = projectEstimateCostManageRepository.findAllByProjectIdEquals(project.getId());
        ProjectEstimateCostManage costManageExpropriation = manages.stream().filter(d -> d.getType() == 1).collect(Collectors.toList()).get(0);
        estimateBean.setCostExpropriationTaxExclude(costManageExpropriation.getCostTaxExclude());
        ProjectEstimateCostManage costManageCompany = manages.stream().filter(d -> d.getType() == 2).collect(Collectors.toList()).get(0);
        estimateBean.setCostCompanyManageTaxExclude(costManageCompany.getCostTaxExclude());

        return estimateBean;
    }
}