package com.thhy.materials.modules.biz.rebarprint.service.impl;

import cn.hutool.core.io.IoUtil;
import cn.hutool.poi.excel.ExcelWriter;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.github.pagehelper.util.StringUtil;
import com.thhy.general.common.BasicResult;
import com.thhy.general.config.SysUserInfo;
import com.thhy.general.utils.UserInfoUtils;
import com.thhy.materials.modules.biz.rebarprint.dto.AppProduceLoopingParamDto;
import com.thhy.materials.modules.biz.rebarprint.entity.TSteelCheckRecord;
import com.thhy.materials.modules.biz.rebarprint.entity.dto.CheckDto;
import com.thhy.materials.modules.biz.rebarprint.entity.dto.ProduceDto;
import com.thhy.materials.modules.biz.rebarprint.entity.dto.ProduceExportDto;
import com.thhy.materials.modules.biz.rebarprint.entity.dto.ProduceInventoryDto;
import com.thhy.materials.modules.biz.rebarprint.mapper.TSteelProduceMapper;
import com.thhy.materials.modules.biz.rebarprint.service.TSteelProduceService;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.OutputStream;
import java.util.*;
import java.util.stream.Collectors;

@Service
public class TSteelProduceServiceImpl implements TSteelProduceService {

    @Resource
    private TSteelProduceMapper steelProduceMapper;


    @Override
    public BasicResult steelProduceList(Map<String, Object> values) {
        SysUserInfo sysUserInfo = UserInfoUtils.getInstance().getUserInfo();
        String companyId = sysUserInfo.getCompanyId();
        values.put("companyId",companyId);
        Integer pageNum = Integer.valueOf(values.get("pageNum").toString());
        Integer pageSize = Integer.valueOf(values.get("pageSize").toString());
        PageHelper.startPage(pageNum,pageSize);
        List<ProduceDto> steelProduces = steelProduceMapper.steelProduceList(values);
        PageInfo<ProduceDto> tSteelProducePageInfo = new PageInfo<>(steelProduces);
        return BasicResult.success(tSteelProducePageInfo);
    }

    @Override
    public BasicResult steelProduceInfo(String steelProduceId) {
        ProduceDto steelProduces = steelProduceMapper.steelProduceInfo(steelProduceId);
        return BasicResult.success(steelProduces);
    }

    @Override
    public BasicResult produceInventory(Map<String, Object> values) {
        SysUserInfo sysUserInfo = UserInfoUtils.getInstance().getUserInfo();
        values.put("companyId",sysUserInfo.getCompanyId());
        Integer pageSize = Integer.valueOf(values.get("pageSize").toString());
        Integer pageNum = Integer.valueOf(values.get("pageNum").toString());
        PageHelper.startPage(pageNum,pageSize);
        List<ProduceInventoryDto> inventoryDtos = steelProduceMapper.produceInventory(values);
        PageInfo<ProduceInventoryDto> produceInventoryDtoPageInfo = new PageInfo<>(inventoryDtos);
        return BasicResult.success(produceInventoryDtoPageInfo);
    }

