package cn.iocoder.yudao.module.srm.service.supplier;

import cn.hutool.core.util.StrUtil;
import cn.iocoder.yudao.module.srm.controller.admin.supplier.vo.SrmSupplierSaveReqVO;
import cn.iocoder.yudao.module.srm.dal.dataobject.SrmSupplierDO;
import cn.iocoder.yudao.module.srm.dal.mysql.SrmSupplierMapper;
import cn.iocoder.yudao.module.system.api.agent.imports.AgentImportCommitReqVO;
import cn.iocoder.yudao.module.system.api.agent.imports.AgentImportModuleAdapter;
import cn.iocoder.yudao.module.system.api.agent.imports.AgentImportPreflightReqVO;
import cn.iocoder.yudao.module.system.api.agent.imports.AgentImportPreflightRespVO;
import cn.iocoder.yudao.module.system.api.agent.imports.AgentImportRowReceipt;
import cn.iocoder.yudao.module.system.framework.agent.AgentPrincipal;
import cn.iocoder.yudao.module.system.service.agent.imports.SystemAgentGenericImportService;
import jakarta.annotation.Resource;
import org.springframework.stereotype.Component;

import java.math.BigDecimal;
import java.util.*;

/**
 * 供应商档案导入：已存在编码跳过并给警告，只新建不更新。
 */
@Component
public class SrmSupplierImportAdapter implements AgentImportModuleAdapter {

    public static final String MODULE_ID = "srm.supplier";
    private static final String PERMISSION = "srm:supplier:create";

    @Resource
    private SrmSupplierService supplierService;
    @Resource
    private SrmSupplierMapper supplierMapper;

    @Override
    public String moduleId() {
        return MODULE_ID;
    }

    @Override
    public String permission() {
        return PERMISSION;
    }

    @Override
    public AgentImportPreflightRespVO preflight(AgentPrincipal principal, AgentImportPreflightReqVO request) {
        // 1. 先统计文件内重复编码，全部标为阻断，避免替用户选版本
        Map<String, Integer> codeCounts = new HashMap<>();
        for (AgentImportPreflightReqVO.Row row : request.getRows()) {
            String code = value(row, "code");
            if (!code.isEmpty()) {
                codeCounts.merge(code, 1, Integer::sum);
            }
        }

        List<AgentImportPreflightRespVO.Row> rows = new ArrayList<>();
        List<Map<String, Object>> resolvedPayload = new ArrayList<>();
        int create = 0;
        int skip = 0;
        int blocked = 0;
        for (AgentImportPreflightReqVO.Row row : request.getRows()) {
            List<AgentImportPreflightRespVO.Issue> blockers = new ArrayList<>();
            List<AgentImportPreflightRespVO.Issue> warnings = new ArrayList<>();
            String code = value(row, "code");
            String name = value(row, "name");
            if (code.isEmpty()) {
                blockers.add(issue("CODE_REQUIRED", "code", "供应商编码不能为空"));
            }
            if (name.isEmpty()) {
                blockers.add(issue("NAME_REQUIRED", "name", "供应商名称不能为空"));
            }
            if (!code.isEmpty() && codeCounts.getOrDefault(code, 0) > 1) {
                blockers.add(issue("DUPLICATE_CODE_IN_FILE", "code",
                        "文件内存在重复的供应商编码：" + code));
            }
            Integer status = parseStatus(row.getValues().get("status"), blockers);
            BigDecimal registeredCapital = parseDecimal(row.getValues().get("registeredCapital"), blockers);

            Long targetId = null;
            String action;
            SrmSupplierDO existing = code.isEmpty() ? null : supplierMapper.selectByCode(code);
            if (!blockers.isEmpty()) {
                action = "BLOCKED";
                blocked++;
            } else if (existing != null) {
                action = "SKIP";
                targetId = existing.getId();
                skip++;
                warnings.add(issue("SUPPLIER_EXISTS", "code",
                        "供应商编码已存在，已跳过且不会更新现有档案"));
            } else {
                action = "CREATE";
                create++;
            }

            Map<String, Object> resolved = new LinkedHashMap<>();
            resolved.put("candidate_id", row.getCandidateId());
            resolved.put("code", code);
            resolved.put("name", name);
            resolved.put("status", status);
            resolved.put("action", action);
            resolved.put("target_id", targetId);
            resolvedPayload.add(resolved);

            Map<String, Object> resolvedValues = new LinkedHashMap<>();
            resolvedValues.put("code", code);
            resolvedValues.put("name", name);
            resolvedValues.put("status", status);
            resolvedValues.put("registeredCapital", registeredCapital);
            rows.add(AgentImportPreflightRespVO.Row.builder()
                    .candidateId(row.getCandidateId())
                    .rowNo(row.getRowNo())
                    .action(action)
                    .resolved(resolvedValues)
                    .blockers(blockers)
                    .warnings(warnings)
                    .targetId(targetId)
                    .build());
        }

        int total = rows.size();
        return AgentImportPreflightRespVO.builder()
                .moduleId(MODULE_ID)
                .preflightHash(SystemAgentGenericImportService.preflightHash(MODULE_ID, request, resolvedPayload))
                .source(source(request))
                .summary(AgentImportPreflightRespVO.Summary.builder()
                        .total(total).create(create).skip(skip).blocked(blocked).build())
                .canCommit(blocked == 0)
                .sideEffects(List.of("创建供应商档案", "不更新已存在的供应商"))
                .rows(rows)
                .blockingItems(List.of())
                .build();
    }

