package com.qianwen.smartman.modules.cps.service.impl;

import cn.hutool.core.lang.Snowflake;
import com.alibaba.excel.write.merge.AbstractMergeStrategy;
import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.google.common.collect.Lists;
import java.lang.invoke.SerializedLambda;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Random;
import java.util.function.Function;
import java.util.stream.Collectors;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.qianwen.smartman.common.constant.CommonGroupConstant;
import com.qianwen.smartman.common.constant.ExcelConstant;
import com.qianwen.smartman.common.constant.ToolingConstant;
import com.qianwen.smartman.common.enums.CommonGroupTypeEnum;
import com.qianwen.smartman.common.utils.MessageUtils;
import com.qianwen.core.excel.util.ExcelUtil;
import com.qianwen.core.mp.service.impl.BladeServiceImpl;
import com.qianwen.core.oss.model.BladeFile;
import com.qianwen.core.secure.utils.AuthUtil;
import com.qianwen.core.tool.support.Kv;
import com.qianwen.core.tool.utils.Func;
import com.qianwen.smartman.modules.cps.convert.TrayFixtureConvert;
import com.qianwen.smartman.modules.cps.dto.RemoveIdsDTO;
import com.qianwen.smartman.modules.cps.entity.CommonGroupOfItem;
import com.qianwen.smartman.modules.cps.entity.Fixture;
import com.qianwen.smartman.modules.cps.entity.Tray;
import com.qianwen.smartman.modules.cps.entity.TrayFixture;
import com.qianwen.smartman.modules.cps.entity.TraySurface;
import com.qianwen.smartman.modules.cps.excel.TrayFixtureImport;
import com.qianwen.smartman.modules.cps.mapper.TrayFixtureMapper;
import com.qianwen.smartman.modules.cps.service.ICommonGroupOfItemService;
import com.qianwen.smartman.modules.cps.service.IFixtureService;
import com.qianwen.smartman.modules.cps.service.ITrayFixtureService;
import com.qianwen.smartman.modules.cps.service.ITrayService;
import com.qianwen.smartman.modules.cps.service.ITraySurfaceService;
import com.qianwen.smartman.modules.cps.utils.StringUtils;
import com.qianwen.smartman.modules.cps.utils.ThrowFun;
import com.qianwen.smartman.modules.cps.vo.TrayFaceFixtureAddVO;
import com.qianwen.smartman.modules.cps.vo.TrayFaceFixtureVO;
import com.qianwen.smartman.modules.cps.vo.TrayFixRemoveVO;
import com.qianwen.smartman.modules.cps.vo.TrayFixtureVO;
import com.qianwen.smartman.modules.resource.builder.oss.OssBuilder;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.multipart.MultipartFile;

@Service

public class TrayFixtureServiceImpl extends BladeServiceImpl<TrayFixtureMapper, TrayFixture> implements ITrayFixtureService {
    private static final Logger log = LoggerFactory.getLogger(TrayFixtureServiceImpl.class);
    @Autowired
    @Lazy
    private IFixtureService fixtureService;
    @Autowired
    @Lazy
    private ITrayService trayService;
    @Autowired
    private OssBuilder ossBuilder;
    @Autowired
    @Lazy
    private ITraySurfaceService traySurfaceService;
    @Autowired
    private ICommonGroupOfItemService itemService;

    @Override // org.springblade.modules.cps.service.ITrayFixtureService
    public List<TrayFaceFixtureVO> listFixture(String faceId) {
        return this.baseMapper.listFixture(faceId);
    }

    @Override // org.springblade.modules.cps.service.ITrayFixtureService
    @Transactional(rollbackFor = {Exception.class})
    public List<TrayFixtureVO> addFaceFixture(TrayFaceFixtureAddVO vo) {
        List<Long> fixIds = vo.getFixIds();
        List<TrayFixture> fixtures = fixIds.stream().map(c -> {
            TrayFixture trayFixture = new TrayFixture();
            trayFixture.setTrayId(vo.getTrayId());
            trayFixture.setFaceId(vo.getFaceId());
            trayFixture.setFixId(c);
            return trayFixture;
        }).collect(Collectors.toList());
        saveBatch(fixtures);
        Tray tray = this.trayService.getById(vo.getTrayId());
        this.fixtureService.update(Wrappers.<Fixture>lambdaUpdate()
                .set(Fixture::getInUse, ToolingConstant.TOOLING_IN_USE)
                .set(Fixture::getFixtureStatus, tray.getAvailability())
                .in(Fixture::getId, fixIds));
        /*
        this.fixtureService.update((Wrapper) ((LambdaUpdateWrapper) ((LambdaUpdateWrapper) Wrappers.lambdaUpdate().set((v0) -> {
            return v0.getInUse();
        }, ToolingConstant.TOOLING_IN_USE)).set((v0) -> {
            return v0.getFixtureStatus();
        }, tray.getAvailability())).in((v0) -> {
            return v0.getId();
        }, fixIds));*/
        return TrayFixtureConvert.INSTANCE.convert(fixtures);
    }

