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

import com.alibaba.fastjson.JSON;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.jeecg.common.api.vo.Result;
import org.jeecg.common.aspect.annotation.AutoLog;
import org.jeecg.modules.lims.testing.entity.*;
import org.jeecg.modules.lims.testing.service.*;
import org.jeecg.modules.lims.testing.vo.LimsBatchDetailVo;
import org.jeecg.modules.lims.testing.vo.LimsBatchSampleVo;
import org.jeecg.modules.lims.testing.vo.LimsTestingTypeVo;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import java.util.*;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.stream.Collectors;

@Api(tags = "小程序接口")
@RestController
@RequestMapping("/lims/testing/mini")
@Slf4j
public class LimsMiniController {
    /**
     * description:
     * 小程序中部分组件或页面需要组装数据或回写数据，新增接口
     */
    @Autowired
    private ILimsBatchResultService resultService;
    @Autowired
    private ILimsTestingTypeService typeService;
    @Autowired
    private ILimsBatchDetailService detailService;
    @Autowired
    private ILimsTestingItemService itemService;
    @Autowired
    private ILimsTestingBatchService batchService;
    @Autowired
    private ILimsTestingStandCondService condService;
    @Autowired
    private ILimsBatchSampleService sampleService;
    @Autowired
    private ILimsTestingCategoryService categoryService;
    @Autowired
    private ILimsTestingStandardService standardService;
    @Autowired
    private ILimsItemTargetService targetService;


    @AutoLog(value = "小程序-查询批次检验分类-鉴定类别")
    @ApiOperation(value = "小程序-查询批次检验分类-鉴定类别", notes = "小程序-查询批次检验分类-鉴定类别")
    @GetMapping(value = "/bacthCatList")
    public Result<?> queryBatchCatList(LimsTestingBatch limsTestingBatch) {
        QueryWrapper<LimsBatchResult> resultQueryWrapper = new QueryWrapper<>();
        resultQueryWrapper.lambda().eq(LimsBatchResult::getBatchId, limsTestingBatch.getId());
        //1.查询批次检验结果列表，
        List<LimsBatchResult> resultList = resultService.list(resultQueryWrapper);
        //2.得到鉴定类别id列表
        List<String> catIds = resultList.stream().map(LimsBatchResult::getTestingCat).collect(Collectors.toList());
        if (catIds.isEmpty()) catIds.add("empty");
        //3.查询鉴定类别列表
        QueryWrapper<LimsTestingCategory> catQueryWrapper = new QueryWrapper<>();
        catQueryWrapper.lambda().in(LimsTestingCategory::getId, catIds);
        List<LimsTestingCategory> catList = categoryService.list(catQueryWrapper);

      /*  LimsTestingBatch batch = batchService.getById(limsTestingBatch.getId());
        if (StringUtils.isEmpty(batch.getStandardId())) {
            return Result.error("技术标准信息错误！");
        }
        QueryWrapper<LimsItemTarget> targetQueryWrapper = new QueryWrapper<>();
        targetQueryWrapper.lambda().eq(LimsItemTarget::getStandardId, batch.getStandardId());
        targetQueryWrapper.lambda().eq(LimsItemTarget::getEnabled, 1);
        List<LimsItemTarget> itemTargetList = targetService.list(targetQueryWrapper);
        List<String> catIds = itemTargetList.stream().map(LimsItemTarget::getCategoryId).collect(Collectors.toList());
        if (catIds.isEmpty()) catIds.add("empty");
        QueryWrapper<LimsTestingCategory> catQueryWrapper = new QueryWrapper<>();
        catQueryWrapper.lambda().in(LimsTestingCategory::getId, catIds);
        List<LimsTestingCategory> catList = categoryService.list(catQueryWrapper);*/
        return Result.OK(catList);
    }