    @Override
    public BasicResult produceLooping(Map<String, Object> values) {
        String proId = values.get("proId").toString();
        List<String> dictIds = steelProduceMapper.blockNumSelectAll(proId);

        List<ProduceInventoryDto> inventoryDtos = steelProduceMapper.produceInventory(values);
        List<ProduceInventoryDto> reinforcementIdS = steelProduceMapper.produceInventoryReinforcementId(values);
        System.out.println("当前的数量"+inventoryDtos);
        List<List<ProduceInventoryDto>> info = new ArrayList<>();
        List<Object> hashMap=new ArrayList<Object>();
        for (ProduceInventoryDto inventoryDto : reinforcementIdS){
            List<ProduceInventoryDto> infos=new ArrayList<ProduceInventoryDto>();
            values.put("reinforcementId",inventoryDto.getReinforcementId());
            List<ProduceInventoryDto> inventoryDtos1 = steelProduceMapper.produceInventory(values);
            System.out.println("加上配筋后的数量"+inventoryDtos1);
            if(dictIds.size()==inventoryDtos1.size()){
                List<Integer> collect = inventoryDtos1.stream().map(ProduceInventoryDto::getInventory).collect(Collectors.toList());
                Integer min = Collections.min(collect);
                HashMap<String, Object> hashMap1 = new HashMap<>();
                hashMap1.put("counts",min);
                hashMap1.put("reinforcementId",inventoryDto.getReinforcementId());
                hashMap1.put("reinforcementName",inventoryDto.getReinforcementName());
                hashMap.add(hashMap1);
                if(inventoryDtos1.size()>0){
                    for (ProduceInventoryDto produceInventoryDto :inventoryDtos1){
                        int i = produceInventoryDto.getInventory() - min;
                        produceInventoryDto.setInventory(i);
                        System.out.println("------"+produceInventoryDto);
                        infos.add(produceInventoryDto);
                    }
                    info.add(infos);
                }
            }else {
                for (ProduceInventoryDto produceInventoryDto :inventoryDtos1){
                    infos.add(produceInventoryDto);
                }
                info.add(infos);
            }
        }
        HashMap<String, Object> objectObjectHashMap = new HashMap<>();
        objectObjectHashMap.put("looping",hashMap);
        objectObjectHashMap.put("info",info);
        return BasicResult.success(objectObjectHashMap);
    }
    @Override
    public BasicResult produceLoopingThingJs(Map<String, Object> values) {
        String proId = values.get("proId").toString();
        List<String> dictIds = steelProduceMapper.blockNumSelectAll(proId);

        List<ProduceInventoryDto> inventoryDtos = steelProduceMapper.produceInventory(values);
        List<ProduceInventoryDto> reinforcementIdS = steelProduceMapper.produceInventoryReinforcementId(values);
        System.out.println("当前的数量"+inventoryDtos);
        List<List<ProduceInventoryDto>> info = new ArrayList<>();
        List<Object> hashMap=new ArrayList<Object>();
        for (ProduceInventoryDto inventoryDto : reinforcementIdS){
            List<ProduceInventoryDto> infos=new ArrayList<ProduceInventoryDto>();
            values.put("reinforcementId",inventoryDto.getReinforcementId());
            List<ProduceInventoryDto> inventoryDtos1 = steelProduceMapper.produceInventory(values);
            System.out.println("加上配筋后的数量"+inventoryDtos1);
            if(dictIds.size()==inventoryDtos1.size()){
                List<Integer> collect = inventoryDtos1.stream().map(ProduceInventoryDto::getInventory).collect(Collectors.toList());
                Integer min = Collections.min(collect);
                HashMap<String, Object> hashMap1 = new HashMap<>();
                hashMap1.put("counts",min);
                hashMap1.put("reinforcementId",inventoryDto.getReinforcementId());
                hashMap1.put("reinforcementName",inventoryDto.getReinforcementName());
                hashMap.add(hashMap1);
                if(inventoryDtos1.size()>0){
                    for (ProduceInventoryDto produceInventoryDto :inventoryDtos1){
                        int i = produceInventoryDto.getInventory() - min;
                        produceInventoryDto.setInventory(i);
                        System.out.println("------"+produceInventoryDto);
                        infos.add(produceInventoryDto);
                    }
                    info.add(infos);
                }
            }else {
                for (ProduceInventoryDto produceInventoryDto :inventoryDtos1){
                    infos.add(produceInventoryDto);
                }
                info.add(infos);
            }
        }
        HashMap<String, Object> objectObjectHashMap = new HashMap<>();
        objectObjectHashMap.put("looping",hashMap);
        objectObjectHashMap.put("info",info);
        return BasicResult.success(objectObjectHashMap);
    }

