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

import java.util.Collection;
import java.util.Comparator;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import java.util.stream.Collectors;

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 com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.google.common.collect.Lists;
import com.google.common.collect.Sets;
import com.qianwen.core.log.exception.ServiceException;
import com.qianwen.core.mp.base.BaseServiceImpl;
import com.qianwen.core.mp.support.Condition;
import com.qianwen.core.mp.support.Query;
import com.qianwen.core.tool.utils.Func;
import com.qianwen.smartman.common.utils.MessageUtils;
import com.qianwen.smartman.modules.dnc.convert.DncArtBagConvert;
import com.qianwen.smartman.modules.dnc.entity.DncArtBag;
import com.qianwen.smartman.modules.dnc.entity.DncArtFile;
import com.qianwen.smartman.modules.dnc.entity.DncArtProduct;
import com.qianwen.smartman.modules.dnc.entity.DncProcessCatalogue;
import com.qianwen.smartman.modules.dnc.enums.BagProcessEnum;
import com.qianwen.smartman.modules.dnc.mapper.DncArtBagMapper;
import com.qianwen.smartman.modules.dnc.service.IDncArtBagService;
import com.qianwen.smartman.modules.dnc.service.IDncArtFileService;
import com.qianwen.smartman.modules.dnc.service.IDncArtProductService;
import com.qianwen.smartman.modules.dnc.service.IDncProcessCatalogueService;
import com.qianwen.smartman.modules.dnc.vo.BagProcessQueryVO;
import com.qianwen.smartman.modules.dnc.vo.DncArtBagSaveVO;
import com.qianwen.smartman.modules.dnc.vo.DncArtBagVO;

@Service
/* loaded from: blade-api.jar:BOOT-INF/classes/org/springblade/modules/dnc/service/impl/DncArtBagServiceImpl.class */
public class DncArtBagServiceImpl extends BaseServiceImpl<DncArtBagMapper, DncArtBag> implements IDncArtBagService {
    @Autowired
    private IDncProcessCatalogueService dncProcessCatalogueService;
    @Autowired
    @Lazy
    private IDncArtFileService dncArtFileService;
    @Autowired
    private IDncArtProductService dncArtProductService;

    @Override // org.springblade.modules.dnc.service.IDncArtBagService
    public DncArtBagVO save(DncArtBagSaveVO dncArtBagSaveVO) {
        check(dncArtBagSaveVO.getCatalogueId(), null, dncArtBagSaveVO.getCode(), dncArtBagSaveVO.getName());
        DncArtBag dncArtBag = DncArtBagConvert.INSTANCE.convert(dncArtBagSaveVO);
        save(dncArtBag);
        return DncArtBagConvert.INSTANCE.convert(dncArtBag);
    }

    @Override // org.springblade.modules.dnc.service.IDncArtBagService
    public DncArtBagVO updateName(Long id, String name) {
        DncArtBag dncArtBag = (DncArtBag) getById(id);
        dncArtBag.setName(name);
        check(dncArtBag.getCatalogueId(), dncArtBag.getId(), dncArtBag.getCode(), dncArtBag.getName());
        updateById(dncArtBag);
        return DncArtBagConvert.INSTANCE.convert(dncArtBag);
    }

