package com.dy.pmsPlatform.product;

import cn.hutool.core.codec.Base64;
import com.alibaba.excel.util.StringUtils;
import com.dy.common.webUtil.QueryResultVo;
import com.dy.pmsGlobal.daoOth.OthFileMapper;
import com.dy.pmsGlobal.daoPlt.PltProParamsMapper;
import com.dy.pmsGlobal.daoPlt.PltProductFileMapper;
import com.dy.pmsGlobal.daoPlt.PltProductMapper;
import com.dy.pmsGlobal.daoPlt.PltProductQualityInspectionItemsMapper;
import com.dy.pmsGlobal.dyFile.FileOperate;
import com.dy.pmsGlobal.dyFile.FileRestVo;
import com.dy.pmsGlobal.pojoOth.OthFile;
import com.dy.pmsGlobal.pojoPlt.PltProduct;
import com.dy.pmsGlobal.pojoPlt.PltProductFile;
import com.dy.pmsGlobal.util.QrCodeUtil;
import com.google.zxing.WriterException;
import jakarta.servlet.http.HttpServletResponse;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.dubbo.common.utils.PojoUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.dao.DuplicateKeyException;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.io.IOException;
import java.util.List;
import java.util.Map;
import java.util.stream.Stream;

@Slf4j
@Service
public class ProductSv {
    private PltProductMapper dao;
    private PltProductFileMapper pfDao;

    private FileOperate fileOperate;
    private OthFileMapper othFileMapper;
    private PltProductQualityInspectionItemsMapper itemDao;
    private PltProParamsMapper paramDao;

    @Value("${dy.webFile.fmUrl}")
    private String fmUrl ;

    private static final String DEFAULT_CODE = "001";
    private static final String CODE_FORMAT = "%03d";

    @Autowired
    public void setFileOperate(FileOperate fileOperate){
        this.fileOperate = fileOperate;
    }
    @Autowired
    public void setOthFileMapper(OthFileMapper othFileMapper){
        this.othFileMapper = othFileMapper;
    }

    @Autowired
    public void setDao(PltProductMapper dao) {
        this.dao = dao;
    }
    @Autowired
    public void setPfDao(PltProductFileMapper pfDao) {
        this.pfDao = pfDao;
    }
    @Autowired
    public void setItemDao(PltProductQualityInspectionItemsMapper itemDao) {
        this.itemDao = itemDao;
    }
    @Autowired
    public void setParamDao(PltProParamsMapper paramDao) {
        this.paramDao = paramDao;
    }


    @Transactional
    public int save(PltProduct p) {
        //判断产品 名称和型号 不能重名
        if (dao.exists(p.name.trim(), p.type.trim() ,p.id)) {
            throw new RuntimeException("已经存在相同的产品名称&型号");
        }
        int flag=0;
        do {
            p.code = getNextCode();
            try {
                int count = dao.insertSelective(p);
                if (count > 0) {
                    saveProRel(p);
                    return count;
                }
            } catch (DuplicateKeyException e) {
                // 如果出现唯一约束违反异常，尝试获取新的code并重试
                log.warn("插入产品时遇到唯一约束异常，尝试获取新的code", e);
            }
            flag++;
        } while (flag<5);
        return 0;
    }
    private String getNextCode(){
        log.info("获取产品编号");
        String maxCode = dao.selectMaxCode();
        if (StringUtils.isBlank(maxCode)) {
            return DEFAULT_CODE;
        } else {
            int nextCode = Integer.parseInt(maxCode) + 1;
            // 检查溢出
            if (nextCode > 999) {
                throw new RuntimeException("产品编号溢出");
            }
            return String.format(CODE_FORMAT, nextCode);
        }
    }

    @Transactional
    public int update(PltProduct p) {
        if (dao.exists(p.name.trim(), p.type.trim(),p.id)) {
            throw new RuntimeException("已经存在相同的产品名称&型号");
        }
        int count = dao.updateByPrimaryKeySelective(p);
        //删除旧数据,重新插入
        pfDao.deleteByProId(p.id);
        saveProRel(p);
        return count;
    }


