package com.yvan.logisticsModel;

import com.fasterxml.jackson.annotation.JsonIgnore;
import com.galaxis.rcs.common.entity.RcsTaskBiz;
import com.galaxis.rcs.plan.path.NavigationGraph;
import com.galaxis.rcs.task.TaskDispatchFactory;
import com.galaxis.rcs.task.TaskService;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import com.yvan.logisticsEnv.LogisticsEnv;
import com.yvan.workbench.model.entity.Vector2;
import lombok.extern.slf4j.Slf4j;
import org.clever.core.Conv;
import org.clever.core.json.JsonWrapper;

import java.util.List;
import java.util.Map;

/**
 * 物流上下文运行时
 */
@Slf4j
public class LogisticsRuntime {

    /**
     * 物流执行环境
     */
    public final LogisticsEnv logisticsEnv;

    /**
     * 任务服务
     */
    @JsonIgnore
    public TaskService taskService = new TaskService(this);

    /**
     * 任务分配服务
     */
    @JsonIgnore
    public TaskDispatchFactory taskDispatchFactory = new TaskDispatchFactory(this);

    /**
     * 物流流动单元（周转箱、托盘、纸箱等）
     */
    public final Map<String, FlowItem> flowItemMap = Maps.newHashMap();

    /**
     * 物流任务执行单元(如拣货台、小车、AGV、堆垛机、人等)
     */
    public final Map<String, ExecutorItem> executorItemMap = Maps.newHashMap();

    /**
     * AGV导航地图 车类型 t -> NavigationGraph
     */
    @JsonIgnore
    public final Map<String, NavigationGraph> executorGraphMap = Maps.newHashMap();

    /**
     * 楼层目录 catalogCode -> Floor
     */
    public final Map<String, Floor> floorMap = Maps.newHashMap();

    public LogisticsRuntime(LogisticsEnv logisticsEnv) {
        this.logisticsEnv = logisticsEnv;
    }

    /**
     * 获取当前空闲的执行器列表
     */
    public List<ExecutorItem> getFreeExecutorList() {
        List<ExecutorItem> freeExecutorList = Lists.newArrayList();
        for (ExecutorItem executorItem : executorItemMap.values()) {
            if (executorItem.isFree()) {
                freeExecutorList.add(executorItem);
            }
        }
        return freeExecutorList;
    }


    /**
     * 根据 ID 获取静态物品（如路标点、货架等）
     */
    public StaticItem getStaticItemById(String itemId) {
        // 到所有楼层寻找这个物品
        for (Floor floor : this.floorMap.values()) {
            StaticItem item = floor.itemMap.get(itemId);
            if (item != null) {
                return item;
            }
        }
        return null;
    }

    /**
     * 根据 ID 获取静态物品（如路标点、货架、地堆位等）
     */
    public StaticItem getStaticItemByLogicXY(int logicX, int logicZ) {
        // 到所有楼层寻找这个物品
        for (Floor floor : this.floorMap.values()) {
            for (StaticItem item : floor.itemMap.values()) {
                if (item.logicX == logicX && item.logicZ == logicZ) {
                    return item;
                }
            }
        }
        return null;
    }

    /**
     * 读取某个楼层的地图数据
     * 格式必须是如下模式:
     * <pre>
     * {
     *     "catalogCode": "f2",
     *     "t": "floor",
     *     "items": []
     * }
     * </pre>
     *
     * @param jw 原始 Json 读取器
     */
    public void loadMap(JsonWrapper jw) {
        if (!"floor".equals(jw.asStr("t"))) {
            throw new RuntimeException("loadMap error, not floor type: " + jw.asStr("t"));
        }
        List<Map<String, Object>> items = (List<Map<String, Object>>) jw.getInnerMap().get("items");

        Floor floor = new Floor(jw.asStr("catalogCode"));
        this.floorMap.put(floor.id, floor);

        for (Map<String, Object> itemObject : items) {
            String t = Conv.asString(itemObject.get("t"));
            BaseItem item;
            switch (t) {
                case "way":
                case "gstore":
                case "rack":
                    item = new StaticItem(itemObject);
                    floor.itemMap.put(item.getId(), (StaticItem) item);
                    break;

                case "pallet":
                case "carton":
                    item = new FlowItem(itemObject);
                    this.flowItemMap.put(item.getId(), (FlowItem) item);
                    break;

                case "cl2":
                case "clx":
                    item = new PtrAgvItem(this, itemObject);
                    this.executorItemMap.put(item.getId(), (ExecutorItem) item);
                    break;
            }
        }
    }

    public void start() {
        // 开启所有机器人的任务调度
        for (ExecutorItem executorItem : executorItemMap.values()) {
            executorItem.mapReady();
            log.info("Executor {} started", executorItem.getId());
        }

        this.taskDispatchFactory.startPolling();
    }
}