package org.jeecg.modules.base.controller;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
import com.baomidou.mybatisplus.core.toolkit.ObjectUtils;
import com.baomidou.mybatisplus.core.toolkit.StringUtils;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.jeecg.common.api.vo.Result;
import org.jeecg.common.aspect.annotation.AutoLog;
import org.jeecg.common.constant.CommonConstant;
import org.jeecg.common.system.base.controller.JeecgController;
import org.jeecg.common.system.vo.SelectTreeModel;
import org.jeecg.modules.base.entity.MaterialCategory;
import org.jeecg.modules.base.service.IMaterialCategoryService;
import org.jeecg.modules.quartz.entity.QuartzJob;
import org.jeecg.modules.quartz.service.IQuartzJobService;
import org.jeecg.common.system.base.entity.DataVersion;
import org.jeecg.modules.system.service.IDataVersionService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.*;

import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.*;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.stream.Collectors;

/**
 * @Description: 物料分类
 * @Author: jeecg-boot
 * @Date: 2023-04-20
 * @Version: V1.0
 */
@Api(tags = "物料分类")
@RestController
@RequestMapping("/base/materialCategory")
@Slf4j
public class MaterialCategoryController extends JeecgController<MaterialCategory, IMaterialCategoryService> {

    @Autowired
    private IMaterialCategoryService materialCategoryService;
    @Autowired
    private IDataVersionService dataVersionService;
    @Autowired
    private IQuartzJobService quartzJobService;

    /**
     * 获取物料分类架构树
     */
    @GetMapping("/enterpriseTree")
    @ApiOperation(value = "获取物料分类架构树", notes = "获取物料分类架构树")
    public Result<?> getEnterpriseTree(@RequestParam(value = "version", required = false) Integer version) {
        SelectTreeModel selectTreeModel = new SelectTreeModel();
        selectTreeModel.setKey("0");
        selectTreeModel.setTitle("物料分类");
        List<SelectTreeModel> finallyList = new ArrayList<>();
        selectTreeModel.setChildren(materialCategoryService.getMaterialCategoryVersionTree("0", version));
        finallyList.add(selectTreeModel);
        return Result.OK(finallyList);
    }

    /**
     * 分页列表查询
     *
     * @param map
     * @param pageNo
     * @param pageSize
     * @param parentId
     * @return
     */
    @ApiOperation(value = "物料分类-分页列表查询", notes = "物料分类-分页列表查询")
    @GetMapping(value = "/list")
    public Result<IPage<Map<String, Object>>> queryPageList(Map map,
                                                            @RequestParam(name = "pageNo", defaultValue = "1") Integer pageNo,
                                                            @RequestParam(name = "pageSize", defaultValue = "10") Integer pageSize,
                                                            @RequestParam(name = "parentId", required = false) String parentId,
                                                            @RequestParam(name = "version", required = false) Integer version) {
        Page<Map<String, Object>> page = new Page(pageNo, pageSize);
        IPage<Map<String, Object>> pageList = materialCategoryService.getMaterialCategoryListByPid(page, version, parentId);
        return Result.OK(pageList);
    }

    /**
     * 获取初始版本号
     */
    @GetMapping("/getInitVersion")
    public Result<?> getUsableVersion() {
        return Result.OK(materialCategoryService.getInitVersion());
    }

    /**
     * 获取所有版本号
     */
    @GetMapping("/getVersionList")
    @ApiOperation(value = "获取所有版本号", notes = "获取所有版本号")
    public Result<?> getAllVersion() {
        return Result.OK(materialCategoryService.getAllVersion());
    }