    @Override // org.springblade.modules.cps.service.ITrayFixtureService
    public Boolean removeFaceFixture(TrayFixRemoveVO vo) {
        List<RemoveIdsDTO> ids = vo.getIds();
        if (Func.isEmpty(ids)) {
            return false;
        }
        List<Long> idList = Lists.newArrayList();
        List<Long> fixIds = Lists.newArrayList();
        ids.forEach(s -> {
            idList.add(s.getId());
            fixIds.add(s.getOthersId());
        });
        boolean remove = removeByIds(idList);
        
        boolean update = this.fixtureService.update(Wrappers.<Fixture>lambdaUpdate()
                .set(Fixture::getInUse, ToolingConstant.TOOLING_NOT_USE)
                .set(Fixture::getFixtureStatus, null)
                .in(Fixture::getId, fixIds));
        /*
        boolean update = this.fixtureService.update((Wrapper) ((LambdaUpdateWrapper) ((LambdaUpdateWrapper) Wrappers.lambdaUpdate().set((v0) -> {
            return v0.getInUse();
        }, ToolingConstant.TOOLING_NOT_USE)).set((v0) -> {
            return v0.getFixtureStatus();
        }, (Object) null)).in((v0) -> {
            return v0.getId();
        }, fixIds));
        */
        return Boolean.valueOf(remove && update);
    }

    @Override // org.springblade.modules.cps.service.ITrayFixtureService
    public void updateFixtureStatusByTray(List<Long> trayIds) {
        this.baseMapper.updateFixtureStatus(trayIds);
    }

    @Override // org.springblade.modules.cps.service.ITrayFixtureService
    @Transactional(rollbackFor = {Exception.class})
    public BladeFile importTrayFixture(MultipartFile file) {
        List<TrayFixtureImport> rawData = ExcelUtil.read(file, 0, 2, TrayFixtureImport.class);
        ThrowFun.isTrue(Func.isEmpty(rawData)).throwMessage(MessageUtils.message("excel.import.data.can.not.be.null", new Object[0]));
        ThrowFun.isTrue(rawData.size() > 200).throwMessage(MessageUtils.message("excel.import.size.failed", new Object[0]));
        Map<String, Tray> trayMap = Kv.newMap();
        List<Tray> needSaveTray = Lists.newArrayList();
        Map<String, Fixture> fixtureMap = Kv.newMap();
        List<Fixture> needSaveFixture = Lists.newArrayList();
        Map<String, TraySurface> trayFaceMap = Kv.newMap();
        List<TraySurface> needSaveFace = Lists.newArrayList();
        getTrayFixtureMap(rawData, trayMap, fixtureMap, trayFaceMap);
        List<TrayFixtureImport> failExcel = Lists.newArrayList();
        for (TrayFixtureImport data : rawData) {
            boolean validImport = validImport(data, failExcel, trayMap, needSaveTray, fixtureMap, needSaveFixture, trayFaceMap, needSaveFace);
            if (validImport) {
                break;
            }
        }
        if (Func.isNotEmpty(failExcel)) {
            return exportFailFile(failExcel);
        }
        if (Func.isNotEmpty(needSaveTray)) {
            Map<String, Tray> needSaveTrayMap = needSaveTray.stream().collect(Collectors.toMap((v0) -> {
                return v0.getCode();
            }, Function.identity(), (v1, v2) -> {
                return v1;
            }));
            Collection<Tray> trays = needSaveTrayMap.values();
            this.trayService.saveBatch(trays);
            List<CommonGroupOfItem> items = trays.stream().map(tray -> {
                return CommonGroupOfItem.builder().groupId(105L).itemId(tray.getId()).groupType(CommonGroupTypeEnum.TRAY.getName()).groupCategory(CommonGroupConstant.DEFAULT_CATEGORY).build();
            }).collect(Collectors.toList());
            this.itemService.saveBatch(items);
            trayMap.putAll(needSaveTrayMap);
        }
        if (Func.isNotEmpty(needSaveFace)) {
            Map<String, TraySurface> needSaveFaceMap = needSaveFace.stream().collect(Collectors.toMap(k -> {
                return StringUtils.getKey(k.getTrayId(), k.getCode());
            }, Function.identity(), (v12, v22) -> {
                return v12;
            }));
            this.traySurfaceService.saveBatch(needSaveFaceMap.values());
            trayFaceMap.putAll(needSaveFaceMap);
        }
        if (Func.isNotEmpty(needSaveFixture)) {
            Map<String, Fixture> needSaveFixtureMap = needSaveFixture.stream().collect(Collectors.toMap((v0) -> {
                return v0.getCode();
            }, Function.identity(), (v13, v23) -> {
                return v13;
            }));
            Collection<Fixture> fixtures = needSaveFixtureMap.values();
            this.fixtureService.saveBatch(fixtures);
            List<CommonGroupOfItem> items2 = fixtures.stream().map(fixture -> {
                return CommonGroupOfItem.builder().groupId(104L).itemId(fixture.getId()).groupCategory(CommonGroupConstant.DEFAULT_CATEGORY).groupType(CommonGroupTypeEnum.FIXTURE.getName()).build();
            }).collect(Collectors.toList());
            this.itemService.saveBatch(items2);
            fixtureMap.putAll(needSaveFixtureMap);
        }
        saveTrayFixture(rawData, trayMap, fixtureMap, trayFaceMap);
        return null;
    }