    @Override
    public BasicResult appProduceLooping(AppProduceLoopingParamDto values) {
        List<AppProduceLoopingParamDto> paramDtos = values.getParamDtos();
        List<Map<String,Object>> resultList = new ArrayList<>();
        paramDtos.forEach(p->{
            Map<String, Object> map = steelProduceMapper.appProduceLooping(p.getProId(),p.getSizeId());
            if (map!=null){
                resultList.add(map);
            }else {
                Map<String,Object> addMap = new HashMap<>();
                addMap.put("proName",steelProduceMapper.getProName(p.getProId()));
                addMap.put("inventory",0);
                resultList.add(addMap);
            }
        });
        return BasicResult.success(resultList);
    }

    @Override
    public BasicResult appProduceLooping(Map<String, Object> values) {
        String proId = values.get("proId").toString();
        List<String> dictIds = steelProduceMapper.blockNumSelectAll(proId);

        List<ProduceInventoryDto> inventoryDtos = steelProduceMapper.allproduceInventory(values);
        List<ProduceInventoryDto> reinforcementIdS = steelProduceMapper.allProduceInventoryReinforcementId(values);
        System.out.println("当前的数量"+inventoryDtos);
        List<List<ProduceInventoryDto>> info = new ArrayList<>();
        List<Object> hashMap=new ArrayList<Object>();
        for (ProduceInventoryDto inventoryDto : reinforcementIdS){
            List<ProduceInventoryDto> infos=new ArrayList<ProduceInventoryDto>();
            values.put("reinforcementId",inventoryDto.getReinforcementId());
            List<ProduceInventoryDto> inventoryDtos1 = steelProduceMapper.allproduceInventory(values);
            System.out.println("加上配筋后的数量"+inventoryDtos1);
            if(dictIds.size()==inventoryDtos1.size()){
                List<Integer> collect = inventoryDtos1.stream().map(ProduceInventoryDto::getInventory).collect(Collectors.toList());
                Integer min = Collections.min(collect);
                HashMap<String, Object> hashMap1 = new HashMap<>();
                hashMap1.put("counts",min);
                hashMap1.put("reinforcementId",inventoryDto.getReinforcementId());
                hashMap1.put("reinforcementName",inventoryDto.getReinforcementName());
                hashMap.add(hashMap1);
                if(inventoryDtos1.size()>0){
                    for (ProduceInventoryDto produceInventoryDto :inventoryDtos1){
                        System.out.println("------"+produceInventoryDto);
                        infos.add(produceInventoryDto);
                    }
                    info.add(infos);
                }
            }else {
                for (ProduceInventoryDto produceInventoryDto :inventoryDtos1){
                    infos.add(produceInventoryDto);
                }
                info.add(infos);
            }
        }
        HashMap<String, Object> objectObjectHashMap = new HashMap<>();
        objectObjectHashMap.put("looping",hashMap);
        objectObjectHashMap.put("info",info);
        return BasicResult.success(objectObjectHashMap);
    }

