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

import com.alibaba.nacos.api.utils.StringUtils;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.thhy.general.common.BasicResult;
import com.thhy.general.config.SysUserInfo;
import com.thhy.general.utils.UserInfoUtils;
import com.thhy.materials.modules.biz.concret.entity.*;
import com.thhy.materials.modules.biz.concret.entity.dto.DicetName;
import com.thhy.materials.modules.biz.concret.entity.dto.PieceDto;
import com.thhy.materials.modules.biz.concret.mapper.TMaterialReleaseMappper;
import com.thhy.materials.modules.biz.concret.service.TMaterialReleaseService;
import com.thhy.materials.modules.biz.weigh.mapper.WeighMapper;
import org.apache.poi.ss.usermodel.CellStyle;
import org.apache.poi.ss.usermodel.HorizontalAlignment;
import org.apache.poi.ss.usermodel.VerticalAlignment;
import org.apache.poi.ss.util.CellRangeAddress;
import org.apache.poi.xssf.usermodel.XSSFRow;
import org.apache.poi.xssf.usermodel.XSSFSheet;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletResponse;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.OutputStream;
import java.text.DecimalFormat;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

@Service
public class TMaterialReleaseServiceImpl implements TMaterialReleaseService {

    @Resource
    private TMaterialReleaseMappper materialReleaseMappper;

    @Resource
    private WeighMapper weighMapper;


    @Override
    @Transactional
    public BasicResult materialReleaseInsert(Map<String, Object> values) {

        SysUserInfo sysUserInfo = UserInfoUtils.getInstance().getUserInfo();

        String companyId = sysUserInfo.getCompanyId();

        String userId = sysUserInfo.getUserId();

        Date date = new Date();
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String format1 = format.format(date);

        values.put("materialReleaseTime",format1);
        values.put("companyId",companyId);
        values.put("createUser",userId);
        values.put("materialReleaseId","");
        materialReleaseMappper.materialReleaseInsert(values);


        List<Map<String,Object>> tReleaseData =  (List<Map<String,Object>>) values.get("releaseData");
        for (Map<String,Object> releaseData : tReleaseData){
            releaseData.put("materialReleaseId",values.get("materialReleaseId").toString());
            releaseData.put("releaseDataId","");
            materialReleaseMappper.releaseDataInsert(releaseData);
        }
        return BasicResult.success();
    }

    @Override
    public BasicResult dictList() {
        List<DicetName> dictList = weighMapper.dictList();
        return BasicResult.success(dictList);
    }

    @Override
    public BasicResult materialReleaseList(HashMap<String, Object> values) {
        Integer pageSize = Integer.valueOf(values.get("pageSize").toString());
        Integer pageNum = Integer.valueOf(values.get("pageNum").toString());
        PageHelper.startPage(pageNum,pageSize);
        List<TMaterialRelease> materialReleases = materialReleaseMappper.materialReleaseList(values);
        for (TMaterialRelease materialRelease : materialReleases){
            List<TReleaseData> tReleaseData = materialReleaseMappper.materialDataList(materialRelease.getMaterialReleaseId());
            DecimalFormat df = new DecimalFormat("#.####");
            tReleaseData.stream().forEach(tReleaseData1 -> {
                if(tReleaseData1.getReleaseData()!=null && tReleaseData1.getReleaseData()>0){
                    String formattedNumber = df.format(tReleaseData1.getReleaseData());
                    tReleaseData1.setReleaseData(Double.valueOf(formattedNumber));
                }
            });
           if(materialRelease.getQuantity()!=null){
               String formattedNumber = df.format(materialRelease.getQuantity());
               materialRelease.setQuantity(Double.valueOf(formattedNumber));
           }
            materialRelease.setTReleaseData(tReleaseData);
        }
        PageInfo<TMaterialRelease> tMaterialReleasePageInfo = new PageInfo<>(materialReleases);
        return BasicResult.success(tMaterialReleasePageInfo);
    }

    @Override
    @Transactional
    public BasicResult materialReleaseUpdate(Map<String, Object> values) {

        materialReleaseMappper.materialReleaseUpdate(values);

        materialReleaseMappper.releaseDataDel(values.get("materialReleaseId").toString());


        List<Map<String,Object>> tReleaseData =  (List<Map<String,Object>>) values.get("releaseData");
        for (Map<String,Object> releaseData : tReleaseData){
            releaseData.put("materialReleaseId",values.get("materialReleaseId").toString());
            releaseData.put("releaseDataId","");
            materialReleaseMappper.releaseDataInsert(releaseData);
        }
        return BasicResult.success();
    }

    @Override
    @Transactional
    public BasicResult materialReleaseDel(String materialReleaseId) {
        materialReleaseMappper.materialReleaseDel(materialReleaseId);
        return BasicResult.success();
    }

