package com.ruoyi.mock.service.impl;

import com.alibaba.fastjson2.JSON;
import com.alibaba.fastjson2.JSONArray;
import com.alibaba.fastjson2.JSONObject;
import com.ruoyi.ai.assistant.Assistant;
import com.ruoyi.basic.mapper.ProductMapper;
import com.ruoyi.basic.mapper.ProductModelMapper;
import com.ruoyi.basic.pojo.Customer;
import com.ruoyi.basic.pojo.SupplierManage;
import com.ruoyi.basic.service.ICustomerService;
import com.ruoyi.basic.service.ISupplierService;
import com.ruoyi.mock.dto.DataGenerateRequest;
import com.ruoyi.mock.prompt.MockDataPrompt;
import com.ruoyi.mock.service.DataGenerateService;
import com.ruoyi.mock.vo.DataGenerateResult;
import com.ruoyi.mock.vo.DataGenerateResult.ModuleSummary;
import com.ruoyi.production.pojo.ProductionOrder;
import com.ruoyi.production.pojo.ProductionPlan;
import com.ruoyi.production.service.ProductionOrderService;
import com.ruoyi.production.service.ProductionPlanService;
import com.ruoyi.purchase.dto.PurchaseLedgerDto;
import com.ruoyi.purchase.service.IPurchaseLedgerService;
import com.ruoyi.quality.pojo.QualityTestStandard;
import com.ruoyi.quality.pojo.QualityTestStandardBinding;
import com.ruoyi.quality.service.IQualityTestStandardService;
import com.ruoyi.quality.service.QualityTestStandardBindingService;
import com.ruoyi.sales.dto.SalesLedgerDto;
import com.ruoyi.sales.pojo.SalesLedgerProduct;
import com.ruoyi.sales.service.ISalesLedgerService;
import com.ruoyi.stock.dto.StockInventoryDto;
import com.ruoyi.stock.service.StockInventoryService;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;

import java.time.LocalDate;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

@Slf4j
@Service
@RequiredArgsConstructor
public class DataGenerateServiceImpl implements DataGenerateService {

    private final Assistant assistant;
    private final ProductMapper productMapper;
    private final ProductModelMapper productModelMapper;

    private final ICustomerService customerService;
    private final ISalesLedgerService salesLedgerService;
    private final ISupplierService supplierService;
    private final IPurchaseLedgerService purchaseLedgerService;
    private final IQualityTestStandardService qualityTestStandardService;
    private final QualityTestStandardBindingService qualityTestStandardBindingService;
    private final ProductionPlanService productionPlanService;
    private final ProductionOrderService productionOrderService;
    private final StockInventoryService stockInventoryService;

