package org.jeecg.modules.lims.testing.controller;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
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.apache.commons.lang3.ObjectUtils;
import org.jeecg.common.api.vo.Result;
import org.jeecg.common.aspect.annotation.AutoLog;
import org.jeecg.common.system.base.controller.JeecgController;
import org.jeecg.common.system.query.QueryGenerator;
import org.jeecg.modules.lims.testing.dto.LimsTestingCategoryDTO;
import org.jeecg.modules.lims.testing.dto.LimsTestingItemDTO;
import org.jeecg.modules.lims.testing.dto.LimsTestingTypeDTO;
import org.jeecg.modules.lims.testing.entity.LimsTestingCategory;
import org.jeecg.modules.lims.testing.entity.LimsTestingItem;
import org.jeecg.modules.lims.testing.entity.LimsTestingOutline;
import org.jeecg.modules.lims.testing.entity.LimsTestingType;
import org.jeecg.modules.lims.testing.service.ILimsTestingCategoryService;
import org.jeecg.modules.lims.testing.service.ILimsTestingItemService;
import org.jeecg.modules.lims.testing.service.ILimsTestingOutlineService;
import org.jeecg.modules.lims.testing.service.ILimsTestingTypeService;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

/**
 * @Description: lims_testing_outline
 * @Author: jeecg-boot
 * @Date: 2023-04-19
 * @Version: V1.0
 */
@Api(tags = "lims_testing_outline")
@RestController
@RequestMapping("/lims/testing/outline")
@Slf4j
public class LimsTestingOutlineController extends JeecgController<LimsTestingOutline, ILimsTestingOutlineService> {
    @Autowired
    private ILimsTestingOutlineService limsTestingOutlineService;

    @Autowired
    private ILimsTestingCategoryService limsTestingCategoryService;
    @Autowired
    private ILimsTestingTypeService limsTestingTypeService;
    @Autowired
    private ILimsTestingItemService limsTestingItemService;

    /**
     * 分页列表查询
     *
     * @param limsTestingOutline
     * @param pageNo
     * @param pageSize
     * @param req
     * @return
     */
    @AutoLog(value = "lims_testing_outline-分页列表查询")
    @ApiOperation(value = "lims_testing_outline-分页列表查询", notes = "lims_testing_outline-分页列表查询")
    @GetMapping(value = "/list")
    public Result<?> queryPageList(LimsTestingOutline limsTestingOutline,
                                   @RequestParam(name = "pageNo", defaultValue = "1") Integer pageNo,
                                   @RequestParam(name = "pageSize", defaultValue = "10") Integer pageSize,
                                   HttpServletRequest req) {
        QueryWrapper<LimsTestingOutline> queryWrapper = QueryGenerator.initQueryWrapper(limsTestingOutline, req.getParameterMap());
        Page<LimsTestingOutline> page = new Page<LimsTestingOutline>(pageNo, pageSize);
        IPage<LimsTestingOutline> pageList = limsTestingOutlineService.page(page, queryWrapper);
        return Result.OK(pageList);
    }

    /**
     * 添加
     *
     * @param limsTestingOutline
     * @return
     */
    @AutoLog(value = "lims_testing_outline-添加")
    @ApiOperation(value = "lims_testing_outline-添加", notes = "lims_testing_outline-添加")
    @PostMapping(value = "/add")
    public Result<?> add(@RequestBody LimsTestingOutline limsTestingOutline) {
        limsTestingOutlineService.save(limsTestingOutline);
        return Result.OK("添加成功！");
    }

    /**
     * 编辑
     *
     * @param limsTestingOutline
     * @return
     */
    @AutoLog(value = "lims_testing_outline-编辑")
    @ApiOperation(value = "lims_testing_outline-编辑", notes = "lims_testing_outline-编辑")
    @PutMapping(value = "/edit")
    @Transactional
    public Result<?> edit(@RequestBody LimsTestingOutline limsTestingOutline) {




        if(limsTestingOutline.getStatus() != null){
            //发布
            if(limsTestingOutline.getStatus() == 1){
                //发布时废止旧版本
                queryOldOutline(limsTestingOutline);

                //大纲的状态 0-新建  1-发布  2-废止
                limsTestingOutlineService.updateById(limsTestingOutline);
            }else if(limsTestingOutline.getStatus() == 2){
                //复制一条记录
                generateNewVersion(limsTestingOutline);
            }else {
                //大纲的状态 0-新建  1-发布  2-废止
                limsTestingOutlineService.updateById(limsTestingOutline);
            }

        }
        return Result.OK("编辑成功!");
    }
    /**
     * 查询产品（已发布）大纲，并更新为废止状态
     *
     * @param limsTestingOutline
     */
    private void queryOldOutline(LimsTestingOutline limsTestingOutline){
        QueryWrapper<LimsTestingOutline> queryWrapper = new QueryWrapper<>();
        queryWrapper.lambda().eq(LimsTestingOutline::getCode,limsTestingOutline.getCode());
        //已发布
        queryWrapper.lambda().eq(LimsTestingOutline::getStatus,1);
        List<LimsTestingOutline> list = limsTestingOutlineService.list(queryWrapper);
        list.forEach(item -> {
            item.setStatus(2);
            limsTestingOutlineService.updateById(item);
        });
    }