    @Override
    public BasicResult materialReleaseExcel(HashMap<String, Object> values, HttpServletResponse response) throws FileNotFoundException {

        List<TMaterialRelease> materialReleases = materialReleaseMappper.materialReleaseList(values);
        for (TMaterialRelease materialRelease : materialReleases){
            List<TReleaseData> tReleaseData = materialReleaseMappper.materialDataList(materialRelease.getMaterialReleaseId());
            materialRelease.setTReleaseData(tReleaseData);
        }

        XSSFWorkbook book = new XSSFWorkbook();
        XSSFSheet sheet = book.createSheet();
        XSSFRow row1 = sheet.createRow(0);



        List<DicetName> dictList = weighMapper.dictList();
        if(materialReleases.size()>0&&dictList.size()>0){


        // 创建一个合并单元格区域，从A1到D1
        CellRangeAddress mergedRegion = new CellRangeAddress(0, 1, 0, 0);
        CellRangeAddress mergedRegion1 = new CellRangeAddress(0, 1, 1, 1);
        sheet.addMergedRegion(mergedRegion);
        sheet.addMergedRegion(mergedRegion1);
        row1.createCell(0).setCellValue("时间");
        row1.createCell(1).setCellValue("方量");

        CellRangeAddress mergedRegionD1 = new CellRangeAddress(0, 0, 2, 1+dictList.size());
        CellRangeAddress mergedRegionD2 = new CellRangeAddress(0, 0, 2+dictList.size(), 1+dictList.size()+dictList.size());
        sheet.addMergedRegion(mergedRegionD1);
        sheet.addMergedRegion(mergedRegionD2);
        row1.createCell(2).setCellValue("理论配比（kg/m³）");
        row1.createCell(2+dictList.size()).setCellValue("实际消耗（kg/m³）");

        for (int i=0 ; i<materialReleases.size();i++){
            XSSFRow row = sheet.createRow(2+i);
            row.createCell(0).setCellValue(materialReleases.get(i).getMaterialReleaseTime());
            row.createCell(1).setCellValue(materialReleases.get(i).getQuantity());
            XSSFRow row2 = sheet.createRow(1);
            for (int d =0 ; d<dictList.size();d++){
                row2.createCell(2+d).setCellValue(dictList.get(d).getDictName());
                for (TReleaseData tReleaseData : materialReleases.get(i).getTReleaseData()){
                    if(dictList.get(d).getDictId().equals(tReleaseData.getDictId())&&tReleaseData.getReleaseType()==1){
                        row.createCell(2+d).setCellValue(tReleaseData.getReleaseData());
                    }
                }
            }

            for (int d =0 ; d<dictList.size();d++){
                row2.createCell(2+dictList.size()+d).setCellValue(dictList.get(d).getDictName());
                for (TReleaseData tReleaseData : materialReleases.get(i).getTReleaseData()){
                    if(dictList.get(d).getDictId().equals(tReleaseData.getDictId())&&tReleaseData.getReleaseType()==2){
                        row.createCell(2+d+dictList.size()).setCellValue(tReleaseData.getReleaseData());
                    }
                }
            }
        }
            //FileOutputStream fos = new FileOutputStream("D:/test2/hannah.xls");
        response.setContentType("application/vnd.ms-excel;charset=UTF-8");
        response.setHeader("Content-Disposition", "attachment;filename=test.xls");
        OutputStream out = null;
            try {
                out = response.getOutputStream();
                book.write(out);
               // book.write(fos);
                out.close();
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                //IOUtils.closeQuietly(out);
            }
        }else {
            return BasicResult.success("数据为空");
        }
        return null;
    }

    @Override
    public BasicResult materialRew(HashMap<String, Object> values) {
        Integer pageSize = Integer.valueOf(values.get("pageSize").toString());
        Integer pageNum = Integer.valueOf(values.get("pageNum").toString());
        PageHelper.startPage(pageNum,pageSize);
        List<PieceDto> pieceDtos =  materialReleaseMappper.pieceList(values);
        for (PieceDto pieceDto : pieceDtos){
            List<TRawMaterial> rawMaterials = materialReleaseMappper.materialRew(pieceDto.getById(),pieceDto.getTypes());
            pieceDto.setRawMaterials(rawMaterials);
        }
        PageInfo<PieceDto> pieceDtoPageInfo = new PageInfo<>(pieceDtos);
        return BasicResult.success(pieceDtoPageInfo);
    }

    @Override
    public BasicResult mixingInsert(HashMap<String, Object> values) {
        List<Map<String,Object>> mixingList = (List<Map<String,Object>>) values.get("mixingList");
        for (Map<String,Object> mixing : mixingList){
            materialReleaseMappper.mixingUpdateType(mixing.get("siloId").toString());
            mixing.put("types",1);
            mixing.put("mixingId","");
            mixing.put("stata",2);
            materialReleaseMappper.mixingInsert(mixing);
        }
        return BasicResult.success();
    }