    @Override
    public DataGenerateResult generate(DataGenerateRequest request) {
        DataGenerateResult result = new DataGenerateResult();
        List<ModuleSummary> summaries = new ArrayList<>();
        List<String> errors = new ArrayList<>();
        int totalGenerated = 0;

        try {
            List<Long> productIds = productMapper.selectList(null).stream()
                    .map(p -> p.getId()).collect(Collectors.toList());
            List<Long> productModelIds = productModelMapper.selectList(null).stream()
                    .map(m -> m.getId()).collect(Collectors.toList());

            String systemPrompt = MockDataPrompt.buildSystemPrompt();
            String userMessage = MockDataPrompt.buildUserMessage(
                    request.getModules(), request.getIndustries(),
                    request.getCountMin(), request.getCountMax(),
                    request.getDateStart(), request.getDateEnd(),
                    request.getAdditionalInfo(),
                    productIds, productModelIds);

            String fullPrompt = systemPrompt + "\n\n" + userMessage;
            log.info("调用AI生成模拟数据, modules={}, industries={}", request.getModules(), request.getIndustries());
            String llmResponse = assistant.chat(fullPrompt);
            log.info("AI返回数据长度: {}", llmResponse != null ? llmResponse.length() : 0);

            if (llmResponse == null || llmResponse.isBlank()) {
                result.setStatus("FAILED");
                errors.add("AI未返回任何数据");
                result.setErrors(errors);
                return result;
            }

            List<JSONObject> entities = parseJsonResponse(llmResponse);
            if (entities.isEmpty()) {
                result.setStatus("FAILED");
                errors.add("无法解析AI返回的数据");
                result.setErrors(errors);
                return result;
            }

            Map<String, List<JSONObject>> grouped = entities.stream()
                    .collect(Collectors.groupingBy(e -> e.getString("entity")));

            // 名称→ID 映射表，用于创建业务单据时回填外键
            Map<String, Long> customerNameToId = new HashMap<>();
            Map<String, Long> supplierNameToId = new HashMap<>();

            // Tier 0: 基础数据
            if (grouped.containsKey("customer")) {
                ModuleSummary s = createCustomers(grouped.get("customer"), customerNameToId);
                summaries.add(s);
                totalGenerated += s.getSuccessCount();
            }
            if (grouped.containsKey("supplier")) {
                ModuleSummary s = createSuppliers(grouped.get("supplier"), supplierNameToId);
                summaries.add(s);
                totalGenerated += s.getSuccessCount();
            }
            if (grouped.containsKey("qualityTestStandard")) {
                ModuleSummary s = createQualityStandards(grouped.get("qualityTestStandard"));
                summaries.add(s);
                totalGenerated += s.getSuccessCount();
            }

            // Tier 1: 业务单据
            if (grouped.containsKey("salesLedger")) {
                ModuleSummary s = createSalesLedgers(grouped.get("salesLedger"), customerNameToId);
                summaries.add(s);
                totalGenerated += s.getSuccessCount();
            }
            if (grouped.containsKey("purchaseLedger")) {
                ModuleSummary s = createPurchaseLedgers(grouped.get("purchaseLedger"), supplierNameToId);
                summaries.add(s);
                totalGenerated += s.getSuccessCount();
            }
            if (grouped.containsKey("productionPlan")) {
                ModuleSummary s = createProductionPlans(grouped.get("productionPlan"));
                summaries.add(s);
                totalGenerated += s.getSuccessCount();
            }

            // Tier 2
            if (grouped.containsKey("productionOrder")) {
                ModuleSummary s = createProductionOrders(grouped.get("productionOrder"));
                summaries.add(s);
                totalGenerated += s.getSuccessCount();
            }
            if (grouped.containsKey("qualityTestStandardBinding")) {
                ModuleSummary s = createQualityBindings(grouped.get("qualityTestStandardBinding"));
                summaries.add(s);
                totalGenerated += s.getSuccessCount();
            }
            if (grouped.containsKey("stockInventory")) {
                ModuleSummary s = createStockInventories(grouped.get("stockInventory"));
                summaries.add(s);
                totalGenerated += s.getSuccessCount();
            }

            result.setStatus(errors.isEmpty() ? "SUCCESS" : "PARTIAL");
            result.setTotalGenerated(totalGenerated);
            result.setModuleSummaries(summaries);
            result.setErrors(errors);

        } catch (Exception e) {
            log.error("数据生成失败", e);
            result.setStatus("FAILED");
            errors.add("数据生成异常: " + e.getMessage());
            result.setErrors(errors);
        }

        return result;
    }

    private List<JSONObject> parseJsonResponse(String response) {
        try {
            String trimmed = response.trim();
            if (trimmed.startsWith("```")) {
                int start = trimmed.indexOf("\n");
                int end = trimmed.lastIndexOf("```");
                if (start > 0 && end > start) {
                    trimmed = trimmed.substring(start + 1, end).trim();
                }
            }
            return JSON.parseArray(trimmed, JSONObject.class);
        } catch (Exception e) {
            log.warn("JSON解析失败，尝试提取数组片段: {}", e.getMessage());
            int start = response.indexOf('[');
            int end = response.lastIndexOf(']');
            if (start >= 0 && end > start) {
                return JSON.parseArray(response.substring(start, end + 1), JSONObject.class);
            }
            return List.of();
        }
    }

    // ---- Tier 0: 基础数据 ----

    private ModuleSummary createCustomers(List<JSONObject> items, Map<String, Long> nameToId) {
        int success = 0, fail = 0;
        for (JSONObject item : items) {
            try {
                Customer c = new Customer();
                c.setCustomerName(item.getString("customerName"));
                c.setCustomerType(item.getString("customerType"));
                c.setContactPerson(item.getString("contactPerson"));
                c.setContactPhone(item.getString("contactPhone"));
                c.setCompanyAddress(item.getString("companyAddress"));
                c.setTaxpayerIdentificationNumber(item.getString("taxpayerIdentificationNumber"));
                customerService.insertCustomer(c);
                if (c.getId() != null) {
                    nameToId.put(c.getCustomerName(), c.getId());
                }
                success++;
            } catch (Exception e) {
                log.warn("创建客户失败: {}", e.getMessage());
                fail++;
            }
        }
        return summary("sales", "客户", items.size(), success, fail);
    }

