package com.doumee.service.business.impl;

import com.alibaba.fastjson.JSON;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.doumee.biz.system.SystemDictDataBiz;
import com.doumee.core.annotation.excel.ExcelEmbeddedImageReader;
import com.doumee.core.annotation.excel.AsyncImportExcelSupport;
import com.doumee.core.annotation.excel.ExcelImporter;
import com.doumee.core.annotation.excel.RowEmbeddedImages;
import com.doumee.core.constants.ResponseStatus;
import com.doumee.core.exception.BusinessException;
import com.doumee.core.model.LoginUserInfo;
import com.doumee.core.model.PageData;
import com.doumee.core.model.PageWrap;
import com.doumee.core.utils.Constants;
import com.doumee.core.utils.PinYinUtil;
import com.doumee.core.utils.Utils;
import com.doumee.dao.business.*;
import com.doumee.dao.business.model.*;
import com.doumee.dao.business.model.dto.OssModel;
import com.doumee.service.CateParamSelectService;
import com.doumee.service.business.BaseDataService;
import com.doumee.service.business.GoodsImportTaskService;
import org.apache.commons.lang3.StringUtils;
import org.apache.poi.ss.usermodel.*;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import org.apache.shiro.SecurityUtils;
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 javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.math.BigDecimal;
import java.net.URLEncoder;
import java.util.*;

@Service
public class GoodsImportTaskServiceImpl implements GoodsImportTaskService {

    private static final String[] ASYNC_TEMPLATE_HEADERS = {
            "商品文件夹名称", "商品名称", "商品类别", "商品品牌",
            "指导价", "入手价", "产品参数", "商品二级类别", "商品主图", "商品多图"
    };

    /** 表头字体改为黑色的列：商品二级类别、商品主图、商品多图 */
    private static final int[] BLACK_HEADER_COLS = {7, 8, 9};

    /** 商品主图、商品多图列索引（与 GoodsImportAsync.index 一致） */
    private static final int COL_MAIN_IMAGE = 8;
    private static final int COL_MULTI_IMAGE = 9;

    @Autowired
    private GoodsImportTaskMapper goodsImportTaskMapper;
    @Autowired
    private GoodsMapper goodsMapper;
    @Autowired
    private CategoryMapper categoryMapper;
    @Autowired
    private BrandMapper brandMapper;
    @Autowired
    private CateParamMapper cateParamMapper;
    @Autowired
    private GoodsParamMapper goodsParamMapper;
    @Autowired
    private MultifileMapper multifileMapper;
    @Autowired
    private BaseDataService baseDataService;
    @Autowired
    private SystemDictDataBiz systemDictDataBiz;
    @Autowired
    private CateParamSelectService cateParamSelectService;
    @Autowired
    @Lazy
    private GoodsImportTaskWorker goodsImportTaskWorker;