    @AutoLog(value = "小程序-查询批次检验分类-根据鉴定类别查询鉴定类型")
    @ApiOperation(value = "小程序-查询批次检验分类-根据鉴定类别查询鉴定类型", notes = "小程序-查询批次检验分类-根据鉴定类别查询鉴定类型")
    @GetMapping(value = "/typList")
    public Result<?> queryTypListByCat(LimsBatchResult limsBatchResult) {
        //查询BatchResult
        QueryWrapper<LimsBatchResult> resultQueryWrapper = new QueryWrapper<>();
        resultQueryWrapper.lambda().eq(LimsBatchResult::getBatchId, limsBatchResult.getBatchId());
        resultQueryWrapper.lambda().eq(LimsBatchResult::getTestingCat, limsBatchResult.getTestingCat());
        List<LimsBatchResult> resultList = resultService.list(resultQueryWrapper);
        if (resultList.isEmpty()) {
            return Result.error("未查询到数据!");
        }


        List<String> typIds = resultList.stream().map(LimsBatchResult::getTestingType).distinct().collect(Collectors.toList());
        if (typIds.isEmpty()) typIds.add("empty");

        QueryWrapper<LimsTestingType> typQueryWrapper = new QueryWrapper<>();
        typQueryWrapper.lambda().in(LimsTestingType::getId, typIds);
        List<LimsTestingType> typList = typeService.list(typQueryWrapper);

        //统计每个类型的完成数量
        Map<String, String> typResultMap = resultList.stream().collect(Collectors.toMap(LimsBatchResult::getTestingType, LimsBatchResult::getId));

        List<LimsTestingTypeVo> collect = typList.stream().map(item -> {
            LimsTestingTypeVo vo = new LimsTestingTypeVo();
            BeanUtils.copyProperties(item, vo);
            try {
                String resultId = typResultMap.get(item.getId());
                QueryWrapper<LimsBatchDetail> detailQueryWrapper = new QueryWrapper<>();
                detailQueryWrapper.lambda().eq(LimsBatchDetail::getResultId, resultId);
                List<LimsBatchDetail> detailList = detailService.list(detailQueryWrapper);
                List<LimsBatchDetail> finishDetailList = detailList.stream().filter(d -> d.getValue() != null).collect(Collectors.toList());
                vo.setBatchDetailTotal(detailList.size());
                vo.setBatchDetailFinish(finishDetailList.size());
            } catch (Exception e) {
                e.printStackTrace();
            }

            return vo;
        }).collect(Collectors.toList());


        return Result.OK(collect);
    }


    /**
     * @param batchId 批次
     * @param typeId  检验类型
     * @return
     */

    @AutoLog(value = "小程序-查询批次下type类型的检测条件")
    @ApiOperation(value = "小程序-查询批次下type类型的检测条件", notes = "小程序-查询批次下type类型的检测条件")
    @GetMapping(value = "/typeCond")
    public Result<?> queryBatchTypeCond(String batchId, String typeId) {
        if (StringUtils.isEmpty(batchId)) return Result.error("批次Id不能为空！");
        if (StringUtils.isEmpty(typeId)) return Result.error("检验类型Id不能为空！");

        //1.查询批次产品的技术标准
        LimsTestingBatch batch = batchService.getById(batchId);
        String standardId = batch.getStandardId();
        //2.查询type的检验条件
        QueryWrapper<LimsTestingStandCond> condQueryWrapper = new QueryWrapper<>();
        condQueryWrapper.lambda().eq(LimsTestingStandCond::getStandardId, standardId);
        condQueryWrapper.lambda().eq(LimsTestingStandCond::getTypeId, typeId);
        List<LimsTestingStandCond> condList = condService.list(condQueryWrapper);
        return Result.OK(condList);

    }


    @AutoLog(value = "小程序-查询批次检验结果")
    @ApiOperation(value = "小程序-查询批次检验结果", notes = "小程序-查询批次检验结果")
    @GetMapping(value = "/batchResult")
    public Result<?> queryBatchResult(String batchId, String typeId) {
        if (StringUtils.isEmpty(batchId)) return Result.error("批次Id不能为空！");
        if (StringUtils.isEmpty(typeId)) return Result.error("检验类型Id不能为空！");

        QueryWrapper<LimsBatchResult> resultQueryWrapper = new QueryWrapper<>();
        resultQueryWrapper.lambda().eq(LimsBatchResult::getBatchId, batchId);
        resultQueryWrapper.lambda().eq(LimsBatchResult::getTestingType, typeId);
        LimsBatchResult batchResult = resultService.getOne(resultQueryWrapper);
        return Result.OK(batchResult);

    }