    @Override
    public AgentImportRowReceipt commitRow(AgentPrincipal principal, AgentImportCommitReqVO request,
                                           AgentImportPreflightRespVO.Row planned,
                                           AgentImportPreflightReqVO.Row row) {
        Map<String, String> values = row.getValues();
        SrmSupplierSaveReqVO saveReqVO = new SrmSupplierSaveReqVO();
        saveReqVO.setCode(value(row, "code"));
        saveReqVO.setName(value(row, "name"));
        saveReqVO.setShortName(blankToNull(values.get("shortName")));
        saveReqVO.setType(blankToNull(values.get("type")));
        saveReqVO.setCompanyNature(blankToNull(values.get("companyNature")));
        saveReqVO.setRegisteredCapital(decimalOrNull(values.get("registeredCapital")));
        saveReqVO.setBusinessLicenseNo(blankToNull(values.get("businessLicenseNo")));
        saveReqVO.setTaxNo(blankToNull(values.get("taxNo")));
        saveReqVO.setLegalPerson(blankToNull(values.get("legalPerson")));
        saveReqVO.setAddress(blankToNull(values.get("address")));
        saveReqVO.setWebsite(blankToNull(values.get("website")));
        saveReqVO.setContactName(blankToNull(values.get("contactName")));
        saveReqVO.setContactMobile(blankToNull(values.get("contactMobile")));
        saveReqVO.setContactEmail(blankToNull(values.get("contactEmail")));
        saveReqVO.setBankName(blankToNull(values.get("bankName")));
        saveReqVO.setBankAccount(blankToNull(values.get("bankAccount")));
        saveReqVO.setStatus(parseStatus(values.get("status"), null));
        saveReqVO.setRemark(blankToNull(values.get("remark")));

        Long id = supplierService.createSupplier(saveReqVO);
        return AgentImportRowReceipt.created(id, saveReqVO.getCode(), saveReqVO.getName());
    }

    private static AgentImportPreflightRespVO.Source source(AgentImportPreflightReqVO request) {
        return AgentImportPreflightRespVO.Source.builder()
                .attachmentId(request.getAttachmentId())
                .sessionId(request.getSessionId())
                .sourceSha256(request.getSourceSha256())
                .proposalRevision(request.getProposalRevision())
                .build();
    }

    private static AgentImportPreflightRespVO.Issue issue(String code, String field, String message) {
        return AgentImportPreflightRespVO.Issue.builder()
                .code(code).field(field).message(message).retryable(false).build();
    }

    private static String value(AgentImportPreflightReqVO.Row row, String key) {
        String raw = row.getValues() == null ? null : row.getValues().get(key);
        return raw == null ? "" : raw.trim();
    }

    private static Integer parseStatus(String raw, List<AgentImportPreflightRespVO.Issue> blockers) {
        if (StrUtil.isBlank(raw)) {
            return 0;
        }
        String value = raw.trim();
        if ("0".equals(value) || "1".equals(value)) {
            return Integer.valueOf(value);
        }
        if (blockers != null) {
            blockers.add(issue("INVALID_STATUS", "status", "状态只能是 0（启用）或 1（禁用）"));
        }
        return 0;
    }

    private static BigDecimal parseDecimal(String raw, List<AgentImportPreflightRespVO.Issue> blockers) {
        if (StrUtil.isBlank(raw)) {
            return null;
        }
        try {
            return new BigDecimal(raw.trim());
        } catch (NumberFormatException ex) {
            if (blockers != null) {
                blockers.add(issue("INVALID_DECIMAL", "registeredCapital", "注册资金必须是数字"));
            }
            return null;
        }
    }

    private static BigDecimal decimalOrNull(String raw) {
        return StrUtil.isBlank(raw) ? null : new BigDecimal(raw.trim());
    }

    private static String blankToNull(String raw) {
        return StrUtil.isBlank(raw) ? null : raw.trim();
    }
}