    /**
     * 添加需要一次性完成
     *
     * @param materialCategory
     * @return
     */
    @AutoLog(value = "物料分类-添加")
    @ApiOperation(value = "物料分类-添加", notes = "物料分类-添加")
    @PostMapping(value = "/add")
    @Transactional
    public Result<String> add(@RequestBody MaterialCategory materialCategory) {
        materialCategoryService.save(materialCategory);
        LambdaQueryWrapper<MaterialCategory> queryWrapper = new LambdaQueryWrapper<MaterialCategory>()
                .eq(MaterialCategory::getCode, materialCategory.getCode())
                .eq(MaterialCategory::getVersion, materialCategory.getVersion())
                .eq(MaterialCategory::getDelFlag, CommonConstant.DEL_FLAG_0);
        MaterialCategory selectMaterialCategory = materialCategoryService.getOne(queryWrapper, true);
        DataVersion dataVersion = new DataVersion();
        dataVersion.setBusinessId(selectMaterialCategory.getId())
                .setBusinessType("物料分类")
                .setVersion(selectMaterialCategory.getVersion())
                .setVersionStatus(materialCategory.getVersionStatus())
                .setDelFlag(CommonConstant.DEL_FLAG_0)
                .setEffectiveType("0")
                .setIsLastUsable("0");
        dataVersionService.save(dataVersion);
        LambdaQueryWrapper<DataVersion> queryWrapper1 = new LambdaQueryWrapper<DataVersion>()
                .eq(DataVersion::getBusinessId, selectMaterialCategory.getId())
                .eq(DataVersion::getDelFlag, CommonConstant.DEL_FLAG_0);

        DataVersion selectDataVersion = dataVersionService.getOne(queryWrapper1, true);
        selectMaterialCategory.setDataVersionId(selectDataVersion.getId());
        materialCategoryService.saveOrUpdate(selectMaterialCategory);
        return Result.OK("添加成功！");
    }

    /**
     * 升版
     * 需要一次完成
     *
     * @param map
     * @param
     * @return
     */
    @ApiOperation(value = "物料分类-版本升级", notes = "物料分类-版本升级")
    @PostMapping("/updateVersion")
    @Transactional
    public Result<?> updateVersion(@RequestBody Map<String, Integer> map) {
        Integer version = map.get("version");
        Set<Integer> allVersion = materialCategoryService.getAllVersion();
        int newVersion = 1;
        if (CollectionUtils.isNotEmpty(allVersion)) {
            newVersion = allVersion.stream().findFirst().get() + 1;
        }
        recurrenceUpdata("0", "0", version, newVersion);
        return Result.OK("升版成功", newVersion);
    }

    /**
     * 递归升版多个节点
     *
     * @param parentId
     * @param newParentId
     * @param version
     * @param newVersion
     * @return
     */
    public void recurrenceUpdata(String parentId, String newParentId, Integer version, Integer newVersion) {
        CopyOnWriteArrayList<MaterialCategory> childList = new CopyOnWriteArrayList<>(materialCategoryService.list(new QueryWrapper<MaterialCategory>()
                .eq("parent_id", parentId)
                .eq("version", version)
                .eq("del_flag", 0)));
        if (CollectionUtils.isNotEmpty(childList)) {
            childList.forEach(childEnterprise -> {
                //把child的Id存下来,因为在流里边操作对象容易扯着蛋
                String childNewId = childEnterprise.getId();
                //将数据存入数据库
                String childNewParentId = updataOneNode(childEnterprise, newParentId, newVersion);
                //递归
                recurrenceUpdata(childNewId, childNewParentId, version, newVersion);
            });
        }
    }