    private ModuleSummary createSuppliers(List<JSONObject> items, Map<String, Long> nameToId) {
        int success = 0, fail = 0;
        for (JSONObject item : items) {
            try {
                SupplierManage s = new SupplierManage();
                s.setSupplierName(item.getString("supplierName"));
                s.setSupplierType(item.getString("supplierType"));
                s.setContactUserName(item.getString("contactUserName"));
                s.setContactUserPhone(item.getString("contactUserPhone"));
                s.setCompanyAddress(item.getString("companyAddress"));
                s.setTaxpayerIdentificationNum(item.getString("taxpayerIdentificationNum"));
                s.setBankAccountName(item.getString("bankAccountName"));
                s.setBankAccountNum(item.getString("bankAccountNum"));
                if (item.containsKey("isWhite")) {
                    s.setIsWhite(item.getInteger("isWhite"));
                }
                supplierService.saveSupplier(s);
                if (s.getId() != null) {
                    nameToId.put(s.getSupplierName(), s.getId());
                }
                success++;
            } catch (Exception e) {
                log.warn("创建供应商失败: {}", e.getMessage());
                fail++;
            }
        }
        return summary("purchase", "供应商", items.size(), success, fail);
    }

    private ModuleSummary createQualityStandards(List<JSONObject> items) {
        int success = 0, fail = 0;
        for (JSONObject item : items) {
            try {
                QualityTestStandard std = new QualityTestStandard();
                std.setStandardNo(item.getString("standardNo"));
                std.setStandardName(item.getString("standardName"));
                std.setInspectType(item.getInteger("inspectType"));
                std.setRemark(item.getString("remark"));
                qualityTestStandardService.save(std);
                success++;
            } catch (Exception e) {
                log.warn("创建检测标准失败: {}", e.getMessage());
                fail++;
            }
        }
        return summary("quality", "检测标准", items.size(), success, fail);
    }

    // ---- Tier 1: 业务单据 ----

    private ModuleSummary createSalesLedgers(List<JSONObject> items, Map<String, Long> customerNameToId) {
        int success = 0, fail = 0;
        for (JSONObject item : items) {
            try {
                String customerName = item.getString("customerName");
                Long customerId = customerNameToId.get(customerName);

                SalesLedgerDto dto = new SalesLedgerDto();
                dto.setCustomerId(customerId);
                dto.setCustomerName(customerName);
                dto.setProjectName(item.getString("projectName"));
                dto.setSalesman(item.getString("salesman"));
                dto.setPaymentMethod(item.getString("paymentMethod"));
                dto.setType(item.getInteger("type"));
                if (item.containsKey("entryDate")) {
                    dto.setEntryDate(java.sql.Date.valueOf(item.getString("entryDate")));
                }
                if (item.containsKey("executionDate")) {
                    dto.setExecutionDate(LocalDate.parse(item.getString("executionDate")));
                }
                if (item.containsKey("deliveryDate")) {
                    dto.setDeliveryDate(LocalDate.parse(item.getString("deliveryDate")));
                }
                JSONArray productData = item.getJSONArray("productData");
                if (productData != null) {
                    List<SalesLedgerProduct> products = new ArrayList<>();
                    for (int i = 0; i < productData.size(); i++) {
                        JSONObject pd = productData.getJSONObject(i);
                        SalesLedgerProduct slp = new SalesLedgerProduct();
                        slp.setProductId(pd.getLong("productId"));
                        slp.setProductModelId(pd.getLong("productModelId"));
                        slp.setQuantity(pd.getBigDecimal("quantity"));
                        slp.setTaxInclusiveUnitPrice(pd.getBigDecimal("taxInclusiveUnitPrice"));
                        slp.setTaxInclusiveTotalPrice(pd.getBigDecimal("taxInclusiveTotalPrice"));
                        slp.setTaxRate(pd.getBigDecimal("taxRate"));
                        slp.setUnit(pd.getString("unit"));
                        slp.setType(pd.getInteger("type"));
                        products.add(slp);
                    }
                    dto.setProductData(products);
                }
                salesLedgerService.addOrUpdateSalesLedger(dto);
                success++;
            } catch (Exception e) {
                log.warn("创建销售台账失败: {}", e.getMessage());
                fail++;
            }
        }
        return summary("sales", "销售台账", items.size(), success, fail);
    }