    @Override
    public void exportImportAsyncTemplate(HttpServletRequest request, HttpServletResponse response) throws Exception {
        LoginUserInfo loginUserInfo = (LoginUserInfo) SecurityUtils.getSubject().getPrincipal();
        String fileName = "产品异步导入表" + System.currentTimeMillis() + ".xlsx";
        InputStream inputStream = this.getClass().getClassLoader().getResourceAsStream("static/file/goodsExcelTemp.xlsx");
        Workbook workbook = new XSSFWorkbook(inputStream);
        Sheet sheet0 = workbook.getSheetAt(0);
        Row headerRow = sheet0.getRow(0);
        if (headerRow == null) {
            headerRow = sheet0.createRow(0);
        }
        for (int i = 0; i < ASYNC_TEMPLATE_HEADERS.length; i++) {
            Cell cell = headerRow.getCell(i);
            if (cell == null) {
                cell = headerRow.createCell(i);
            }
            cell.setCellValue(ASYNC_TEMPLATE_HEADERS[i]);
        }
        applyTemplateHeaderStyles(workbook, headerRow);
        applyTemplateColumnWidths(sheet0);
        CellStyle wrapStyle = workbook.createCellStyle();
        wrapStyle.setWrapText(true);
        fillTemplateExampleRow(sheet0, wrapStyle);
        Sheet sheet = workbook.getSheetAt(1);
        CellStyle cs = workbook.createCellStyle();
        cs.setWrapText(true);
        Row row = sheet.createRow(1);
        List<Category> categoryList = categoryMapper.selectList(
                new QueryWrapper<Category>().eq("ISDELETED", 0).eq("COMPANY_ID", loginUserInfo.getCompanyId()));
        categoryList.forEach(i -> i.setParamList(
                cateParamMapper.selectList(new QueryWrapper<CateParam>().eq("ISDELETED", 0).eq("CATEGORY_ID", i.getId()))));
        if (categoryList != null) {
            for (int i = 0; i < categoryList.size(); i++) {
                Category category = categoryList.get(i);
                row = sheet.createRow(i + 1);
                row.createCell(0).setCellValue(category.getName());
                List<CateParam> paramList = category.getParamList();
                StringBuilder param = new StringBuilder();
                if (paramList != null) {
                    for (int j = 0; j < paramList.size(); j++) {
                        if (j > 0) {
                            param.append("\r\n");
                        }
                        param.append(paramList.get(j).getName()).append("：");
                    }
                }
                Cell cell = row.createCell(1);
                cell.setCellStyle(cs);
                cell.setCellValue(param.toString());
            }
        }
        setResponseHeader(response, fileName);
        OutputStream os = response.getOutputStream();
        workbook.write(os);
        os.flush();
        os.close();
        workbook.close();
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Integer submitTask(MultipartFile file) {
        LoginUserInfo user = (LoginUserInfo) SecurityUtils.getSubject().getPrincipal();
        if (hasUnfinishedTask(user.getCompanyId())) {
            throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(), "当前存在未完成的导入任务，请等待完成后再提交");
        }
        if (file == null || file.isEmpty()) {
            throw new BusinessException(ResponseStatus.BAD_REQUEST.getCode(), "导入文件不能为空");
        }
        String originalName = sanitizeImportFileName(StringUtils.defaultString(file.getOriginalFilename(), "import.xlsx"));
        String saveDir = buildImportDir(user.getCompanyId());
        File dir = new File(saveDir);
        if (!dir.exists() && !dir.mkdirs()) {
            throw new BusinessException(ResponseStatus.SERVER_ERROR.getCode(), "创建导入目录失败");
        }
        String saveName = System.currentTimeMillis() + "_" + originalName;
        File saved = new File(dir, saveName);
        try {
            saveImportFile(file, saved);
        } catch (Exception e) {
            throw new BusinessException(ResponseStatus.SERVER_ERROR.getCode(), "保存导入文件失败：" + e.getMessage());
        }
        GoodsImportTask task = new GoodsImportTask();
        task.setCompanyId(user.getCompanyId());
        task.setCreator(user.getId());
        task.setCreateDate(new Date());
        task.setEditDate(new Date());
        task.setIsdeleted(Constants.ZERO);
        task.setFileName(originalName);
        task.setFilePath(saved.getAbsolutePath());
        task.setStatus(GoodsImportTask.STATUS_PENDING);
        task.setTotalRows(0);
        task.setSuccessRows(0);
        task.setFailedRows(0);
        task.setProgress(0);
        goodsImportTaskMapper.insert(task);
        goodsImportTaskWorker.runTask(task.getId());
        return task.getId();
    }