    /**
     * 立即生效
     * 需要一次完成
     *
     * @param map
     * @param
     * @return
     */
    @PostMapping("/updateVersionStatusToUsable")
    @Transactional
    public Result<?> updateVersionStatusToUsable(@RequestBody Map<String, Object> map) {
        //如果有定时生生效,则将定时生效任务关闭
        QuartzJob quartzJob = quartzJobService.getOne(new QueryWrapper<QuartzJob>()
                .eq("job_class_name", "org.jeecg.modules.quartz.job.EnterpriseSetUsableJob"), true);
        if (ObjectUtils.isNotNull(quartzJob)) {
            quartzJobService.deleteAndStopJob(quartzJob);
        }
        //获取版本号
        Integer version = Integer.parseInt((String) map.get("version"));
        //获取上次生效版本并将其是否上次生效位置置为否
        List<MaterialCategory> lastUsableList = materialCategoryService.getLastUsableList();
        if (CollectionUtils.isNotEmpty(lastUsableList)) {
            List<DataVersion> lastUsableVersionList = dataVersionService.list(new QueryWrapper<DataVersion>()
                    .in("business_id", lastUsableList.stream()
                            .map(MaterialCategory::getId)
                            .collect(Collectors.toList())).eq("del_flag", 0));
            lastUsableVersionList.stream().forEach(dataVersion -> {
                dataVersion.setIsLastUsable("0");
            });
            dataVersionService.updateBatchById(lastUsableVersionList);
        }
        //获取生效版本及版本信息并将其置为失效
        List<MaterialCategory> usableList = materialCategoryService.getUsableList();
        if (CollectionUtils.isNotEmpty(usableList)) {
            List<DataVersion> usableDataVersionList = dataVersionService.list(new QueryWrapper<DataVersion>()
                    .in("business_id", usableList.stream()
                            .map(MaterialCategory::getId)
                            .collect(Collectors.toList())));
            usableDataVersionList.stream().forEach(dataVersion -> {
                dataVersion
                        .setVersionStatus("3")
                        .setIsLastUsable("1")
                        .setExpiredTime(new Date(System.currentTimeMillis()));
            });
            dataVersionService.updateBatchById(usableDataVersionList);
        }
        //获取待生效版本及版本信息并将其置为生效
        List<DataVersion> dataVersionList = dataVersionService.list(new QueryWrapper<DataVersion>()
                .in("business_id", materialCategoryService
                        .list(
                                new QueryWrapper<MaterialCategory>()
                                        .eq("version", version)
                                        .eq("del_flag", 0)
                        )
                        .stream().map(MaterialCategory::getId)
                        .collect(Collectors.toList())));
        dataVersionList.stream().forEach(dataVersion -> {
            dataVersion.setVersionStatus("2")
                    .setEffectiveType("2")
                    .setEffectiveTime(new Date(System.currentTimeMillis()))
                    .setIsLastUsable("0");
        });
        //存入数据库
        dataVersionService.updateBatchById(dataVersionList);
        return Result.OK("生效成功");
    }

    /**
     * 定时生效
     * 需要一次性完成
     *
     * @param quartzJob
     * @param
     * @return
     */
    @PostMapping("/updateVersionStatusToUsableBySetTime")
    @Transactional
    public Result<?> updateVersionStatusToUsableBySetTime(@RequestBody QuartzJob quartzJob) {
        DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        DateTimeFormatter dateTimeFormatter1 = DateTimeFormatter.ofPattern("ss mm HH dd MM ? yyyy");
        String jobClassName = quartzJob.getJobClassName();
        String time = quartzJob.getCronExpression();
        LocalDateTime localDateTime = LocalDateTime.parse(time, dateTimeFormatter);
        String cronStr = dateTimeFormatter1.format(localDateTime);
        quartzJob.setCronExpression(cronStr);
        QueryWrapper<QuartzJob> queryWrapper = new QueryWrapper();
        queryWrapper.eq("JOB_CLASS_NAME", jobClassName);
        List<QuartzJob> quartzJobs = quartzJobService.list(queryWrapper);
        if (CollectionUtils.isEmpty(quartzJobs)) {
            quartzJobService.saveAndScheduleJob(quartzJob);
            quartzJobs = quartzJobService.list(queryWrapper);
            quartzJob.setId(quartzJobs.get(0).getId());
            quartzJobService.resumeJob(quartzJob);
            return Result.OK(quartzJob);
        } else {
            quartzJob.setId(quartzJobs.get(0).getId());
            quartzJobService.resumeJob(quartzJob);
            return Result.OK(quartzJob);
        }
    }

    /**
     * 编辑
     *
     * @param materialCategory
     * @return
     */
    @AutoLog(value = "物料分类-编辑")
    @ApiOperation(value = "物料分类-编辑", notes = "物料分类-编辑")
    @RequestMapping(value = "/edit", method = {RequestMethod.PUT, RequestMethod.POST})
    public Result<String> edit(@RequestBody MaterialCategory materialCategory) {
        materialCategoryService.updateById(materialCategory);
        return Result.OK("编辑成功!");
    }