    @Override
    public void produceExport(Map<String, Object> values, HttpServletResponse response) {
        SysUserInfo sysUserInfo = UserInfoUtils.getInstance().getUserInfo();
        String companyId = sysUserInfo.getCompanyId();
        values.put("companyId",companyId);
        List<ProduceDto> steelProduces = steelProduceMapper.steelProduceList(values);
        List<ProduceExportDto> exportDtos = new ArrayList<>();
        for (ProduceDto produceDto : steelProduces){
            ProduceExportDto exportDto = new ProduceExportDto();
            exportDto.setProduceNumber(produceDto.getProduceNumber());
            exportDto.setProName(produceDto.getProName());
            exportDto.setSizeName(produceDto.getSizeName());
            exportDto.setReinforcementName(produceDto.getReinforcementName());
            exportDto.setBlockName(produceDto.getBlockName());
            exportDto.setGroupName(produceDto.getGroupName());
            if(StringUtil.isEmpty(produceDto.getPrintTime().toString())){
                exportDto.setPrintTime("");
            }else {
                exportDto.setPrintTime(produceDto.getPrintTime());
            }
            if(StringUtil.isEmpty(produceDto.getQualityTime())){
                exportDto.setQualityTime("");
            }else {
                exportDto.setQualityTime(produceDto.getQualityTime().toString());
            }
            exportDto.setRealName(produceDto.getRealName());
            exportDto.setQualityUserName(produceDto.getQualityUserName());

            if(produceDto.getIsQualified()!=null && produceDto.getIsQualified()==1){
                exportDto.setIsQualified("合格");
            }else if (produceDto.getIsQualified()!=null && produceDto.getIsQualified()==2){
                exportDto.setIsQualified("不合格");
            }else if (produceDto.getIsQualified()!=null && produceDto.getIsQualified()==3){
                exportDto.setIsQualified("报废");
            }
            if(produceDto.getIsModel()!=null && produceDto.getIsModel()==1){
                exportDto.setIsModel("入模");
            }else if (produceDto.getIsModel()!=null && produceDto.getIsModel()==2){
                exportDto.setIsModel("未入模");
            }
            exportDtos.add(exportDto);
        }
        ExcelWriter excel = new ExcelWriter();//定义excel
        excel.addHeaderAlias("produceNumber", "钢筋编号");
        excel.addHeaderAlias("proName", "项目名称");
        excel.addHeaderAlias("sizeName", "尺寸");
        excel.addHeaderAlias("reinforcementName", "配筋");
        excel.addHeaderAlias("blockName", "块号");
        excel.addHeaderAlias("groupName", "生产班组");
        excel.addHeaderAlias("printTime", "打印时间");
        excel.addHeaderAlias("realName", "制作人");
        excel.addHeaderAlias("qualityUserName", "质检人");
        excel.addHeaderAlias("qualityTime", "质检时间");
        excel.addHeaderAlias("isQualified", "是否合格");
        excel.addHeaderAlias("isModel", "是否入模");
        response.setContentType("application/vnd.ms-excel;charset=UTF-8");
        response.setHeader("Content-Disposition", "attachment;filename=test.xls");
        OutputStream out = null;
        try {
            out = response.getOutputStream();
            excel.write(exportDtos);
            excel.flush(out, true);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 关闭writer，释放内存
            excel.close();
        }
        IoUtil.close(out);


    }

    @Override
    public BasicResult steelProduceCheck(Map<String, Object> values) {
        List<TSteelCheckRecord> steelCheckRecords = steelProduceMapper.steelProduceCheck(values);
        TSteelCheckRecord tSteelCheckRecord = steelCheckRecords.get(0);
        String checkFaildReason = tSteelCheckRecord.getCheckFaildReason();
        if(!StringUtil.isEmpty(checkFaildReason)){
            String[] split = checkFaildReason.split(",");
            if(split!=null&&split.length>0){
                List<CheckDto> objects = new ArrayList<>();
                for (String sId :split){
                    CheckDto checkDto = steelProduceMapper.checkInfo(sId);
                    objects.add(checkDto);
                }
                tSteelCheckRecord.setCheckDtos(objects);
            }
        }
        for (TSteelCheckRecord  tSteelCheckRecord1 :steelCheckRecords){
            List<String> check_file = steelProduceMapper.checkFile(tSteelCheckRecord1.getCheckId());
            tSteelCheckRecord1.setCheckFile(check_file);
        }

        return BasicResult.success(steelCheckRecords);
    }

    @Override
    public BasicResult steelProduceFeedback(Map<String, Object> values) {
        List<TSteelCheckRecord> steelCheckRecords = steelProduceMapper.steelProduceCheck(values);
        TSteelCheckRecord tSteelCheckRecord = steelCheckRecords.get(0);
        HashMap<String, Object> hashMap = new HashMap<>();
        hashMap.put("checkId",tSteelCheckRecord.getCheckId());
        hashMap.put("remark",values.get("remark").toString());
        hashMap.put("execResult",values.get("execResult").toString());
        hashMap.put("execFlag",1);
        steelProduceMapper.steelProduceFeedback(hashMap);
        return BasicResult.success("提交成功");
    }


}