    @Override // org.springblade.modules.dnc.service.IDncArtBagService
    public IPage<DncArtBagVO> page(IPage<DncArtBag> page, String catalogueId, String keyWord) {
    	IPage<DncArtBag> pages = page(page, Wrappers.<DncArtBag>lambdaQuery()
    	        .eq(DncArtBag::getCatalogueId, catalogueId)
    	        .and(Func.isNotEmpty(keyWord), wrapper -> wrapper.likeRight(DncArtBag::getCode, keyWord).or().likeRight(DncArtBag::getName, keyWord)));
    	
    	/*
        IPage<DncArtBag> pages = page(page, ((LambdaQueryWrapper) Wrappers.lambdaQuery().eq((v0) -> {
            return v0.getCatalogueId();
        }, catalogueId)).and(Func.isNotEmpty(keyWord), wrapper -> {
            LambdaQueryWrapper lambdaQueryWrapper = (LambdaQueryWrapper) ((LambdaQueryWrapper) ((LambdaQueryWrapper) wrapper.likeRight((v0) -> {
                return v0.getCode();
            }, keyWord)).or()).likeRight((v0) -> {
                return v0.getName();
            }, keyWord);
        }));
        */
        IPage<DncArtBagVO> dncArtBagVOIPage = DncArtBagConvert.INSTANCE.convert(pages);
        dncArtBagVOIPage.getRecords().forEach(dncArtBagVO -> {
            DncProcessCatalogue dncProcessCatalogue = (DncProcessCatalogue) this.dncProcessCatalogueService.getById(dncArtBagVO.getCatalogueId());
            String allPath = dncProcessCatalogue.getAllPath();
            String[] split = allPath.split("/");
            StringBuilder sourcePath = new StringBuilder();
            for (String s : split) {
                DncProcessCatalogue byId = (DncProcessCatalogue) this.dncProcessCatalogueService.getById(s);
                sourcePath.append("/").append(byId.getName());
            }
            String substring = sourcePath.append("/").append(dncArtBagVO.getName()).substring(1);
            dncArtBagVO.setSourcePath(substring);
        });
        return dncArtBagVOIPage;
    }

    @Override // org.springblade.modules.dnc.service.IDncArtBagService
    @Transactional(rollbackFor = {Exception.class})
    public boolean remove(List<String> ids) {
        removeByIds(Func.toLongList(ids));
        
        this.dncArtFileService.remove(Wrappers.<DncArtFile>lambdaQuery().in(DncArtFile::getArtBagId, ids));
        this.dncArtProductService.remove((Wrapper)Wrappers.<DncArtProduct>lambdaQuery().in(DncArtProduct::getArtBagId, ids));
        
        /*
        this.dncArtFileService.remove((Wrapper) Wrappers.lambdaQuery().in((v0) -> {
            return v0.getArtBagId();
        }, ids));
        this.dncArtProductService.remove((Wrapper) Wrappers.lambdaQuery().in((v0) -> {
            return v0.getArtBagId();
        }, ids));*/
        return true;
    }

    @Override // org.springblade.modules.dnc.service.IDncArtBagService
    public IPage<DncArtBagVO> curAndSubPage(Query query, String catalogueId) {
    	List<Long> cateIds = this.dncProcessCatalogueService.listObjs(Wrappers.<DncProcessCatalogue>lambdaQuery()
    	        .select( DncProcessCatalogue::getId ).like(DncProcessCatalogue::getAllPath, catalogueId)
    	        .eq(DncProcessCatalogue::getIsDeleted, 0), id -> Long.valueOf(Func.toLong(id.toString())));
    	
    	IPage<DncArtBag> pages = page(Condition.getPage(query), Wrappers.<DncArtBag>lambdaQuery()
    	        .in(DncArtBag::getCatalogueId, cateIds));
    	    
    	/*
        List<Long> cateIds = this.dncProcessCatalogueService.listObjs((Wrapper) ((LambdaQueryWrapper) Wrappers.lambdaQuery().select(new SFunction[]{(v0) -> {
            return v0.getId();
        }}).like((v0) -> {
            return v0.getAllPath();
        }, catalogueId)).eq((v0) -> {
            return v0.getIsDeleted();
        }, 0), id -> {
            return Long.valueOf(Func.toLong(id.toString()));
        });
        IPage<DncArtBag> pages = page(Condition.getPage(query), (Wrapper) Wrappers.lambdaQuery().in((v0) -> {
            return v0.getCatalogueId();
        }, cateIds));*/
        return DncArtBagConvert.INSTANCE.convert(pages);
    }