    private void saveTrayFixture(List<TrayFixtureImport> rawData, Map<String, Tray> trayMap, Map<String, Fixture> fixtureMap, Map<String, TraySurface> trayFaceMap) {
        List<TrayFixture> trayFixtureList = Lists.newArrayList();
        List<Fixture> fixtures = Lists.newArrayList();
        rawData.forEach(data -> {
            Tray tray = (Tray) trayMap.get(data.getTrayCode());
            TraySurface traySurface = (TraySurface) trayFaceMap.get(StringUtils.getKey(tray.getId(), data.getTrayFaceCode()));
            Fixture fixture = (Fixture) fixtureMap.get(data.getFixtureCode());
            if (!ToolingConstant.TOOLING_IN_USE.equals(fixture.getInUse())) {
                fixture.setInUse(ToolingConstant.TOOLING_IN_USE);
                fixture.setFixtureStatus(tray.getAvailability());
                fixtures.add(fixture);
                TrayFixture trayFixture = new TrayFixture().setTrayId(tray.getId()).setFixId(fixture.getId()).setFaceId(traySurface.getId());
                trayFixtureList.add(trayFixture);
            }
        });
        List<TrayFixture> trayFixtures = list();
        Map<String, TrayFixture> trayFixtureMap = trayFixtures.stream().collect(Collectors.toMap(k -> {
            return StringUtils.getKey(k.getTrayId(), k.getFaceId(), k.getFixId());
        }, v -> {
            return v;
        }));
        List<TrayFixture> list = trayFixtureList.stream().distinct().filter(c -> {
            return !trayFixtureMap.containsKey(StringUtils.getKey(c.getTrayId(), c.getFaceId(), c.getFixId()));
        }).collect(Collectors.toList());
        if (Func.isNotEmpty(list)) {
            saveBatch(list);
        }
        if (Func.isNotEmpty(fixtures)) {
            this.fixtureService.updateBatchById(fixtures);
        }
    }

