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

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import java.util.stream.Collectors;
import java.util.stream.Stream;

import org.apache.commons.io.FileUtils;
import org.apache.commons.lang3.StringUtils;
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;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.IdWorker;
import com.google.common.collect.Lists;
import com.qianwen.core.log.exception.ServiceException;
import com.qianwen.core.mp.base.BaseServiceImpl;
import com.qianwen.core.oss.model.BladeFile;
import com.qianwen.core.tool.utils.Func;
import com.qianwen.core.tool.utils.SpringUtil;
import com.qianwen.smartman.common.utils.Lambda;
import com.qianwen.smartman.modules.resource.builder.oss.OssBuilder;
import com.qianwen.smartman.modules.visual.convert.VisualCompConvert;
import com.qianwen.smartman.modules.visual.dto.VisualCompCreatedDTO;
import com.qianwen.smartman.modules.visual.entity.VisualComp;
import com.qianwen.smartman.modules.visual.entity.VisualCompType;
import com.qianwen.smartman.modules.visual.mapper.VisualCompMapper;
import com.qianwen.smartman.modules.visual.service.IVisualCompService;
import com.qianwen.smartman.modules.visual.service.IVisualCompTypeService;
import com.qianwen.smartman.modules.visual.utils.VisualUtils;
import com.qianwen.smartman.modules.visual.vo.VisualCompVO;

import cn.hutool.core.util.ZipUtil;

@Service
/* loaded from: blade-api.jar:BOOT-INF/classes/org/springblade/modules/visual/service/impl/VisualCompServiceImpl.class */
public class VisualCompServiceImpl extends BaseServiceImpl<VisualCompMapper, VisualComp> implements IVisualCompService {
    @Autowired
    @Lazy
    private IVisualCompTypeService visualCompTypeService;


    @Override // org.springblade.modules.visual.service.IVisualCompService
    public IPage<VisualCompVO> pageVO(IPage<VisualComp> page, Map<String, Object> map) {
        String nameStr = (String) map.get("name");
        String typeStr = (String) map.get("type");
        List<String> typeList = null;
        if (StringUtils.isNotEmpty(typeStr)) {
            VisualCompType type = (VisualCompType) this.visualCompTypeService.getOne(Lambda.eq((v0) -> {
                return v0.getType();
            }, typeStr));
            if (type.getParentId().longValue() == 0L) {
	            typeList = (List<String>)this.visualCompTypeService.list(Lambda.eq(VisualCompType::getParentId, type.getId()).select(VisualCompType::getType ))
	            		.stream().map(VisualCompType::getType).collect(Collectors.toList());
            }else {
            	typeList = Lists.newArrayList(new String[] { typeStr });
            }
            /*
            typeList = type.getParentId().longValue() == 0 ? (List) this.visualCompTypeService.list(Lambda.eq((v0) -> {
                return v0.getParentId();
            }, type.getId()).select((v0) -> {
                return v0.getType();
            })).stream().map((v0) -> {
                return v0.getType();
            }).collect(Collectors.toList()) : Lists.newArrayList(new String[]{typeStr});*/
        }
        IPage<VisualComp> visualCompIPage = page(page, Lambda.like(Func.isNotEmpty(nameStr), VisualComp::getName, nameStr)
                
                .in((typeList != null && !typeList.isEmpty()), VisualComp::getType, typeList));
        /*
        IPage<VisualComp> visualCompIPage = page(page, Lambda.like(Func.isNotEmpty(nameStr), (v0) -> {
            return v0.getName();
        }, nameStr).in((typeList == null || typeList.isEmpty()) ? false : true, (v0) -> {
            return v0.getType();
        }, typeList));*/
        IPage<VisualCompVO> convert = VisualCompConvert.INSTANCE.convert(visualCompIPage);
        wrapper(convert.getRecords());
        return convert;
    }

    @Override // org.springblade.modules.visual.service.IVisualCompService
    public void wrapper(List<VisualCompVO> voList) {
        List<VisualCompType> typeList = this.visualCompTypeService.list(Lambda.ne((v0) -> {
            return v0.getParentId();
        }, 0));
        voList.parallelStream().forEach(item -> {
            VisualCompType visualCompType = (VisualCompType) typeList.stream().filter(type -> {
                return item.getType().equals(type.getType());
            }).findFirst().orElse(null);
            item.setTypeName((String) Optional.ofNullable(visualCompType).map((v0) -> {
                return v0.getName();
            }).orElse(null));
        });
    }