    @Override // org.springblade.modules.dnc.service.IDncArtBagService
    public IPage<DncArtBagVO> listBagProcess(BagProcessQueryVO vo) {
        BagProcessEnum type = vo.getType();
        String keyword = vo.getKeyword();
        Query query = vo.getQuery();
        if (Func.isBlank(keyword)) {
            return new Page<>(query.getCurrent().intValue(), query.getSize().intValue());
        }
        switch (type) {
            case BAG_OR_PROCESS:
                return bagOrProcessQuery(keyword, query);
            case ONLY_BAG:
                return onlyBagQuery(keyword, query);
            case ONLY_PROCESS:
                return onlyProcessQuery(keyword, query);
            default:
                return new Page<>(query.getCurrent().intValue(), query.getSize().intValue());
        }
    }

    @Override // org.springblade.modules.dnc.service.IDncArtBagService
    public DncArtBagVO detail(String id) {
        DncArtBag dncArtBag = (DncArtBag) getById(id);
        if (Func.isNull(dncArtBag)) {
            return new DncArtBagVO();
        }
        DncArtBagVO vo = DncArtBagConvert.INSTANCE.convert(dncArtBag);
        StringBuilder sb = getAllPath(dncArtBag.getCatalogueId());
        vo.setSourcePath(sb.toString());
        return vo;
    }

    private StringBuilder getAllPath(Long catalogueId) {
        DncProcessCatalogue dncProcessCatalogue = (DncProcessCatalogue) this.dncProcessCatalogueService.getById(catalogueId);
        String allPath = dncProcessCatalogue.getAllPath();
        String[] split = Func.split(allPath, "/");
        List<DncProcessCatalogue> catalogues = this.dncProcessCatalogueService.listByIds(Lists.newArrayList(split));
        Map<Long, DncProcessCatalogue> catalogueMap = catalogues.stream().collect(Collectors.toMap((v0) -> {
            return v0.getId();
        }, v -> {
            return v;
        }));
        StringBuilder sb = new StringBuilder();
        boolean flag = false;
        for (String s : split) {
            if (flag) {
                sb.append("/");
            }
            flag = true;
            DncProcessCatalogue catalogue = catalogueMap.get(Long.valueOf(Func.toLong(s)));
            Optional.ofNullable(catalogue).ifPresent(bag -> {
                sb.append(bag.getName());
            });
        }
        return sb;
    }

    private IPage<DncArtBagVO> bagOrProcessQuery(String keyword, Query query) {
        List<DncArtFile> artFiles = this.dncArtFileService.list( Wrappers.<DncArtFile>lambdaQuery().like(DncArtFile::getFilename, keyword));
        List<DncArtBag> list = list(Wrappers.<DncArtBag>lambdaQuery()
                .like(DncArtBag::getCode, keyword)
                .or()
                .like(DncArtBag::getName, keyword));
        /*
        List<DncArtBag> list = list((Wrapper) ((LambdaQueryWrapper) ((LambdaQueryWrapper) Wrappers.lambdaQuery().like((v0) -> {
            return v0.getCode();
        }, keyword)).or()).like((v0) -> {
            return v0.getName();
        }, keyword));*/
        List<Long> ids = list.stream().map((v0) -> {
            return v0.getId();
        }).collect(Collectors.toList());
        Collection<? extends Long> bagIds =  artFiles.stream().map((v0) -> {
            return v0.getArtBagId();
        }).collect(Collectors.toList());
        Set<Long> allIds = Sets.newHashSet(ids);
        allIds.addAll(bagIds);
        if (Func.isEmpty(allIds)) {
            return new Page<>(query.getCurrent().intValue(), query.getSize().intValue());
        }
        IPage<DncArtBag> page = page(Condition.getPage(query), Wrappers.<DncArtBag>lambdaQuery().in(DncArtBag::getId, allIds));
        
        page.getRecords().sort(Comparator.comparing(DncArtBag::getCreateTime).reversed());
        
        List<DncArtBagVO> convert = DncArtBagConvert.INSTANCE.convert(page.getRecords());
        Page<DncArtBagVO> page2 = new Page<>(page.getCurrent(), page.getSize(), page.getTotal());
        page2.setRecords(convert);
        return page2;
    }