    /**
     * 通过id删除
     *
     * @param id
     * @return
     */
    @AutoLog(value = "物料分类-通过id删除")
    @ApiOperation(value = "物料分类-通过id删除", notes = "物料分类-通过id删除")
    @DeleteMapping(value = "/delete")
    @Transactional
    public Result<String> delete(@RequestParam(name = "id", required = true) String id) {
        dataVersionService.update(new UpdateWrapper<DataVersion>()
                .set("del_flag", 1)
                .eq("business_id", id));
        materialCategoryService.update(new UpdateWrapper<MaterialCategory>().
                set("del_flag", 1)
                .eq("id", id));
        return Result.OK("删除成功!");
    }


    /**
     * 升版单个树节点并返回升版后新节点Id
     *
     * @param materialCategory
     * @param newParentId
     * @param newVersion
     * @return newEnterPriseId
     */
    public String updataOneNode(MaterialCategory materialCategory, String newParentId, Integer newVersion) {
        //1.取出旧版本信息;2.创建将新版本物料分类及其版本号并存入数据库
        DataVersion oldDataVersion = dataVersionService.getOne(new LambdaQueryWrapper<DataVersion>()
                .eq(DataVersion::getBusinessId, materialCategory.getId())
                .eq(DataVersion::getDelFlag, CommonConstant.DEL_FLAG_0.toString()), true);
        materialCategory.setId(null);
        materialCategory.setParentId(newParentId);
        materialCategory.setVersion(newVersion);
        // 添加物料分类
        materialCategoryService.save(materialCategory);
        MaterialCategory newEnterprise = materialCategoryService.getOne(new QueryWrapper<MaterialCategory>()
                .eq("code", materialCategory.getCode())
                .eq("version", newVersion)
                .eq("del_flag", 0), true);
        DataVersion newDataVersion = new DataVersion();
        newDataVersion
                .setVersion(newVersion)
                .setBusinessType("物料分类")
                .setBusinessId(newEnterprise.getId())
                .setIsLastUsable("0")
                .setVersionStatus("1")
                .setDelFlag(0)
                .setSourceVersionId(oldDataVersion.getId());
        // 添加数据版本
        dataVersionService.save(newDataVersion);
        //将版本号存入关联的集团架构
        String newDataVersionId = dataVersionService
                .getOne(new QueryWrapper<DataVersion>()
                        .eq("business_id", newDataVersion.getBusinessId())
                        .eq("del_flag", 0)).getId();
        materialCategoryService.update(new UpdateWrapper<MaterialCategory>()
                .set("data_version_id", newDataVersionId)
                .eq("id", newEnterprise.getId()));
        return newEnterprise.getId();
    }

    /**
     * 获取当前生效版本和上一次生效版本的版本号
     *
     * @return
     */
    @GetMapping("/getNowAndLastUsableVersion")
    public Result<?> getNowAndLastUsableVersion() {
        return Result.OK(materialCategoryService.getNowAndLastUsableVersion());
    }

    /**
     * 表单验证
     */
    @GetMapping("/check")
    public Result<?> check(@RequestParam(name = "name", required = false) String name,
                           @RequestParam(name = "version", required = false) Integer version,
                           @RequestParam(name = "parentId", required = true) String parentId
    ) {
        LambdaQueryWrapper<MaterialCategory> wrapper = new LambdaQueryWrapper<>();
        if (!StringUtils.isBlank(name)) {
            wrapper.eq(MaterialCategory::getName, name);
        }
        if (version != null) {
            wrapper.eq(MaterialCategory::getVersion, version);
        }
        if (!StringUtils.isBlank(parentId)) {
            wrapper.eq(MaterialCategory::getParentId, parentId);
        }
        wrapper.eq(MaterialCategory::getDelFlag, CommonConstant.DEL_FLAG_0.toString());
        return Result.OK(materialCategoryService.list(wrapper));
    }
}