    @Override
    public BasicResult mixingList(HashMap<String, Object> values) {
//        Integer pageSize = Integer.valueOf(values.get("pageSize").toString());
//        Integer pageNum = Integer.valueOf(values.get("pageNum").toString());
//        PageHelper.startPage(pageNum,pageSize);
        List<TMixing> mixings = materialReleaseMappper.mixingList(values);
        //PageInfo<TMixing> tMixingPageInfo = new PageInfo<>(mixings);
        return BasicResult.success(mixings);
    }

    @Override
    public BasicResult siloList(Integer types) {
        List<TSilo> tSilos = materialReleaseMappper.siloList(types);
        for (TSilo silo :tSilos){
            TMixing mixings = materialReleaseMappper.mixingLists(silo.getSiloId());
            silo.setMixing(mixings);
        }
        return BasicResult.success(tSilos);
    }

    @Override
    @Transactional
    public BasicResult mixingConsumeIn(Map<String, Object> values) {
//        values.put("mixingSignboardId","");
//        materialReleaseMappper.mixingConsumeIn(values);
        String mixingSignboardId = values.get("mixingSignboardId").toString();
        Integer star = materialReleaseMappper.starInt();
        List<Map<String,Object>> mixingConsumes = (List<Map<String,Object>>) values.get("mixingConsume");
        for (Map<String,Object> mixingConsume :mixingConsumes){
            mixingConsume.put("mixingSignboardId",mixingSignboardId);
            if(star!=null){
                mixingConsume.put("star",star+1);
            }else {
                mixingConsume.put("star",1);
            }
            //mixingConsume.put("mixingConsumeId","");
            materialReleaseMappper.mixingConsumeInTwo(mixingConsume);
        }
        return BasicResult.success();
    }

    @Override
    public BasicResult mixingConsumeList(Map<String, Object> values) {
        Integer pageSize = Integer.valueOf(values.get("pageSize").toString());
        Integer pageNum = Integer.valueOf(values.get("pageNum").toString());
        PageHelper.startPage(pageNum,pageSize);
        List<TMixingSignboard> mixingSignboards = materialReleaseMappper.mixingSignboardList(values);
        for (TMixingSignboard mixingSignboard : mixingSignboards){
            Integer star = materialReleaseMappper.starIntSig(mixingSignboard.getMixingSignboardId());
            //values.put("")
            List<TMixingConsume> mixingConsumes = materialReleaseMappper.mixingConsumes(mixingSignboard.getMixingSignboardId(),star);
            mixingSignboard.setTMixingConsumes(mixingConsumes);
        }
        PageInfo<TMixingSignboard> tMixingSignboardPageInfo = new PageInfo<>(mixingSignboards);
        return BasicResult.success(tMixingSignboardPageInfo);
    }

    @Override
    public BasicResult mixingConsumePull() {
        List<TMixingSignboard> mixingSignboards = materialReleaseMappper.mixingConsumePull();
        return BasicResult.success(mixingSignboards);
    }

    @Override
    public BasicResult siloPull() {
        List<TSilo> silos = materialReleaseMappper.siloPull();
        return BasicResult.success(silos);
    }

    @Override
    public BasicResult siloMixingList(Map<String, Object> values) {
        List<TMixing> tMixings =  materialReleaseMappper.siloMixingList(values);
        return BasicResult.success(tMixings);
    }

    @Override
    public BasicResult mixingUpdate(HashMap<String, Object> values) {
        List<Map<String,Object>> mixingList = (List<Map<String,Object>>) values.get("mixingList");
        for (Map<String,Object> mixing : mixingList){
            materialReleaseMappper.mixingUpdate(mixing);
        }
        return BasicResult.success();
    }

    @Override
    public BasicResult mixingDel(HashMap<String, Object> values) {
        List<String> mixingList = (List<String>) values.get("mixingIds");
        for (String mixingId : mixingList){
            materialReleaseMappper.mixingDel(mixingId);
        }
        return BasicResult.success();
    }

    @Override
    public BasicResult mixingConsumeUp(Map<String, Object> values) {
        String mixingSignboardId = values.get("mixingSignboardId").toString();
        Integer star = materialReleaseMappper.starInt();
        materialReleaseMappper.mixingConsumeDelSign(mixingSignboardId,star);
        List<Map<String,Object>> mixingConsumes = (List<Map<String,Object>>) values.get("mixingConsume");
        for (Map<String,Object> mixingConsume :mixingConsumes){
            mixingConsume.put("mixingSignboardId",mixingSignboardId);
            mixingConsume.put("star",star);
            //mixingConsume.put("mixingConsumeId","");
            materialReleaseMappper.mixingConsumeInTwo(mixingConsume);
        }
        return BasicResult.success();
    }

    @Override
    public BasicResult mixingConsumeDel(HashMap<String, Object> values) {
        Integer star = Integer.valueOf(values.get("star").toString());
        List<String> mixingConsumeIds = (List<String>) values.get("mixingConsumeIds");
        for (String mixingConsumeId : mixingConsumeIds){
            materialReleaseMappper.mixingConsumeDel(mixingConsumeId,star);
        }
        return BasicResult.success();
    }
}