    @Override
    public void processTask(Integer taskId) {
        GoodsImportTask task = goodsImportTaskMapper.selectById(taskId);
        if (task == null || !Constants.equalsInteger(Constants.ZERO, task.getIsdeleted())) {
            return;
        }
        task.setStatus(GoodsImportTask.STATUS_PROCESSING);
        task.setEditDate(new Date());
        goodsImportTaskMapper.updateById(task);
        List<String> errorLines = new ArrayList<>();
        int success = 0;
        int failed = 0;
        int rowNum = 1;
        try {
            ExcelImporter ie = new ExcelImporter(new File(task.getFilePath()), 0, 0);
            List<GoodsImportAsync> dataList = ie.getDataList(GoodsImportAsync.class, null);
            if (dataList == null || dataList.isEmpty()) {
                throw new BusinessException(ResponseStatus.BAD_REQUEST.getCode(), "录入数据为空");
            }
            AsyncImportExcelSupport.ColumnMapping columnMapping =
                    AsyncImportExcelSupport.readAndApplyTextFields(task.getFilePath(), 0, 0, dataList);
            task.setTotalRows(dataList.size());
            goodsImportTaskMapper.updateById(task);

            Map<Integer, RowEmbeddedImages> rowImageMap = ExcelEmbeddedImageReader.read(
                    task.getFilePath(), 0, 0, columnMapping.getMainImageCol(), columnMapping.getMultiImageCol());

            LoginUserInfo user = new LoginUserInfo();
            user.setId(task.getCreator());
            user.setCompanyId(task.getCompanyId());

            List<Brand> brandList = brandMapper.selectList(new LambdaQueryWrapper<Brand>().eq(Brand::getIsdeleted, Constants.ZERO)
                    .and(w -> w.eq(Brand::getCompanyId, task.getCompanyId()).or().eq(Brand::getType, Constants.ONE)));
            List<Goods> goodsList = goodsMapper.selectList(new LambdaQueryWrapper<Goods>().eq(Goods::getIsdeleted, Constants.ZERO)
                    .eq(Goods::getCompanyId, task.getCompanyId()));
            List<Category> categoryList = categoryMapper.selectList(new LambdaQueryWrapper<Category>().eq(Category::getIsdeleted, Constants.ZERO)
                    .eq(Category::getCompanyId, task.getCompanyId()));
            Map<Integer, List<Category>> subCategoryMap = buildSubCategoryMap(task.getCompanyId());
            List<CateParam> allParamsList = cateParamMapper.selectList(new LambdaQueryWrapper<CateParam>().eq(CateParam::getIsdeleted, Constants.ZERO));
            OssModel ossModel = baseDataService.initOssModel();

            int processed = 0;
            int dataStartRow = 1;
            for (int i = 0; i < dataList.size(); i++) {
                GoodsImportAsync row = dataList.get(i);
                int excelRowIndex = dataStartRow + i;
                rowNum = excelRowIndex + 1;
                if (isBlankRow(row)) {
                    processed++;
                    updateProgress(task, processed, success, failed);
                    continue;
                }
                RowEmbeddedImages rowImages = rowImageMap.getOrDefault(excelRowIndex, RowEmbeddedImages.empty());
                try {
                    importOneRow(row, rowNum, user, rowImages, brandList, goodsList, categoryList,
                            subCategoryMap, allParamsList, ossModel);
                    success++;
                } catch (BusinessException e) {
                    failed++;
                    errorLines.add("第【" + rowNum + "】行：" + e.getMessage());
                } catch (Exception e) {
                    failed++;
                    errorLines.add("第【" + rowNum + "】行：导入异常");
                }
                processed++;
                updateProgress(task, processed, success, failed);
            }
            task.setStatus(GoodsImportTask.STATUS_SUCCESS);
            task.setSuccessRows(success);
            task.setFailedRows(failed);
            task.setProgress(100);
            if (!errorLines.isEmpty()) {
                task.setErrorMessage("部分行导入失败，共 " + failed + " 行");
                task.setErrorDetail(JSON.toJSONString(errorLines));
                if (success == 0) {
                    task.setStatus(GoodsImportTask.STATUS_FAILED);
                    task.setErrorMessage("全部导入失败");
                }
            }
            cateParamSelectService.dealCateParamSelect();
        } catch (BusinessException e) {
            task.setStatus(GoodsImportTask.STATUS_FAILED);
            task.setErrorMessage(e.getMessage());
            task.setFailedRows(Math.max(failed, 1));
        } catch (Exception e) {
            task.setStatus(GoodsImportTask.STATUS_FAILED);
            task.setErrorMessage("导入任务执行异常，请稍后重试");
            if (!errorLines.isEmpty()) {
                task.setErrorDetail(JSON.toJSONString(errorLines));
            }
        } finally {
            task.setEditDate(new Date());
            goodsImportTaskMapper.updateById(task);
        }
    }