    @Override // org.springblade.modules.visual.service.IVisualCompService
    public BladeFile componentZipDownload(List<Long> componentIds) {
    	
    	List<String> jsonTexts = list(Lambda.<VisualComp>in((componentIds != null && componentIds.size() != 0), VisualComp::getId, componentIds))
    			.stream().map(VisualCompConvert.INSTANCE::convertDTO).map(JSON::toJSONString).collect(Collectors.toList());
    	File zipFile = VisualUtils.visualDownload(jsonTexts.<String>toArray(new String[0]));
        try {
			return ((OssBuilder)SpringUtil.getBean(OssBuilder.class)).tempTemplate().putFile(zipFile.getName(), new FileInputStream(zipFile));
		} catch (FileNotFoundException e) {
			log.error("组件下载zip文件错误",e);
			throw new ServiceException("组件下载zip文件错误"+e.getMessage());
		}
        /*
        boolean z;
        if (componentIds != null) {
            if (componentIds.size() != 0) {
                z = true;
                Stream stream = list(Lambda.in(z, (v0) -> {
                    return v0.getId();
                }, componentIds)).stream();
                VisualCompConvert visualCompConvert = VisualCompConvert.INSTANCE;
                visualCompConvert.getClass();
                List<String> jsonTexts = (List) stream.map(this::convertDTO).map((v0) -> {
                    return JSON.toJSONString(v0);
                }).collect(Collectors.toList());
                File zipFile = VisualUtils.visualDownload((String[]) jsonTexts.toArray(new String[0]));
                return ((OssBuilder) SpringUtil.getBean(OssBuilder.class)).tempTemplate().putFile(zipFile.getName(), new FileInputStream(zipFile));
            }
        }
        z = false;
        Stream stream2 = list(Lambda.in(z, (v0) -> {
            return v0.getId();
        }, componentIds)).stream();
        VisualCompConvert visualCompConvert2 = VisualCompConvert.INSTANCE;
        visualCompConvert2.getClass();
        List<String> jsonTexts2 = (List) stream2.map(this::convertDTO).map((v0) -> {
            return JSON.toJSONString(v0);
        }).collect(Collectors.toList());
        File zipFile2 = VisualUtils.visualDownload((String[]) jsonTexts2.toArray(new String[0]));
        return ((OssBuilder) SpringUtil.getBean(OssBuilder.class)).tempTemplate().putFile(zipFile2.getName(), new FileInputStream(zipFile2));
        */
    }

    @Override // org.springblade.modules.visual.service.IVisualCompService
    public void componentZipImport(MultipartFile zipFile) throws Exception {
        File localZipFile = new File("static/visual/" + IdWorker.get32UUID() + ".zip");
        FileUtils.copyToFile(zipFile.getInputStream(), localZipFile);
        componentZipImport(localZipFile);
    }

    @Override // org.springblade.modules.visual.service.IVisualCompService
    public void componentZipImport(File localZipFile) {
        File unzipFile = ZipUtil.unzip(localZipFile);
        File[] files = unzipFile.listFiles();
        String[] replaceText = VisualUtils.visualFileUpload(files);
        save(replaceText);
    }

    @Transactional
    public void save(String... replaceText) {
    	List<VisualComp> compList = Stream.<String>of(replaceText).map(text -> JSONObject.parseObject(text, VisualCompCreatedDTO.class)).map(dto -> {
            VisualCompType type = (VisualCompType)this.visualCompTypeService.getOne(Lambda.eq(VisualCompType::getType, dto.getType()));
            dto.setType((type == null) ? "ungrouped" : type.getType());
            return dto;
          }).map(VisualCompConvert.INSTANCE::convert).collect(Collectors.toList());
    	/*
        Stream map = Stream.of((Object[]) replaceText).map(text -> {
            return (VisualCompCreatedDTO) JSONObject.parseObject(text, VisualCompCreatedDTO.class);
        }).map(dto -> {
            VisualCompType type = (VisualCompType) this.visualCompTypeService.getOne(Lambda.eq((v0) -> {
                return v0.getType();
            }, dto.getType()));
            dto.setType(type == null ? "ungrouped" : type.getType());
            return dto;
        });
        VisualCompConvert visualCompConvert = VisualCompConvert.INSTANCE;
        visualCompConvert.getClass();
        List<VisualComp> compList = (List) map.map(this::convert).collect(Collectors.toList());*/
        visualSaveOrUpdateBatch(compList);
    }

    private void visualSaveOrUpdateBatch(List<VisualComp> upList) {
        List<VisualComp> list = list();
        Map<String, List<VisualComp>> existComp = list.stream().collect(Collectors.groupingBy(item -> {
            return item.getName() + item.getType();
        }));
        if (Func.isEmpty(existComp)) {
            saveBatch(upList);
            return;
        }
        Set<VisualComp> addList = new HashSet<>();
        upList.forEach(item2 -> {
            List<VisualComp> visualComps = existComp.get(item2.getName() + item2.getType());
            Optional.ofNullable(visualComps).ifPresent(compList -> {
                compList.forEach(comp -> {
                    comp.setComponent(item2.getComponent());
                    comp.setUrl(item2.getUrl());
                    comp.setOrderNum(item2.getOrderNum());
                    comp.setStatus(item2.getStatus());
                    comp.setIsDeleted(item2.getIsDeleted());
                    comp.setCreateUser(item2.getCreateUser());
                    comp.setIsDeleted(item2.getIsDeleted());
                    updateById(comp);
                });
            });
            if (!existComp.containsKey(item2.getName() + item2.getType())) {
                addList.add(item2);
            }
        });
        saveBatch(addList);
    }
}