package com.vincent.rsf.server.api.entity.validator;

import com.vincent.rsf.framework.common.Cools;
import com.vincent.rsf.server.api.controller.erp.params.SyncOrderParams;
import com.vincent.rsf.server.api.controller.erp.params.SyncOrdersItem;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;

import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;

@Component
@Slf4j
public class SyncOrderValidator {

    /**
     * 验证同步订单参数
     */
    public void validateSyncOrder(SyncOrderParams order) {
        if (order == null) {
            throw new IllegalArgumentException("订单参数不能为空");
        }

        // 基本验证
        if (!order.isValid()) {
            throw new IllegalArgumentException("订单参数不完整");
        }

        // 业务验证
        order.validateBusiness();

        // 验证明细
        if (order.getOrderItems() == null || order.getOrderItems().isEmpty()) {
            throw new IllegalArgumentException("订单明细不能为空");
        }

        // 检查重复行号
        Set<String> lineIds = new HashSet<>();
        for (int i = 0; i < order.getOrderItems().size(); i++) {
            SyncOrdersItem item = order.getOrderItems().get(i);
            String prefix = "第" + (i + 1) + "个明细: ";

            if (item == null) {
                throw new IllegalArgumentException(prefix + "明细为空");
            }

            // 验证行内码
            if (Cools.isEmpty(item.getLineId())) {
                throw new IllegalArgumentException(prefix + "行内码不能为空");
            }

            // 检查重复
            if (!lineIds.add(item.getLineId())) {
                throw new IllegalArgumentException(prefix + "行内码重复: " + item.getLineId());
            }

            // 业务验证
            try {
                item.validateBusiness(order.getType());
            } catch (IllegalArgumentException e) {
                throw new IllegalArgumentException(prefix + e.getMessage());
            }
        }

//        // 验证数量一致性
//        double itemsTotal = order.calculateItemsTotal();
//        if (Math.abs(itemsTotal - order.getAnfme()) > 0.001) {
//            log.warn("订单[{}] 主单数量({})与明细总数({})不一致",
//                    order.getOrderNo(), order.getAnfme(), itemsTotal);
//        }
    }

    /**
     * 验证批次订单
     */
    public void validateBatchOrders(List<SyncOrderParams> orders) {
        if (orders == null || orders.isEmpty()) {
            throw new IllegalArgumentException("订单列表不能为空");
        }

        if (orders.size() > 100) {
            throw new IllegalArgumentException("批量同步单次最多支持100个订单");
        }

        // 检查重复订单号
        Set<String> orderNos = new HashSet<>();
        Set<Long> orderInternalCodes = new HashSet<>();

        for (int i = 0; i < orders.size(); i++) {
            SyncOrderParams order = orders.get(i);
            String prefix = "第" + (i + 1) + "个订单: ";

            if (order == null) {
                throw new IllegalArgumentException(prefix + "订单为空");
            }

            // 验证订单号
            if (Cools.isEmpty(order.getOrderNo())) {
                throw new IllegalArgumentException(prefix + "订单号不能为空");
            }

            if (!orderNos.add(order.getOrderNo())) {
                throw new IllegalArgumentException(prefix + "订单号重复: " + order.getOrderNo());
            }

            // 验证单据内码
            if (order.getOrderInternalCode() == null) {
                throw new IllegalArgumentException(prefix + "单据内码不能为空");
            }

            if (!orderInternalCodes.add(order.getOrderInternalCode())) {
                throw new IllegalArgumentException(prefix + "单据内码重复: " + order.getOrderInternalCode());
            }

            // 验证单个订单
            try {
                validateSyncOrder(order);
            } catch (IllegalArgumentException e) {
                throw new IllegalArgumentException(prefix + e.getMessage());
            }
        }
    }

    /**
     * 过滤有效订单
     */
    public List<SyncOrderParams> filterValidOrders(List<SyncOrderParams> orders) {
        if (orders == null) {
            return Collections.emptyList();
        }

        return orders.stream()
                .filter(order -> order != null && order.isValid())
                .collect(Collectors.toList());
    }

    /**
     * 计算总数量
     */
//    public double calculateTotalQuantity(List<SyncOrderParams> orders) {
//        if (orders == null || orders.isEmpty()) {
//            return 0.0;
//        }
//
//        return orders.stream()
//                .mapToDouble(order -> order.getAnfme() != null ? order.getAnfme() : 0.0)
//                .sum();
//    }
}