    @AutoLog(value = "小程序-查询批次检验结果")
    @ApiOperation(value = "小程序-查询批次检验结果", notes = "小程序-查询批次检验结果")
    @GetMapping(value = "/inputInfo")
    public Result<?> queryInfo(@RequestParam(required = false) Map<String, String> options) {
        Map<String, Object> result = new HashMap<>();
        Map<String, Object> info = new HashMap<>();
        LimsTestingBatch batch = batchService.getById(options.get("batch"));
        LimsTestingCategory cat = categoryService.getById(options.get("cat"));
        LimsTestingType type = typeService.getById(options.get("type"));
        LimsBatchSample sample = sampleService.getById(options.get("sample"));
        //1.组装页面展示信息
        info.put("batchCode", batch.getBatchCode());
        info.put("typeName", type.getName());
        info.put("catName", cat.getName());
        info.put("cond1", options.get("cond1"));
        info.put("cond2", options.get("cond2"));
        info.put("sampleCode", sample.getCode());


        //1.1 根据batch查询技术标准
        String standardId = batch.getStandardId();
        LimsTestingStandard standard = standardService.getById(standardId);
        //1.2通过批次和技术标准查询
        QueryWrapper<LimsItemTarget> queryWrapper = new QueryWrapper<>();
        queryWrapper.lambda().eq(LimsItemTarget::getStandardId,standard.getId());
        List<LimsItemTarget> targetList = targetService.list(queryWrapper);
        //itemid  valType
        Map<String, String> tarMap = targetList.stream().filter(item->item.getItemId()!=null && item.getValType()!=null).collect(Collectors.toMap(LimsItemTarget::getItemId, LimsItemTarget::getValType));
        //2.查询batch_detail
        QueryWrapper<LimsBatchDetail> detailQueryWrapper = new QueryWrapper<>();
        detailQueryWrapper.lambda().eq(LimsBatchDetail::getBatchId, options.get("batch"));
        detailQueryWrapper.lambda().eq(LimsBatchDetail::getResultId, options.get("result"));
        detailQueryWrapper.lambda().eq(LimsBatchDetail::getSampleId, options.get("sample"));
        detailQueryWrapper.lambda().eq(LimsBatchDetail::getCond, options.get("cond1"));
        detailQueryWrapper.lambda().eq(LimsBatchDetail::getCond2, options.get("cond2"));
        detailQueryWrapper.lambda().isNull(LimsBatchDetail::getDestroy);
        List<LimsBatchDetail> batchDetailList = detailService.list(detailQueryWrapper);

        //破坏性
        QueryWrapper<LimsBatchDetail> detailQueryWrapper2 = new QueryWrapper<>();
        detailQueryWrapper2.lambda().eq(LimsBatchDetail::getBatchId, options.get("batch"));
        detailQueryWrapper2.lambda().eq(LimsBatchDetail::getResultId, options.get("result"));
        detailQueryWrapper2.lambda().eq(LimsBatchDetail::getSampleId, options.get("sample"));
        detailQueryWrapper2.lambda().isNotNull(LimsBatchDetail::getDestroy);
        List<LimsBatchDetail> batchDetailList2 = detailService.list(detailQueryWrapper2);
        batchDetailList.addAll(batchDetailList2);

        List<LimsBatchDetailVo> collect = batchDetailList.stream().map(item -> {
            LimsBatchDetailVo vo = new LimsBatchDetailVo();
            BeanUtils.copyProperties(item, vo);
            LimsTestingItem testingItem = itemService.getById(item.getItemId());
            vo.setItemName(testingItem.getName());
            if(tarMap.containsKey(testingItem.getId())){
                vo.setValType(tarMap.get(testingItem.getId()));
            }

            return vo;
        }).collect(Collectors.toList());
        result.put("info", JSON.toJSON(info));
        result.put("model", JSON.toJSON(collect));
        return Result.OK(result);
    }