    private void importOneRow(GoodsImportAsync m, int num, LoginUserInfo user, RowEmbeddedImages rowImages,
                            List<Brand> brandList, List<Goods> goodsList, List<Category> categoryList,
                            Map<Integer, List<Category>> subCategoryMap, List<CateParam> allParamsList,
                            OssModel ossModel) {
        if (StringUtils.isBlank(m.getName()) || StringUtils.isBlank(m.getCategory())
                || StringUtils.isBlank(m.getBrand()) || StringUtils.isBlank(m.getZdPrice())
                || StringUtils.isBlank(m.getPrice())) {
            throw new BusinessException(ResponseStatus.BAD_REQUEST.getCode(), "数据无效，请检查名称/类别/品牌/价格");
        }
        if (StringUtils.isNotBlank(m.getId())) {
            Goods existsFolder = new Goods();
            existsFolder.setRemark(m.getId());
            existsFolder.setCompanyId(user.getCompanyId());
            existsFolder.setIsdeleted(Constants.ZERO);
            existsFolder = goodsMapper.selectOne(new QueryWrapper<>(existsFolder).last(" limit 1"));
            if (existsFolder != null) {
                throw new BusinessException(ResponseStatus.BAD_REQUEST.getCode(), "商品图片文件夹名称重复");
            }
        }
        Category cate = getTopCategoryByName(m.getCategory(), categoryList);
        if (cate == null) {
            throw new BusinessException(ResponseStatus.BAD_REQUEST.getCode(), "商品类别无效");
        }
        Category subCate = null;
        String subCategoryName = normalizeCategoryName(m.getSubCategory());
        if (StringUtils.isNotBlank(subCategoryName)) {
            subCate = matchSubCategoryUnderParent(cate, subCategoryName, subCategoryMap, user.getCompanyId());
            if (subCate == null) {
                throw new BusinessException(ResponseStatus.BAD_REQUEST.getCode(),
                        "商品二级类别【" + subCategoryName + "】在一级类别【"
                                + normalizeCategoryName(cate.getName()) + "】的子类别中不存在");
            }
        }
        Brand brand = getBrandByName(m.getBrand(), brandList);
        if (brand == null) {
            throw new BusinessException(ResponseStatus.BAD_REQUEST.getCode(), "商品品牌无效");
        }
        if (findGoodsByName(m.getName(), goodsList) != null) {
            throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(), "产品名称【" + m.getName() + "】已存在");
        }

        Goods newModel = new Goods();
        if (StringUtils.isNotBlank(m.getId())) {
            newModel.setRemark(m.getId());
        }
        newModel.setCategoryId(cate.getId());
        if (subCate != null) {
            newModel.setSubCategoryId(subCate.getId());
        }
        newModel.setBrandId(brand.getId());
        newModel.setIsdeleted(Constants.ZERO);
        newModel.setCreator(user.getId());
        newModel.setCompanyId(user.getCompanyId());
        newModel.setCreateDate(new Date());
        newModel.setName(m.getName().trim());
        newModel.setStatus(Constants.ZERO);
        try {
            newModel.setZdPrice(BigDecimal.valueOf(Double.parseDouble(m.getZdPrice().trim())));
            newModel.setPrice(BigDecimal.valueOf(Double.parseDouble(m.getPrice().trim())));
        } catch (Exception e) {
            throw new BusinessException(ResponseStatus.BAD_REQUEST.getCode(), "指导价或入手价无效");
        }
        newModel.setPinyin(PinYinUtil.getFullSpell(newModel.getName()));
        newModel.setShortPinyin(PinYinUtil.getFirstSpell(newModel.getName()));

        String goodsFolder = ossModel.getGoodsFolder();
        String mainImg = null;
        if (rowImages.getMainImage() != null) {
            mainImg = uploadEmbeddedImage(ossModel, goodsFolder, rowImages.getMainImage());
        }

        List<String> multiUrls = new ArrayList<>();
        if (rowImages.getMultiImages() != null) {
            for (RowEmbeddedImages.EmbeddedImageItem item : rowImages.getMultiImages()) {
                String url = uploadEmbeddedImage(ossModel, goodsFolder, item);
                if (StringUtils.isNotBlank(url)) {
                    multiUrls.add(url);
                }
            }
        }

        if (StringUtils.isNotBlank(mainImg)) {
            newModel.setImgurl(mainImg);
        }

