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

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.utils.SecurityUtils;
import com.gkhy.exam.system.domain.Catalogue;
import com.gkhy.exam.system.domain.CatalogueData;
import com.gkhy.exam.system.domain.CatalogueDataFile;
import com.gkhy.exam.system.domain.SysCompany;
import com.gkhy.exam.system.domain.req.CatalogueDataReq;
import com.gkhy.exam.system.domain.req.CatalogueReq;
import com.gkhy.exam.system.domain.vo.CatalogueDataVo;
import com.gkhy.exam.system.domain.vo.CatalogueVo;
import com.gkhy.exam.system.mapper.CatalogueMapper;
import com.gkhy.exam.system.mapper.SysCompanyMapper;
import com.gkhy.exam.system.service.CatalogueService;
import com.gkhy.exam.system.service.SysCompanyService;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.time.LocalDate;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

@Service
public class CatalogueServiceImpl extends ServiceImpl<CatalogueMapper, Catalogue> implements CatalogueService {

    @Autowired
    private CatalogueMapper catalogueMapper;
    @Autowired
    private SysCompanyMapper sysCompanyMapper;

    /**
     * 目录管理
     * @param catalogueReq
     * @return
     */
    @Override
    public CommonResult selectCatalogueList(CatalogueReq catalogueReq) {
        List<CatalogueVo> catalogueVos = catalogueMapper.selectCatalogueList(catalogueReq);
        List<CatalogueVo> collect = catalogueVos.stream().filter(catalogueVo -> catalogueVo.getParentId() == 0).collect(Collectors.toList());
        for (CatalogueVo catalogueVo : collect) {
            List<CatalogueVo> getchildren = getchildren(catalogueVo, catalogueVos);
            catalogueVo.setChildren(getchildren);
        }
        return CommonResult.success(collect);
    }

    private List<CatalogueVo> getchildren(CatalogueVo catalogueVo, List<CatalogueVo> catalogueVos) {
        List<CatalogueVo> catalogueCharlden = new ArrayList<>();
        for (CatalogueVo catalogue : catalogueVos) {
            if (catalogueVo.getId() == catalogue.getParentId()){
                catalogueCharlden.add(catalogue);
            }
        }
        for (CatalogueVo vo : catalogueCharlden) {
            List<CatalogueVo> getchildren = getchildren(vo, catalogueVos);
            vo.setChildren(getchildren);
        }
        return catalogueCharlden;
    }

    @Override
    public CommonResult insertCatalogue(Catalogue catalogue) {
        catalogue.setCreateBy(SecurityUtils.getUsername());
        catalogue.setCreateTime(LocalDate.now());
        int insert = catalogueMapper.insert(catalogue);
        if (insert>0){
            return CommonResult.success();
        }
        return CommonResult.failed();
    }

    @Override
    public CommonResult updateCatalogue(Catalogue catalogue) {
        catalogue.setUpdateBy(SecurityUtils.getUsername());
        catalogue.setUpdateTime(LocalDate.now());
        int i = catalogueMapper.updateById(catalogue);
        if (i>0){
            return CommonResult.success();
        }
        return CommonResult.failed();
    }

    @Override
    public CommonResult deletedCatalogue(Integer catalogueId) {

        CatalogueReq catalogueReq = new CatalogueReq();
        catalogueReq.setCatalogueId(catalogueId);
        List<CatalogueDataVo> catalogueDataVos = catalogueMapper.selectCatalogueDataList(catalogueReq);
        if (catalogueDataVos.size()>0){
            return CommonResult.failed("当前目录存在数据，请勿删除");
        }
        Catalogue catalogue = new Catalogue();
        catalogue.setId(catalogueId);
        catalogue.setDelFlag(2);
        catalogue.setUpdateTime(LocalDate.now());
        catalogue.setUpdateBy(SecurityUtils.getUsername());
        int i = catalogueMapper.updateById(catalogue);
        if (i>0){
            return CommonResult.success();
        }
        return CommonResult.failed();
    }