    private void saveProRel(PltProduct p) {
        p.params.forEach(param->{
            param.proId=p.id;
            if(param.id !=null){
                paramDao.updateByPrimaryKeySelective(param);
            }else{
                param.deleted=false;
                paramDao.insert(param);
            }
        });
        saveRel(p, p.proFiles);
    }

    private void saveRel(PltProduct p, List<PltProductFile> docs) {
        docs.forEach(doc -> {
            doc.proId = p.id;
            pfDao.insertSelective(doc);
        });
    }



    /**
     * 逻辑删除实体
     * @param id 实体ID
     * @return 影响记录数量
     */
    @Transactional
    public int delete(Long id) {
        return dao.deleteLogicById(id);
    }

    public PltProduct selectById(String proId) {
        PltProduct pro=dao.selectByPrimaryKey(Long.valueOf(proId));
        pro=addWebUrl(pro);
        return pro;
    }

    private PltProduct addWebUrl(PltProduct pro) {
        if (pro != null) {
            if (pro.image != null) {
                String filePathWithWebUrl = getFilePathWithWebUrl(pro.image);
                pro.imageWebPath = filePathWithWebUrl;
                pro.imageWebPathZip = fileOperate.getImgFileZipPath(filePathWithWebUrl);
            }

            pro.proFiles.stream().forEach(doc -> {
                 OthFile file = othFileMapper.selectByPrimaryKey(doc.fileId);
                 if (file == null) {
                     return;
                 }
                 FileRestVo fileRestVo = fileOperate.parseHashcode(fmUrl, file.hash);
                 doc.webUrl = fileRestVo.fileWebDownloadPath + doc.fileId;
                 doc.orgName = file.orgName;
                 doc.extName = file.extName;
             });
        }
        return pro;
    }

    private String getFilePathWithWebUrl(Long fileId) {
        OthFile file = othFileMapper.selectByPrimaryKey(fileId);
        FileRestVo fileRestVo = fileOperate.parseHashcode(fmUrl, file.hash);
        return fileRestVo.fileWebUrl + file.filePath;
    }


    /**
     * 获取产品列表
     */
    public QueryResultVo<List<PltProduct>> selectSome(QueryVo queryVo) {
        Map<String, Object> params = (Map<String, Object>) PojoUtils.generalize(queryVo);
        //查询符合条件的记录总数
        Long itemTotal = dao.selectSomeCount(params);
        QueryResultVo<List<PltProduct>> rsVo = new QueryResultVo<>(queryVo.pageSize, queryVo.pageCurr) ;
        //计算分页等信息
        rsVo.calculateAndSet(itemTotal, params);
        //查询符合条件的记录
        rsVo.obj = dao.selectSome(params) ;
        if(CollectionUtils.isNotEmpty(rsVo.obj)){
            rsVo.obj.parallelStream().forEach(item->{
                try {
                    byte[] codes = QrCodeUtil.genQrCode(item.code);
                    item.qrCode = "data:image/jpeg;base64," + Base64.encode(codes);
                    item = addWebUrl(item);
                } catch (IOException e) {
                    log.error("IOException:",e);
                } catch (WriterException e) {
                    log.error("WriterException:",e);
                }
            });
        }
        return rsVo ;
    }

//    /**
//     * 添加产品文档关联
//     * @param proId 产品id
//     * @param fileId 文档id
//     * @return 更新数量
//     */
//    public int addDoc(long proId,long fileId,String fileType){
//        PltProductFile pf=new PltProductFile();
//        pf.fileId = fileId;
//        pf.proId = proId;
//        pf.fileType = fileType;
//        return pfDao.insertSelective(pf);
//    }

//    /**
//     * 查询产品关联文档
//     * @param proId 产品id
//     * @return 返回关联文档集合
//     */
//    public List<OthFile> selectDoc(long proId){
//        return othFileMapper.selectByProId(proId);
//    }


    public List<PltProduct> selectAll(QueryVo queryVo) {
        Map<String, Object> params = (Map<String, Object>) PojoUtils.generalize(queryVo);
        return dao.selectAll(params);
    }
    public List<PltProduct> getProduct(Long orderId) {
        return dao.selectByOrderId(orderId);
    }

//    public void downloadDoc(HttpServletResponse response) {
//        PltProduct pro=dao.selectByPrimaryKey(Long.valueOf(1));
//    }
}