    private boolean validImport(TrayFixtureImport data, List<TrayFixtureImport> failExcel, Map<String, Tray> trayMap, List<Tray> needSaveTray, Map<String, Fixture> fixtureMap, List<Fixture> needSaveFixture, Map<String, TraySurface> trayFaceMap, List<TraySurface> needSaveFace) {
        Snowflake snowflake = new Snowflake(new Random().nextInt(4) + 1, new Random().nextInt(4) + 1, true);
        String trayCode = data.getTrayCode();
        if (Func.isBlank(trayCode)) {
            data.setFailReason(MessageUtils.message("excel.export.tray.code.not.be.null", new Object[0]));
            failExcel.add(data);
            return true;
        }
        Tray tray = trayMap.get(trayCode);
        String trayName = data.getTrayName();
        if (Func.isEmpty(tray)) {
            String trayName2 = Func.isBlank(trayName) ? trayCode : trayName;
            Tray newTray = new Tray().setCode(trayCode).setName(trayName2).setTrayStatus(1).setInUse(0).setAvailability(1);
            newTray.setId(Long.valueOf(snowflake.nextId()));
            needSaveTray.add(newTray);
            int size = 0;
            for (Tray trays : needSaveTray) {
                String code = trays.getCode();
                String name = trays.getName();
                if (code.equals(trayCode) && !trayName2.equals(name)) {
                    size++;
                }
            }
            if (size > 0) {
                data.setFailReason(MessageUtils.message("excel.export.file.tray.code.name.system.exists", new Object[0]));
                failExcel.add(data);
                return true;
            }
            tray = newTray;
            tray.setId(newTray.getId());
        } else if (Func.isNotBlank(trayName) && !tray.getName().equals(trayName)) {
            data.setFailReason(MessageUtils.message("excel.export.tray.code.system.exists", new Object[0]));
            failExcel.add(data);
            return true;
        }
        String trayFaceCode = data.getTrayFaceCode();
        if (Func.isBlank(trayFaceCode)) {
            data.setFailReason(MessageUtils.message("excel.export.tray.face.code.not.be.null", new Object[0]));
            failExcel.add(data);
            return true;
        }
        TraySurface traySurface = trayFaceMap.get(StringUtils.getKey(tray.getId(), trayFaceCode));
        String trayFaceName = data.getTrayFaceName();
        if (Func.isEmpty(traySurface)) {
            String trayFaceName2 = Func.isBlank(trayFaceName) ? trayFaceCode : trayFaceName;
            TraySurface newFace = new TraySurface().setTrayId(tray.getId()).setCode(trayFaceCode).setName(trayFaceName2).setInUse(0);
            needSaveFace.add(newFace);
            int size2 = 0;
            for (TraySurface surface : needSaveFace) {
                String code2 = surface.getCode();
                String name2 = surface.getName();
                if (code2.equals(trayFaceCode) && !name2.equals(trayFaceName2)) {
                    size2++;
                }
            }
            if (size2 > 0) {
                data.setFailReason(MessageUtils.message("excel.export.file.tray.face.code.name.system.exists", new Object[0]));
                failExcel.add(data);
                return true;
            }
        } else if (Func.isNotBlank(trayFaceName) && !trayFaceName.equals(traySurface.getName())) {
            data.setFailReason(MessageUtils.message("excel.export.tray.face.code.excel.exists", new Object[0]));
            failExcel.add(data);
            return true;
        }
        String fixtureCode = data.getFixtureCode();
        if (Func.isBlank(fixtureCode)) {
            data.setFailReason(MessageUtils.message("excel.export.tray.fixture.code.not.be.null", new Object[0]));
            failExcel.add(data);
            return true;
        }
        Fixture fixture = fixtureMap.get(fixtureCode);
        String fixtureName = data.getFixtureName();
        if (Func.isEmpty(fixture)) {
            String fixtureName2 = Func.isBlank(fixtureName) ? fixtureCode : fixtureName;
            Fixture newFixture = new Fixture().setTenantId(AuthUtil.getTenantId()).setCode(fixtureCode).setName(Func.isBlank(fixtureName2) ? fixtureCode : fixtureName2).setFixtureStatus(1).setInUse(0);
            needSaveFixture.add(newFixture);
            int size3 = 0;
            for (Fixture fixtures : needSaveFixture) {
                String code3 = fixtures.getCode();
                String name3 = fixtures.getName();
                if (code3.equals(fixtureCode) && !name3.equals(fixtureName2)) {
                    size3++;
                }
            }
            if (size3 > 0) {
                data.setFailReason(MessageUtils.message("excel.export.file.fixture.code.name.system.exists", new Object[0]));
                failExcel.add(data);
                return true;
            }
            return false;
        } else if (Func.isNotBlank(fixtureName) && !fixtureName.equals(fixture.getName())) {
            data.setFailReason(MessageUtils.message("excel.export.tray.fixture.system.exists", new Object[0]));
            failExcel.add(data);
            return true;
        } else if (ToolingConstant.TOOLING_IN_USE.equals(fixture.getInUse())) {
            data.setFailReason(MessageUtils.message("excel.export.tray.fixture.in.use", new Object[0]));
            failExcel.add(data);
            return true;
        } else {
            return false;
        }
    }