    /**
     * 复制大纲生成新版本
     */
    private void generateNewVersion(LimsTestingOutline limsTestingOutline) {
        //根据id查询子项数据
        String oid = limsTestingOutline.getId();
        //1.查询cat
        QueryWrapper<LimsTestingCategory> catWrapper = new QueryWrapper<>();
        catWrapper.lambda().eq(LimsTestingCategory::getOutlineId, oid);
        List<LimsTestingCategory> catList = limsTestingCategoryService.list(catWrapper);
        List<String> catIds = catList.stream().map(item -> item.getId()).collect(Collectors.toList());
        if(catIds.isEmpty()){
            catIds.add("empty");
        }
        //2.查询typ
        QueryWrapper<LimsTestingType> typWrapper = new QueryWrapper<>();
        typWrapper.lambda().in(LimsTestingType::getCategoryId, catIds);
        List<LimsTestingType> typList = limsTestingTypeService.list(typWrapper);
        List<String> typIds = typList.stream().map(item -> item.getId()).collect(Collectors.toList());
        if(typIds.isEmpty()){
            typIds.add("empty");
        }
        //3.查询itm
        QueryWrapper<LimsTestingItem> itmWrapper = new QueryWrapper<>();
        itmWrapper.lambda().in(LimsTestingItem::getTypeId, typIds);
        List<LimsTestingItem> itmList = limsTestingItemService.list(itmWrapper);
        //List<String> itmIds = itmList.stream().map(item -> item.getId()).collect(Collectors.toList());

        LimsTestingOutline outline = new LimsTestingOutline();
        BeanUtils.copyProperties(limsTestingOutline, outline);
        //4.拷贝生成新的大纲
        outline.setId(null);
        //设置大纲状态为 0-新建
        outline.setStatus(0);
        outline.setCreateTime(null);
        outline.setCreateBy(null);
        outline.setUpdateTime(null);
        outline.setUpdateBy(null);
        if(outline.getVer() ==null ){
            outline.setVer(1);
        }else {
            outline.setVer(outline.getVer()+1);
        }
        limsTestingOutlineService.save(outline);

        //5.生成并保存新大纲明细数据 cat typ itm
        generateAndSave(catList, typList, itmList,outline.getId());



    }

    /**
     * @param catList
     * @param typList
     * @param itmList
     * @param outlineId  拷贝后的 新大纲id
     */
    private void generateAndSave(List<LimsTestingCategory> catList, List<LimsTestingType> typList, List<LimsTestingItem> itmList,String outlineId) {
        //entity转DTO
        List<LimsTestingCategoryDTO> catDTOList = catList.stream().map(item -> {
            LimsTestingCategoryDTO dto = new LimsTestingCategoryDTO();
            BeanUtils.copyProperties(item, dto);
            return dto;
        }).collect(Collectors.toList());

        List<LimsTestingTypeDTO> typDTOList = typList.stream().map(item -> {
            LimsTestingTypeDTO dto = new LimsTestingTypeDTO();
            BeanUtils.copyProperties(item, dto);
            return dto;
        }).collect(Collectors.toList());

        List<LimsTestingItemDTO> itmDTOList = itmList.stream().map(item -> {
            LimsTestingItemDTO dto = new LimsTestingItemDTO();
            BeanUtils.copyProperties(item, dto);
            return dto;
        }).collect(Collectors.toList());

        //建立父子关系
        catDTOList.stream().forEach(cat->{
            typDTOList.stream().forEach(typ->{
                if(cat.getId().equals(typ.getCategoryId())){
                    cat.getChildren().add(typ);

                    itmDTOList.forEach(itm->{
                        if(typ.getId().equals(itm.getTypeId())){
                            typ.getChildren().add(itm);
                        }
                    });
                }

            });
        });
        //执行拷贝
        catDTOList.stream().forEach(cat->{
            cat.setId(null);
            cat.setCreateTime(null);
            cat.setCreateBy(null);
            cat.setUpdateTime(null);
            cat.setUpdateBy(null);
            //赋值新大纲ID
            cat.setOutlineId(outlineId);
            limsTestingCategoryService.save(cat);
            if(cat.getChildren().size()>0){
                List<LimsTestingTypeDTO> typeDTOList = cat.getChildren();
                typeDTOList.stream().forEach(typ->{
                    typ.setId(null);
                    typ.setCreateTime(null);
                    typ.setCreateBy(null);
                    typ.setUpdateTime(null);
                    typ.setUpdateBy(null);
                    typ.setCategoryId(cat.getId());
                    limsTestingTypeService.save(typ);

                    if(typ.getChildren().size()>0){
                        List<LimsTestingItemDTO> itemDTOList = typ.getChildren();
                        itemDTOList.stream().forEach(itm->{
                            itm.setId(null);
                            itm.setCreateTime(null);
                            itm.setCreateBy(null);
                            itm.setUpdateTime(null);
                            itm.setUpdateBy(null);
                            itm.setTypeId(typ.getId());
                            limsTestingItemService.save(itm);
                        });
                    }

                });
            }

        });

    }