    /**
     * 目录数据管理
     * @param catalogueReq
     * @return
     */
    @Override
    public CommonResult selectCatalogueDataList(CatalogueReq catalogueReq) {
        List<CatalogueDataVo> catalogueData = catalogueMapper.selectCatalogueDataList(catalogueReq);
        for (CatalogueDataVo catalogueDatum : catalogueData) {
            List<CatalogueDataFile> catalogueDataFiles = catalogueMapper.selectCatalogueDataFile(catalogueDatum.getCompanyId(), catalogueDatum.getCatalogueId());
            catalogueDatum.setFiles(catalogueDataFiles);
        }
        return CommonResult.success(catalogueData);
    }

    @Override
    public CommonResult insertCatalogueData(CatalogueDataReq catalogue) {
        List<CatalogueData> catalogueData1 = catalogueMapper.selectByCompanyId(catalogue.getCompanyId());
        if (catalogueData1.size()>0){
            return CommonResult.failed("当前企业已有数据，请勿重复添加");
        }
        CatalogueData catalogueData = new CatalogueData();
        BeanUtils.copyProperties(catalogue,catalogueData);
        Integer i = catalogueMapper.insertCatalogueData(catalogueData);
//        List<CatalogueDataFile> files = catalogue.getFiles();
        if (i>0){
//            for (CatalogueDataFile file : files) {
//                file.setCatalogueDataId(catalogueData.getId());
//                file.setCreateBy(SecurityUtils.getUsername());
//                file.setCreateTime(LocalDate.now());
//                catalogueMapper.insertCatalogueDataFile(file);
//            }
            return CommonResult.success();
        }
        return CommonResult.failed();
    }

    @Override
    public CommonResult updateCatalogueData(CatalogueDataReq catalogue) {
        CatalogueData catalogueData = new CatalogueData();
        BeanUtils.copyProperties(catalogue,catalogueData);
        Integer i = catalogueMapper.updateCatalogueData(catalogueData);
//        List<CatalogueDataFile> files = catalogue.getFiles();
        if (i>0){
//            catalogueMapper.updateCatalogueDataFile(files);
            return CommonResult.success();
        }
        return CommonResult.failed();
    }

    @Override
    public CommonResult deletedCatalogueData(Integer catalogueDataId) {
        CatalogueData catalogueData = new CatalogueData();
        catalogueData.setId(catalogueDataId);
        catalogueData.setDelFlag(2);
        catalogueData.setUpdateBy(SecurityUtils.getUsername());
        catalogueData.setUpdateTime(LocalDate.now());
        Integer i = catalogueMapper.updateCatalogueData(catalogueData);
        if (i>9){
            return CommonResult.success();
        }
        return CommonResult.failed();
    }

    @Override
    public CommonResult insertCatalogueDataFile(CatalogueDataFile catalogueDataFile) {
        catalogueDataFile.setCreateTime(LocalDate.now());
        catalogueDataFile.setCreateBy(SecurityUtils.getUsername());
        catalogueMapper.insertCatalogueDataFile(catalogueDataFile);
        return CommonResult.success();
    }

    @Override
    public CommonResult updateCatalogueDataFile(CatalogueDataFile catalogueDataFile) {
        catalogueDataFile.setUpdateBy(SecurityUtils.getUsername());
        catalogueDataFile.setUpdateTime(LocalDate.now());
        catalogueMapper.updateCatalogueDataFile(catalogueDataFile);
        return CommonResult.success();
    }

    @Override
    public CommonResult deletedCatalogueDataFile(Integer dataFileId) {
        CatalogueDataFile catalogueDataFile = new CatalogueDataFile();
        catalogueDataFile.setId(dataFileId);
        catalogueDataFile.setDelFlag(2);
        catalogueDataFile.setUpdateTime(LocalDate.now());
        catalogueDataFile.setUpdateBy(SecurityUtils.getUsername());
        catalogueMapper.updateCatalogueDataFile(catalogueDataFile);
        return CommonResult.success();
    }
}