    private BladeFile exportFailFile(List<TrayFixtureImport> failExcel) {
        MultipartFile multipartFile = ExcelUtil.exportFillTemplateToMultipartFile(ExcelConstant.DIRECTORY + "trayFixtureFailTemplate" + ExcelConstant.SUFFIX, MessageUtils.message("excel.import.failed.report.name", new Object[0]) + ExcelConstant.SUFFIX, ExcelConstant.SHEET, failExcel, (Object) null, (AbstractMergeStrategy) null);
        return this.ossBuilder.tempTemplate().putFile(multipartFile.getOriginalFilename(), multipartFile);
    }

    private void getTrayFixtureMap(List<TrayFixtureImport> rawData, Map<String, Tray> trayMap, Map<String, Fixture> fixtureMap, Map<String, TraySurface> surfaceMap) {
    	LambdaQueryWrapper<Tray> trayQuery = Wrappers.lambdaQuery();
    	//Wrapper lambdaQuery = Wrappers.lambdaQuery();
        
        
        
        LambdaQueryWrapper<Fixture> fixtureQuery = Wrappers.lambdaQuery();
       // Wrapper lambdaQuery2 = Wrappers.lambdaQuery();
        
        QueryWrapper<TrayFixtureImport> query = Wrappers.query();
        boolean flag1 = false;
        boolean flag2 = false;
        boolean flag3 = false;
        for (TrayFixtureImport data : rawData) {
            if (trayCodeNameRequired(data)) {
                if (flag1) {
                	trayQuery.or();
                }
                flag1 = true;
                trayQuery.eq((v0) -> {
                    return v0.getCode();
                }, data.getTrayCode());
            }
            if (fixtureCodeNameRequired(data)) {
                if (flag2) {
                	fixtureQuery.or();
                }
                flag2 = true;
                fixtureQuery.eq((v0) -> {
                    return v0.getCode();
                }, data.getFixtureCode());
            }
            if (trayFaceRequired(data)) {
                if (flag3) {
                    query.or();
                }
                flag3 = true;
                query.nested(i -> {
                    i.eq("bt.code", data.getTrayCode()).eq("bts.code", data.getTrayFaceCode());
                });
            }
        }
        String sqlSegment1 = trayQuery.getSqlSegment();
        if (Func.isNotEmpty(sqlSegment1)) {
            List<Tray> trays = this.trayService.list(trayQuery);
            if (Func.isNotEmpty(trays)) {
                trayMap.putAll(trays.stream().collect(Collectors.toMap((v0) -> {
                    return v0.getCode();
                }, v -> {
                    return v;
                })));
            }
        }
        String sqlSegment2 = fixtureQuery.getSqlSegment();
        if (Func.isNotEmpty(sqlSegment2)) {
            List<Fixture> fixtures = this.fixtureService.list(fixtureQuery);
            if (Func.isNotEmpty(fixtures)) {
                fixtureMap.putAll(fixtures.stream().collect(Collectors.toMap((v0) -> {
                    return v0.getCode();
                }, v2 -> {
                    return v2;
                })));
            }
        }
        String sqlSegment3 = query.getSqlSegment();
        if (Func.isNotEmpty(sqlSegment3)) {
            List<TraySurface> traySurfaces = this.traySurfaceService.listByTrayCodeName(query);
            if (Func.isNotEmpty(traySurfaces)) {
                surfaceMap.putAll(traySurfaces.stream().collect(Collectors.toMap(k -> {
                    return StringUtils.getKey(k.getTrayId(), k.getCode());
                }, v3 -> {
                    return v3;
                })));
            }
        }
    }

    private boolean trayCodeNameRequired(TrayFixtureImport dto) {
        return Func.isNotBlank(dto.getTrayCode());
    }

    private boolean fixtureCodeNameRequired(TrayFixtureImport dto) {
        return Func.isNotBlank(dto.getFixtureCode());
    }

    private boolean trayFaceRequired(TrayFixtureImport dto) {
        return trayCodeNameRequired(dto) && Func.isNotBlank(dto.getTrayFaceCode());
    }
}