    /**
     * 通过id删除
     *
     * @param id
     * @return
     */
    @AutoLog(value = "lims_testing_outline-通过id删除")
    @ApiOperation(value = "lims_testing_outline-通过id删除", notes = "lims_testing_outline-通过id删除")
    @DeleteMapping(value = "/delete")
    @Transactional
    public Result<?> delete(@RequestParam(name = "id", required = true) String id) {
        limsTestingOutlineService.removeById(id);
        //删除大纲的同时需要删除大纲明细数据
        //1.cat
        QueryWrapper<LimsTestingCategory> catWrapper = new QueryWrapper<>();
        catWrapper.lambda().eq(LimsTestingCategory::getOutlineId,id);
        List<LimsTestingCategory> catList = limsTestingCategoryService.list(catWrapper);
        List<String> catIds = catList.stream().map(item -> item.getId()).collect(Collectors.toList());
        if(catIds.isEmpty()){
            catIds.add("empty");
        }
        //2.typ
        QueryWrapper<LimsTestingType> typWrapper = new QueryWrapper<>();
        typWrapper.lambda().in(LimsTestingType::getCategoryId,catIds);
        List<LimsTestingType> typList = limsTestingTypeService.list(typWrapper);
        List<String> typIds = typList.stream().map(item -> item.getId()).collect(Collectors.toList());
        if(typIds.isEmpty()){
            typIds.add("empty");
        }
        //3.itm
        QueryWrapper<LimsTestingItem> itmWrapper = new QueryWrapper<>();
        itmWrapper.lambda().in(LimsTestingItem::getTypeId,typIds);
        List<LimsTestingItem> itmList = limsTestingItemService.list(itmWrapper);
        List<String> itmIds = itmList.stream().map(item -> item.getId()).collect(Collectors.toList());


        limsTestingCategoryService.removeByIds(catIds);
        limsTestingTypeService.removeByIds(typIds);
        limsTestingItemService.removeByIds(itmIds);


        return Result.OK("删除成功!");
    }

    /**
     * 批量删除
     *
     * @param ids
     * @return
     */
    @AutoLog(value = "lims_testing_outline-批量删除")
    @ApiOperation(value = "lims_testing_outline-批量删除", notes = "lims_testing_outline-批量删除")
    @DeleteMapping(value = "/deleteBatch")
    public Result<?> deleteBatch(@RequestParam(name = "ids", required = true) String ids) {
        this.limsTestingOutlineService.removeByIds(Arrays.asList(ids.split(",")));
        return Result.OK("批量删除成功!");
    }

    /**
     * 通过id查询
     *
     * @param id
     * @return
     */
    @AutoLog(value = "lims_testing_outline-通过id查询")
    @ApiOperation(value = "lims_testing_outline-通过id查询", notes = "lims_testing_outline-通过id查询")
    @GetMapping(value = "/queryById")
    public Result<?> queryById(@RequestParam(name = "id", required = true) String id) {
        LimsTestingOutline limsTestingOutline = limsTestingOutlineService.getById(id);
        if (limsTestingOutline == null) {
            return Result.error("未找到对应数据");
        }
        return Result.OK(limsTestingOutline);
    }

    /**
     * 导出excel
     *
     * @param request
     * @param limsTestingOutline
     */
    @RequestMapping(value = "/exportXls")
    public ModelAndView exportXls(HttpServletRequest request, LimsTestingOutline limsTestingOutline) {
        return super.exportXls(request, limsTestingOutline, LimsTestingOutline.class, "lims_testing_outline");
    }

    /**
     * 通过excel导入数据
     *
     * @param request
     * @param response
     * @return
     */
    @RequestMapping(value = "/importExcel", method = RequestMethod.POST)
    public Result<?> importExcel(HttpServletRequest request, HttpServletResponse response) {
        return super.importExcel(request, response, LimsTestingOutline.class);
    }

}