    private IPage<DncArtBagVO> onlyBagQuery(String keyword, Query query) {
    	IPage<DncArtBag> page = page(Condition.getPage(query), Wrappers.<DncArtBag>lambdaQuery()
    	        .like(DncArtBag::getCode, keyword)
    	        .or()
    	        .like(DncArtBag::getName, keyword));
    	    page.getRecords().sort(Comparator.comparing(DncArtBag::getCreateTime).reversed());
    	    
    	/*
        IPage<DncArtBag> page = page(Condition.getPage(query), (Wrapper) ((LambdaQueryWrapper) ((LambdaQueryWrapper) Wrappers.lambdaQuery().like((v0) -> {
            return v0.getCode();
        }, keyword)).or()).like((v0) -> {
            return v0.getName();
        }, keyword));
        page.getRecords().sort(Comparator.comparing((v0) -> {
            return v0.getCreateTime();
        }).reversed());
        */
        List<DncArtBagVO> convert = DncArtBagConvert.INSTANCE.convert(page.getRecords());
        Page<DncArtBagVO> page2 = new Page<>(page.getCurrent(), page.getSize(), page.getTotal());
        page2.setRecords(convert);
        return page2;
    }

    private IPage<DncArtBagVO> onlyProcessQuery(String keyword, Query query) {
    	List<DncArtFile> artFiles = this.dncArtFileService.list(Wrappers.<DncArtFile>lambdaQuery()
    	        .like(DncArtFile::getFilename, keyword));
    	/*
        List<DncArtFile> artFiles = this.dncArtFileService.list((Wrapper) Wrappers.lambdaQuery().like((v0) -> {
            return v0.getFilename();
        }, keyword));*/
        if (Func.isEmpty(artFiles)) {
            return new Page<>(query.getCurrent().intValue(), query.getSize().intValue());
        }
        List<Long> bagIds = artFiles.stream().map((v0) -> {
            return v0.getArtBagId();
        }).collect(Collectors.toList());
        
        IPage<DncArtBag> page = page(Condition.getPage(query), Wrappers.<DncArtBag>lambdaQuery().in(DncArtBag::getId, bagIds));
        page.getRecords().sort(Comparator.comparing(DncArtBag::getCreateTime).reversed());
        /*
        IPage<DncArtBag> page = page(Condition.getPage(query), (Wrapper) Wrappers.lambdaQuery().in((v0) -> {
            return v0.getId();
        }, bagIds));
        page.getRecords().sort(Comparator.comparing((v0) -> {
            return v0.getCreateTime();
        }).reversed());*/
        List<DncArtBagVO> convert = DncArtBagConvert.INSTANCE.convert(page.getRecords());
        Page<DncArtBagVO> page2 = new Page<>(page.getCurrent(), page.getSize(), page.getTotal());
        page2.setRecords(convert);
        return page2;
    }

    private void check(Long catalogueId, Long id, String code, String name) {
    	long countCode = count(Wrappers.<DncArtBag>lambdaQuery()
    	        .eq(DncArtBag::getCatalogueId, catalogueId)
    	        .eq(DncArtBag::getCode, code)
    	        .ne(Func.isNotEmpty(id), DncArtBag::getId, id));
    	
        if (countCode > 0) {
            throw new ServiceException(MessageUtils.message("dnc.art.bag.code.already.exists", new Object[0]));
        }
        
        long countName = count(Wrappers.<DncArtBag>lambdaQuery()
                .eq(DncArtBag::getCatalogueId, catalogueId)
                .eq(DncArtBag::getName, name)
                .ne(Func.isNotEmpty(id), DncArtBag::getId, id));
        
        if (countName > 0) {
            throw new ServiceException(MessageUtils.message("dnc.art.bag.name.already.exists", new Object[0]));
        }
    }
}