    @AutoLog(value = "小程序-根据条件查询样本列表")
    @ApiOperation(value = "小程序-根据条件查询样本列表", notes = "小程序-根据条件查询样本列表")
    @GetMapping(value = "/condSample")
    public Result<?> querySampleByCond(@RequestParam(required = false) Map<String, String> options) {
        String batchId = options.get("batchId");
        String catId = options.get("catId");
        String typeId = options.get("typeId");
        String cond = options.get("cond");
        String cond2 = options.get("cond2");

        //0.查询batch_result
        QueryWrapper<LimsBatchResult> resultQueryWrapper = new QueryWrapper<>();
        resultQueryWrapper.lambda().eq(LimsBatchResult::getBatchId, batchId);
        resultQueryWrapper.lambda().eq(LimsBatchResult::getTestingCat, catId);
        resultQueryWrapper.lambda().eq(LimsBatchResult::getTestingType, typeId);
        LimsBatchResult batchResult = resultService.getOne(resultQueryWrapper);

        //1.1 查询检验明细
        QueryWrapper<LimsBatchDetail> detailQueryWrapper = new QueryWrapper<>();
        detailQueryWrapper.lambda().eq(LimsBatchDetail::getBatchId, batchId);
        detailQueryWrapper.lambda().eq(LimsBatchDetail::getCond, cond);
        detailQueryWrapper.lambda().eq(LimsBatchDetail::getCond2, cond2);
        detailQueryWrapper.lambda().isNull(LimsBatchDetail::getDestroy);
        detailQueryWrapper.lambda().eq(LimsBatchDetail::getResultId, batchResult.getId());
        List<LimsBatchDetail> detailList = detailService.list(detailQueryWrapper);

        //1.2 查询破坏性
        QueryWrapper<LimsBatchDetail> detailQueryWrapper2 = new QueryWrapper<>();
        detailQueryWrapper2.lambda().eq(LimsBatchDetail::getBatchId, batchId);
        detailQueryWrapper2.lambda().isNotNull(LimsBatchDetail::getDestroy);
        detailQueryWrapper2.lambda().eq(LimsBatchDetail::getResultId, batchResult.getId());
        List<LimsBatchDetail> detailList2 = detailService.list(detailQueryWrapper2);
        detailList.addAll(detailList2);

        //2.根据明细,得到样本
        Map<String, List<LimsBatchDetail>> sampleMap = detailList.stream().collect(Collectors.groupingBy(item -> item.getSampleId()));
        List<String> sampleIds = new ArrayList<>(sampleMap.keySet());
        sampleIds.add("empty");
        QueryWrapper<LimsBatchSample> sampleQueryWrapper = new QueryWrapper<>();
        sampleQueryWrapper.lambda().in(LimsBatchSample::getId, sampleIds);

        List<LimsBatchSample> batchSample = sampleService.list(sampleQueryWrapper);

        AtomicInteger index  = new AtomicInteger(1);
        List<LimsBatchSampleVo> collect = batchSample.stream().map(item -> {
            LimsBatchSampleVo vo = new LimsBatchSampleVo();
            BeanUtils.copyProperties(item, vo);
            if (sampleMap.containsKey(item.getId())) {
                List<LimsBatchDetail> finish = sampleMap.get(item.getId()).stream().filter(i -> i.getValue() != null).collect(Collectors.toList());
                vo.setInspectCount(sampleMap.get(item.getId()).size());
                vo.setInspectFinish(finish.size());
            } else {
                vo.setInspectCount(0);
                vo.setInspectFinish(0);
            }
            vo.setModelName("m"+index + vo.getCode().substring(vo.getCode().indexOf("-")) );
            index.getAndIncrement();

            return vo;
        }).collect(Collectors.toList());
        return Result.OK(collect);

    }


}