        goodsMapper.insert(newModel);
        goodsList.add(newModel);
        dealGoodsParam(cate, newModel, m.getParamStr(), allParamsList, num);
        dealMultifiles(multiUrls, newModel);
    }

    @Override
    public PageData<GoodsImportTask> findPage(PageWrap<GoodsImportTask> pageWrap) {
        LoginUserInfo user = (LoginUserInfo) SecurityUtils.getSubject().getPrincipal();
        IPage<GoodsImportTask> page = new Page<>(pageWrap.getPage(), pageWrap.getCapacity());
        QueryWrapper<GoodsImportTask> wrapper = new QueryWrapper<>();
        wrapper.eq("COMPANY_ID", user.getCompanyId());
        wrapper.eq("ISDELETED", Constants.ZERO);
        GoodsImportTask model = pageWrap.getModel();
        if (model != null) {
            if (model.getStatus() != null) {
                wrapper.eq("STATUS", model.getStatus());
            }
            if (model.getCreateDateStart() != null) {
                wrapper.ge("CREATE_DATE", model.getCreateDateStart());
            }
            if (model.getCreateDateEnd() != null) {
                wrapper.le("CREATE_DATE", model.getCreateDateEnd());
            }
        }
        wrapper.orderByDesc("ID");
        IPage<GoodsImportTask> result = goodsImportTaskMapper.selectPage(page, wrapper);
        if (result.getRecords() != null) {
            result.getRecords().forEach(this::fillStatusText);
        }
        return PageData.from(result);
    }

    @Override
    public GoodsImportTask findById(Integer id) {
        LoginUserInfo user = (LoginUserInfo) SecurityUtils.getSubject().getPrincipal();
        GoodsImportTask task = goodsImportTaskMapper.selectById(id);
        if (task == null || !Constants.equalsInteger(Constants.ZERO, task.getIsdeleted())
                || !user.getCompanyId().equals(task.getCompanyId())) {
            throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(), "任务不存在");
        }
        fillStatusText(task);
        return task;
    }

    @Override
    public boolean hasUnfinishedTask(Integer companyId) {
        Long count = goodsImportTaskMapper.selectCount(new LambdaQueryWrapper<GoodsImportTask>()
                .eq(GoodsImportTask::getCompanyId, companyId)
                .eq(GoodsImportTask::getIsdeleted, Constants.ZERO)
                .in(GoodsImportTask::getStatus, GoodsImportTask.STATUS_PENDING, GoodsImportTask.STATUS_PROCESSING));
        return count != null && count > 0;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void deleteById(Integer id) {
        LoginUserInfo user = (LoginUserInfo) SecurityUtils.getSubject().getPrincipal();
        GoodsImportTask task = goodsImportTaskMapper.selectById(id);
        if (task == null || !Constants.equalsInteger(Constants.ZERO, task.getIsdeleted())
                || !user.getCompanyId().equals(task.getCompanyId())) {
            throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(), "任务不存在");
        }
        if (Constants.equalsInteger(GoodsImportTask.STATUS_PENDING, task.getStatus())
                || Constants.equalsInteger(GoodsImportTask.STATUS_PROCESSING, task.getStatus())) {
            throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(), "待处理或处理中的任务无法删除");
        }
        task.setIsdeleted(Constants.ONE);
        task.setEditor(user.getId());
        task.setEditDate(new Date());
        goodsImportTaskMapper.updateById(task);
        removeTaskFile(task.getFilePath());
    }

    private void removeTaskFile(String filePath) {
        if (StringUtils.isBlank(filePath)) {
            return;
        }
        try {
            File file = new File(filePath);
            if (file.isFile()) {
                file.delete();
            }
        } catch (Exception ignored) {
        }
    }

    private void updateProgress(GoodsImportTask task, int processed, int success, int failed) {
        int total = Math.max(task.getTotalRows(), 1);
        task.setProgress(Math.min(100, (int) (processed * 100.0 / total)));
        task.setSuccessRows(success);
        task.setFailedRows(failed);
        task.setEditDate(new Date());
        goodsImportTaskMapper.updateById(task);
    }

    private void fillStatusText(GoodsImportTask task) {
        if (task == null || task.getStatus() == null) {
            return;
        }
        switch (task.getStatus()) {
            case GoodsImportTask.STATUS_PENDING:
                task.setStatusText("待处理");
                break;
            case GoodsImportTask.STATUS_PROCESSING:
                task.setStatusText("处理中");
                break;
            case GoodsImportTask.STATUS_SUCCESS:
                task.setStatusText("成功");
                break;
            case GoodsImportTask.STATUS_FAILED:
                task.setStatusText("失败");
                break;
            default:
                task.setStatusText("未知");
        }
    }

    private boolean isBlankRow(GoodsImportAsync row) {
        return StringUtils.isBlank(row.getName()) && StringUtils.isBlank(row.getCategory())
                && StringUtils.isBlank(row.getBrand()) && StringUtils.isBlank(row.getZdPrice())
                && StringUtils.isBlank(row.getPrice()) && StringUtils.isBlank(row.getId());
    }

    private String buildImportDir(Integer companyId) {
        String goodsDir = buildImportDirByBase(companyId, Constants.GOODS_IMG_DIR);
        if (canCreateDir(goodsDir)) {
            return goodsDir;
        }
        String fileDir = buildImportDirByBase(companyId, Constants.FILE_DIR);
        if (canCreateDir(fileDir)) {
            return fileDir;
        }
        String tmpDir = normalizeDirPath(System.getProperty("java.io.tmpdir"))
                + "preselect" + File.separator + "import_tasks" + File.separator + companyId;
        if (!canCreateDir(tmpDir)) {
            throw new BusinessException(ResponseStatus.SERVER_ERROR.getCode(), "创建导入目录失败");
        }
        return tmpDir;
    }

    private String buildImportDirByBase(Integer companyId, String baseKey) {
        String base = getDictCode(baseKey);
        if (StringUtils.isBlank(base)) {
            return "";
        }
        String proDir = getDictCode(Constants.PROJECTS);
        return normalizeDirPath(base) + normalizeDirPath(proDir) + companyId + File.separator + "import_tasks";
    }

    private String getDictCode(String label) {
        try {
            com.doumee.dao.system.model.SystemDictData data = systemDictDataBiz.queryByCode(Constants.SYSTEM, label);
            return data == null ? "" : StringUtils.defaultString(data.getCode(), "");
        } catch (Exception e) {
            return "";
        }
    }

    private String normalizeDirPath(String path) {
        if (StringUtils.isBlank(path)) {
            return "";
        }
        String normalized = path.replace('/', File.separatorChar).replace('\\', File.separatorChar);
        if (!normalized.endsWith(File.separator)) {
            normalized += File.separator;
        }
        return normalized;
    }

    private boolean canCreateDir(String dirPath) {
        if (StringUtils.isBlank(dirPath)) {
            return false;
        }
        File dir = new File(dirPath);
        return dir.exists() || dir.mkdirs();
    }

    private String sanitizeImportFileName(String fileName) {
        String name = fileName.replace("\\", "_").replace("/", "_").replace(":", "_");
        if (!name.toLowerCase(Locale.ROOT).endsWith(".xlsx") && !name.toLowerCase(Locale.ROOT).endsWith(".xls")) {
            name = name + ".xlsx";
        }
        return name;
    }

    private void saveImportFile(MultipartFile file, File dest) throws IOException {
        File target = dest.getAbsoluteFile();
        File parent = target.getParentFile();
        if (parent != null && !parent.exists() && !parent.mkdirs()) {
            throw new IOException("无法创建目录: " + parent.getAbsolutePath());
        }
        if (target.exists() && !target.delete()) {
            throw new IOException("无法覆盖已存在文件: " + target.getAbsolutePath());
        }
        try (InputStream in = file.getInputStream(); FileOutputStream out = new FileOutputStream(target)) {
            byte[] buffer = new byte[8192];
            int len;
            while ((len = in.read(buffer)) != -1) {
                out.write(buffer, 0, len);
            }
            out.flush();
        }
    }

    private String uploadEmbeddedImage(OssModel ossModel, String folder, RowEmbeddedImages.EmbeddedImageItem item) {
        if (item == null || item.getData() == null || item.getData().length == 0) {
            return null;
        }
        String ext = StringUtils.defaultIfBlank(item.getExtension(), ".jpg");
        File temp = null;
        try {
            temp = File.createTempFile("goods_import_img_", ext);
            try (FileOutputStream out = new FileOutputStream(temp)) {
                out.write(item.getData());
            }
            return baseDataService.getOssImgurl(ossModel, folder, temp);
        } catch (Exception e) {
            return null;
        } finally {
            if (temp != null && temp.exists() && !temp.delete()) {
                temp.deleteOnExit();
            }
        }
    }

    private void dealMultifiles(List<String> urls, Goods goods) {
        if (urls == null || urls.isEmpty()) {
            return;
        }
        List<Multifile> list = new ArrayList<>();
        for (int i = 0; i < urls.size(); i++) {
            Multifile f = new Multifile();
            f.setObjType(Constants.ZERO);
            f.setName(urls.get(i));
            f.setType(Constants.ZERO);
            f.setObjId(goods.getId());
            f.setCreateDate(goods.getCreateDate());
            f.setCreator(goods.getCreator());
            f.setIsdeleted(Constants.ZERO);
            f.setSortnum(i + Constants.ONE);
            f.setCompanyId(goods.getCompanyId());
            f.setFileurl(urls.get(i));
            list.add(f);
        }
        multifileMapper.insertBatch(list);
    }

    private void dealGoodsParam(Category cate, Goods goods, String paramStr, List<CateParam> allParamsList, int num) {
        List<GoodsParam> paramList = new ArrayList<>();
        String[] params = StringUtils.defaultString(paramStr, "").split("\n");
        List<CateParam> cateParams = getCateParamByCateId(cate.getId(), allParamsList);
        for (String s : params) {
            if (StringUtils.isBlank(s)) {
                continue;
            }
            s = s.replace("：", ":");
            String[] ts = s.split(":");
            if (ts.length == 0) {
                continue;
            }
            CateParam ta = getCateParamByName(ts[0], cateParams);
            if (ta == null) {
                throw new BusinessException(ResponseStatus.BAD_REQUEST.getCode(), "产品参数中【" + s + "】无效");
            }
            GoodsParam gp = new GoodsParam();
            gp.setIsdeleted(Constants.ZERO);
            gp.setCreator(goods.getCreator());
            gp.setCreateDate(goods.getCreateDate());
            gp.setGoodsId(goods.getId());
            gp.setName(ta.getName());
            gp.setPramaId(ta.getId());
            gp.setStatus(Constants.ZERO);
            gp.setVal(ts.length > 1 ? ts[1] : null);
            gp.setSortnum(ta.getSortnum());
            paramList.add(gp);
        }
        if (!paramList.isEmpty()) {
            goodsParamMapper.insertBatch(paramList);
        }
    }

    private String normalizeCategoryName(String name) {
        if (name == null) {
            return "";
        }
        return name.trim().replace('\u00A0', ' ').replaceAll("\\s+", " ");
    }

    private boolean isTopLevelCategory(Category category) {
        return category != null
                && (category.getParentId() == null || Constants.equalsInteger(category.getParentId(), Constants.ZERO));
    }

    private Category getTopCategoryByName(String name, List<Category> list) {
        if (list == null) {
            return null;
        }
        String normalized = normalizeCategoryName(name);
        if (StringUtils.isBlank(normalized)) {
            return null;
        }
        for (Category c : list) {
            if (isTopLevelCategory(c) && StringUtils.equals(normalized, normalizeCategoryName(c.getName()))) {
                return c;
            }
        }
        return null;
    }

    /** 按企业加载一级类别 -> 子类别列表 */
    private Map<Integer, List<Category>> buildSubCategoryMap(Integer companyId) {
        List<Category> subCategories = categoryMapper.selectList(new LambdaQueryWrapper<Category>()
                .eq(Category::getCompanyId, companyId)
                .eq(Category::getIsdeleted, Constants.ZERO)
                .isNotNull(Category::getParentId)
                .orderByAsc(Category::getSortnum));
        Map<Integer, List<Category>> map = new HashMap<>();
        for (Category sub : subCategories) {
            if (sub.getParentId() == null || Constants.equalsInteger(sub.getParentId(), Constants.ZERO)) {
                continue;
            }
            map.computeIfAbsent(sub.getParentId(), k -> new ArrayList<>()).add(sub);
        }
        return map;
    }

    /**
     * 根据本行已匹配的一级【商品类别】，在其子类别中查找与【商品二级类别】名称一致的记录。
     */
    private Category matchSubCategoryUnderParent(Category topCategory, String subCategoryName,
                                                 Map<Integer, List<Category>> subCategoryMap, Integer companyId) {
        if (topCategory == null || topCategory.getId() == null) {
            return null;
        }
        String normalized = normalizeCategoryName(subCategoryName);
        if (StringUtils.isBlank(normalized)) {
            return null;
        }
        List<Category> children = subCategoryMap.get(topCategory.getId());
        if (children == null || children.isEmpty()) {
            Integer cid = topCategory.getCompanyId() != null ? topCategory.getCompanyId() : companyId;
            children = categoryMapper.selectList(new LambdaQueryWrapper<Category>()
                    .eq(Category::getParentId, topCategory.getId())
                    .eq(Category::getCompanyId, cid)
                    .eq(Category::getIsdeleted, Constants.ZERO)
                    .orderByAsc(Category::getSortnum));
        }
        for (Category child : children) {
            if (StringUtils.equals(normalized, normalizeCategoryName(child.getName()))) {
                return child;
            }
        }
        return null;
    }

    private Brand getBrandByName(String name, List<Brand> list) {
        if (list == null) {
            return null;
        }
        for (Brand b : list) {
            if (StringUtils.equals(name.trim(), b.getName())) {
                return b;
            }
        }
        return null;
    }

    private Goods findGoodsByName(String name, List<Goods> list) {
        if (list == null) {
            return null;
        }
        for (Goods g : list) {
            if (StringUtils.equals(name.trim(), g.getName())) {
                return g;
            }
        }
        return null;
    }

    private List<CateParam> getCateParamByCateId(Integer cateId, List<CateParam> all) {
        List<CateParam> list = new ArrayList<>();
        if (all == null) {
            return list;
        }
        for (CateParam p : all) {
            if (Constants.equalsInteger(cateId, p.getCategoryId())) {
                list.add(p);
            }
        }
        return list;
    }

    private CateParam getCateParamByName(String name, List<CateParam> params) {
        if (params == null) {
            return null;
        }
        for (CateParam p : params) {
            if (StringUtils.equals(name.trim(), p.getName())) {
                return p;
            }
        }
        return null;
    }

    /** 原模板「产品参数」列宽（字符宽），用于新版 G 列放大 */
    private static final double TEMPLATE_PARAM_COL_WIDTH = 16.33203125D;

    private void applyTemplateHeaderStyles(Workbook workbook, Row headerRow) {
        CellStyle evenStyle = null;
        CellStyle oddStyle = null;
        for (int i = 0; i < 6; i++) {
            Cell cell = headerRow.getCell(i);
            if (cell == null) {
                continue;
            }
            if (i % 2 == 0) {
                evenStyle = cell.getCellStyle();
            } else {
                oddStyle = cell.getCellStyle();
            }
        }
        if (evenStyle == null && headerRow.getCell(0) != null) {
            evenStyle = headerRow.getCell(0).getCellStyle();
        }
        if (oddStyle == null) {
            oddStyle = evenStyle;
        }
        for (int i = 0; i < ASYNC_TEMPLATE_HEADERS.length; i++) {
            Cell cell = headerRow.getCell(i);
            if (cell == null) {
                cell = headerRow.createCell(i);
            }
            CellStyle style = (i % 2 == 0) ? evenStyle : oddStyle;
            if (style != null) {
                cell.setCellStyle(style);
            }
        }
        for (int col : BLACK_HEADER_COLS) {
            Cell cell = headerRow.getCell(col);
            if (cell == null) {
                continue;
            }
            CellStyle baseStyle = cell.getCellStyle();
            CellStyle blackStyle = workbook.createCellStyle();
            if (baseStyle != null) {
                blackStyle.cloneStyleFrom(baseStyle);
            }
            Font baseFont = baseStyle != null ? workbook.getFontAt(baseStyle.getFontIndexAsInt()) : null;
            Font blackFont = workbook.createFont();
            if (baseFont != null) {
                blackFont.setBold(baseFont.getBold());
                blackFont.setFontHeight(baseFont.getFontHeight());
                blackFont.setFontName(baseFont.getFontName());
            }
            blackFont.setColor(IndexedColors.BLACK.getIndex());
            blackStyle.setFont(blackFont);
            cell.setCellStyle(blackStyle);
        }
    }

    private void applyTemplateColumnWidths(Sheet sheet) {
        int paramColIndex = 6;
        int doubledWidth = (int) Math.round(TEMPLATE_PARAM_COL_WIDTH * 256 * 2);
        sheet.setColumnWidth(paramColIndex, doubledWidth);
    }

    private void fillTemplateExampleRow(Sheet sheet0, CellStyle wrapStyle) {
        Row exampleRow = sheet0.getRow(1);
        if (exampleRow == null) {
            exampleRow = sheet0.createRow(1);
        }
        exampleRow.createCell(0).setCellValue("125");
        exampleRow.createCell(1).setCellValue("美的电烤箱");
        exampleRow.createCell(2).setCellValue("电烤箱");
        exampleRow.createCell(3).setCellValue("美的");
        exampleRow.createCell(4).setCellValue("2888");
        exampleRow.createCell(5).setCellValue("2300");
        Cell paramCell = exampleRow.createCell(6);
        paramCell.setCellStyle(wrapStyle);
        paramCell.setCellValue("容量：99升\r\n重量：88KG\r\n型号：77");
        exampleRow.createCell(7).setCellValue("");
        exampleRow.createCell(8).setCellValue("");
        exampleRow.createCell(9).setCellValue("");
    }

    private void setResponseHeader(HttpServletResponse response, String fileName) throws Exception {
        String encodeFileName = URLEncoder.encode(fileName, "UTF-8");
        response.setContentType("application/octet-stream");
        response.setHeader("Content-Disposition", "attachment;filename=" + encodeFileName);
        response.setHeader("eva-opera-type", "download");
        response.setHeader("eva-download-filename", encodeFileName);
    }
}