    private ModuleSummary createPurchaseLedgers(List<JSONObject> items, Map<String, Long> supplierNameToId) {
        int success = 0, fail = 0;
        for (JSONObject item : items) {
            try {
                String supplierName = item.getString("supplierName");
                Long supplierId = supplierNameToId.get(supplierName);

                PurchaseLedgerDto dto = new PurchaseLedgerDto();
                dto.setSupplierId(supplierId);
                dto.setSupplierName(supplierName);
                dto.setProjectName(item.getString("projectName"));
                dto.setContractAmount(item.getBigDecimal("contractAmount"));
                dto.setPaymentMethod(item.getString("paymentMethod"));
                if (item.containsKey("entryDate")) {
                    dto.setEntryDate(java.sql.Date.valueOf(item.getString("entryDate")));
                }
                if (item.containsKey("executionDate")) {
                    dto.setExecutionDate(java.sql.Date.valueOf(item.getString("executionDate")));
                }
                JSONArray productData = item.getJSONArray("productData");
                if (productData != null) {
                    List<SalesLedgerProduct> products = new ArrayList<>();
                    for (int i = 0; i < productData.size(); i++) {
                        JSONObject pd = productData.getJSONObject(i);
                        SalesLedgerProduct slp = new SalesLedgerProduct();
                        slp.setProductId(pd.getLong("productId"));
                        slp.setProductModelId(pd.getLong("productModelId"));
                        slp.setQuantity(pd.getBigDecimal("quantity"));
                        slp.setTaxInclusiveUnitPrice(pd.getBigDecimal("taxInclusiveUnitPrice"));
                        slp.setTaxInclusiveTotalPrice(pd.getBigDecimal("taxInclusiveTotalPrice"));
                        slp.setTaxRate(pd.getBigDecimal("taxRate"));
                        slp.setUnit(pd.getString("unit"));
                        slp.setType(2);
                        products.add(slp);
                    }
                    dto.setProductData(products);
                }
                purchaseLedgerService.addOrEditPurchase(dto);
                success++;
            } catch (Exception e) {
                log.warn("创建采购台账失败: {}", e.getMessage());
                fail++;
            }
        }
        return summary("purchase", "采购台账", items.size(), success, fail);
    }

    private ModuleSummary createProductionPlans(List<JSONObject> items) {
        int success = 0, fail = 0;
        for (JSONObject item : items) {
            try {
                ProductionPlan plan = new ProductionPlan();
                plan.setProductModelId(item.getLong("productModelId"));
                plan.setQtyRequired(item.getBigDecimal("qtyRequired"));
                plan.setSource(item.getString("source"));
                plan.setRemark(item.getString("remark"));
                if (item.containsKey("requiredDate")) {
                    plan.setRequiredDate(LocalDate.parse(item.getString("requiredDate")));
                }
                if (item.containsKey("promisedDeliveryDate")) {
                    plan.setPromisedDeliveryDate(LocalDate.parse(item.getString("promisedDeliveryDate")));
                }
                productionPlanService.save(plan);
                success++;
            } catch (Exception e) {
                log.warn("创建生产计划失败: {}", e.getMessage());
                fail++;
            }
        }
        return summary("production", "生产计划", items.size(), success, fail);
    }

    // ---- Tier 2: 后续单据 ----

    private ModuleSummary createProductionOrders(List<JSONObject> items) {
        int success = 0, fail = 0;
        for (JSONObject item : items) {
            try {
                ProductionOrder order = new ProductionOrder();
                order.setProductModelId(item.getLong("productModelId"));
                order.setQuantity(item.getBigDecimal("quantity"));
                if (item.containsKey("planCompleteTime")) {
                    order.setPlanCompleteTime(LocalDate.parse(item.getString("planCompleteTime")));
                }
                productionOrderService.saveProductionOrder(order);
                success++;
            } catch (Exception e) {
                log.warn("创建生产订单失败: {}", e.getMessage());
                fail++;
            }
        }
        return summary("production", "生产订单", items.size(), success, fail);
    }

    private ModuleSummary createQualityBindings(List<JSONObject> items) {
        int success = 0, fail = 0;
        for (JSONObject item : items) {
            try {
                QualityTestStandardBinding binding = new QualityTestStandardBinding();
                binding.setProductId(item.getLong("productId"));
                binding.setTestStandardId(item.getInteger("testStandardId"));
                qualityTestStandardBindingService.add(List.of(binding));
                success++;
            } catch (Exception e) {
                log.warn("创建指标绑定失败: {}", e.getMessage());
                fail++;
            }
        }
        return summary("quality", "指标绑定", items.size(), success, fail);
    }

    private ModuleSummary createStockInventories(List<JSONObject> items) {
        int success = 0, fail = 0;
        for (JSONObject item : items) {
            try {
                StockInventoryDto dto = new StockInventoryDto();
                dto.setProductModelId(item.getLong("productModelId"));
                dto.setQualitity(item.getBigDecimal("qualitity"));
                dto.setBatchNo(item.getString("batchNo"));
                dto.setWarnNum(item.getBigDecimal("warnNum"));
                dto.setRemark(item.getString("remark"));
                stockInventoryService.addstockInventory(dto);
                success++;
            } catch (Exception e) {
                log.warn("创建库存记录失败: {}", e.getMessage());
                fail++;
            }
        }
        return summary("stock", "库存记录", items.size(), success, fail);
    }

    private ModuleSummary summary(String module, String entityName, int total, int success, int fail) {
        ModuleSummary s = new ModuleSummary();
        s.setModule(module);
        s.setEntityName(entityName);
        s.setGeneratedCount(total);
        s.setSuccessCount(success);
        s.setFailCount(fail);
        return s;
    }
}