package com.sd.wln.context;

import cn.hutool.core.date.DateUtil;
import cn.hutool.core.util.ObjectUtil;
import cn.hutool.core.util.StrUtil;
import cn.hutool.extra.spring.SpringUtil;
import com.alibaba.fastjson2.JSONObject;
import com.fjhx.tenant.entity.dict.po.DictCommonData;
import com.fjhx.tenant.service.dict.DictCommonDataService;
import com.ruoyi.framework.mybatis.holder.LogicHolder;
import com.sd.business.entity.department.po.Department;
import com.sd.business.entity.order.po.OrderInfo;
import com.sd.business.entity.order.po.OrderPackageBom;
import com.sd.business.entity.order.po.OrderSku;
import com.sd.business.entity.order.po.OrderSkuBom;
import com.sd.business.entity.sku.po.SkuSpec;
import com.sd.business.service.department.DepartmentService;
import com.sd.business.service.order.OrderService;
import com.sd.business.service.sku.SkuSpecService;
import com.sd.wln.util.WlnUtil;
import lombok.Getter;
import lombok.extern.slf4j.Slf4j;

import java.util.*;
import java.util.stream.Collectors;

@Slf4j
public class OrderContext {

    private final OrderService orderService = SpringUtil.getBean(OrderService.class);
    private final DictCommonDataService dictCommonDataService = SpringUtil.getBean(DictCommonDataService.class);
    private final DepartmentService departmentService = SpringUtil.getBean(DepartmentService.class);
    private final SkuSpecService skuSpecService = SpringUtil.getBean(SkuSpecService.class);

    /**
     * 当前时间
     */
    @Getter
    private final Date endDate;

    /**
     * 万里牛订单列表
     */
    @Getter
    private final List<JSONObject> wlnOrderList;
    /**
     * 保存订单列表
     */
    @Getter
    private final List<OrderInfo> saveOrderList = new ArrayList<>();
    /**
     * 更新订单列表
     */
    @Getter
    private final List<OrderInfo> updateOrderList = new ArrayList<>();
    /**
     * 保存订单明细列表
     */
    @Getter
    private final List<OrderSku> saveOrderSkuList = new ArrayList<>();
    /**
     * 保存订单包材
     */
    @Getter
    private final List<OrderSkuBom> saveOrderSkuBomList = new ArrayList<>();
    /**
     * 保存订单包装
     */
    @Getter
    private final List<OrderPackageBom> orderPackageBomList = new ArrayList<>();
    /**
     * 近3天已存在数据库中的订单
     * key：万里牛订单uid
     * value：订单实体
     */
    private Map<String, OrderInfo> orderMap;
    /**
     * 查询事业部
     * key：仓库编码
     * value：仓库实体
     */
    private Map<String, Department> departmentMap;
    /**
     * sku规格map
     * key：万里牛sku规格id
     * value：sku规格实体
     */
    private Map<String, SkuSpec> skuSpecMap;

    public OrderContext() {
        this.endDate = new Date();
        this.wlnOrderList = selectWlnOrderList();
    }

    /**
     * 查询1天内万里牛订单
     */
    private List<JSONObject> selectWlnOrderList() {
        List<DictCommonData> warehouseCodeList = dictCommonDataService.list(q -> q.eq(DictCommonData::getDictCode, "warehouse_code"));
        if (warehouseCodeList.size() == 0) {
            log.error("订单同步失败，仓库字典:warehouse_code 为空");
            return null;
        }

        List<JSONObject> list = new ArrayList<>();

        long endTime = endDate.getTime();
        long startTime = endTime - 1000 * 60 * 60 * 24;

        for (DictCommonData dictCommonData : warehouseCodeList) {
            String warehouseCode = dictCommonData.getDictValue();
            int page = 1;
            int size;
            do {
                try {
                    List<JSONObject> itemList = WlnUtil.getOrderList(page, 200, startTime, endTime, warehouseCode);
                    page++;
                    size = itemList.size();
                    list.addAll(itemList);
                } catch (Exception e) {
                    log.error("订单同步失败", e);
                    return null;
                }
            } while (size >= 200);
        }

        return list;
    }

    /**
     * 查询近3天已存在数据库中的订单
     */
    public Map<String, OrderInfo> getOrderMap() {
        if (this.orderMap == null) {
            LogicHolder.setLogicHolder(new LogicHolder());

            this.orderMap = orderService.mapKEntity(
                    OrderInfo::getWlnUid,
                    q -> q.between(OrderInfo::getWlnApproveTime, DateUtil.offsetDay(endDate, -3), endDate));

            LogicHolder.clear();
        }

        return this.orderMap;
    }

    /**
     * 查询事业部
     */
    public Map<String, Department> getDepartmentMap() {
        if (this.departmentMap == null) {
            this.departmentMap = new HashMap<>();
            for (Department department : departmentService.list()) {
                String warehouseCode = department.getWlnWarehouseCode();
                if (StrUtil.isBlank(warehouseCode)) {
                    continue;
                }
                for (String item : warehouseCode.split(",")) {
                    this.departmentMap.put(item, department);
                }
            }
        }

        return this.departmentMap;
    }

    /**
     * 获取sku规格
     */
    public Map<String, SkuSpec> getSkuSpecMap() {
        if (this.skuSpecMap == null) {
            List<String> wlnUidList = wlnOrderList.stream()
                    .flatMap(item -> item.getJSONArray("orders").toJavaList(JSONObject.class).stream())
                    .map(item -> item.getString("sys_spec_uid"))
                    .filter(ObjectUtil::isNotNull)
                    .distinct()
                    .collect(Collectors.toList());
            this.skuSpecMap = skuSpecService.mapKEntity(SkuSpec::getWlnUid, q -> q.in(SkuSpec::getWlnUid, wlnUidList));
        }

        return this.skuSpecMap;
    }

}