package com.zy.asrs.utils;

import java.util.*;
import java.util.concurrent.atomic.AtomicReference;

import lombok.Data;

public class SchedulingCarUtil {

    private static final Map<Integer, Double> STATION_PRIORITIES =
            Collections.unmodifiableMap(new HashMap<Integer, Double>() {{
                put(5101, 0.8);
                put(5120, 0.9);
                // ...
            }});
    private static final Map<String, Double> AREA_WEIGHTS =
            Collections.unmodifiableMap(new HashMap<String, Double>() {{
                put("A", 1.2);
                put("B", 1.0);
                put("C", 0.8);
                // ...
            }});

    // 常量配置
    private static final double WAIT_THRESHOLD = 120.0; // 等待临界点(秒)
    private static final double MAX_DISTANCE = 1000.0;  // 轨道最大长度
    private static final double DIST_PENALTY = -0.5;     // 最低距离系数

    // 新增线性增长阈值和系数
    private static final double LINEAR_THRESHOLD = 300.0; // 线性增长起点(秒)
    private static final double LINEAR_FACTOR = 0.0083;    // 线性增长系数(≈0.5/60)

    private static final double LOAD_THRESHOLD = 0.7;
    private static final double ADJUSTMENT_STEP = 0.01;

    // 权重参数 (可动态调整)
    private double baseWeight = 0.40;
    private double waitWeight = 0.35;
    private double distWeight = 0.25;

    private static final double[] EXP_CACHE = new double[1800]; // 缓存0~1800秒（30分钟）
    static {
        for (int i = 0; i < EXP_CACHE.length; i++) {
            EXP_CACHE[i] = 0.8 * (1 - Math.exp(-0.02 * i));
        }
    }

    // 预计算常量
    private static final double EXP_BASE = 0.5;
    private static final double EXP_FACTOR = 3.0;

    private static class Weights {
        double base = 0.40, wait = 0.35, dist = 0.25;
    }
    private final AtomicReference<Weights> weightsRef = new AtomicReference<>(new Weights());

//    // 复用对象（线程安全）
//    private final ThreadLocal<Double> distanceCache = ThreadLocal.withInitial(() -> 0.0);
    /**
     * 计算任务综合优先级
     * @param task 当前任务对象
     * @param agv  当前小车对象
     * @return 综合优先级得分（0.0 - 1.0 ~ ∞）
     */
    public double calculatePriority(Task task, AGV agv) {
        // 1. 站点基础优先级计算
        double stationPriority = calculateStationPriority(task.getStationId());

        // 2. 任务等待时间优先级
        double waitPriority = calculateWaitPriority(task.getWaitSeconds());

        // 3. 小车距离优先级
        double distancePriority = calculateDistancePriority(
                agv.getPosition(),
                task.getTargetPosition()
        );

        applyDynamicWeightAdjustment();

        return (stationPriority * baseWeight)
                + (waitPriority * waitWeight)
                + (distancePriority * distWeight);
    }

    private void applyDynamicWeightAdjustment() {
        Weights current = weightsRef.get();
        Weights updated = new Weights();

        double loadFactor = SystemMonitor.getLoadFactor();
        if (loadFactor > LOAD_THRESHOLD) {
            waitWeight = Math.min(0.55, waitWeight + ADJUSTMENT_STEP);
            distWeight = Math.max(0.10, distWeight - ADJUSTMENT_STEP/2);
        } else if (loadFactor < LOAD_THRESHOLD - 0.05) {
            // 负载降低时逐步恢复权重
            waitWeight = Math.max(0.35, waitWeight - ADJUSTMENT_STEP);
            distWeight = Math.min(0.25, distWeight + ADJUSTMENT_STEP/2);
        }

        weightsRef.compareAndSet(current, updated); // CAS更新
    }

    /**
     * 站点基础优先级（固定值+区域权重）
     */
    private double calculateStationPriority(int stationId) {
        double basePriority = STATION_PRIORITIES.getOrDefault(stationId, 0.5);
        String area = "A";
        return basePriority * AREA_WEIGHTS.getOrDefault(area, 1.0);
    }

    /**
     * 等待时间优先级（非线性增长）
     */
    private double calculateWaitPriority(double waitSeconds) {
//        if (waitSeconds <= WAIT_THRESHOLD) {
//            return 0.2; // 基础值
//        }
//        // 等待超时后的指数增长（无峰值上限）
//        return Math.min(1.0, 0.2 + 0.8 * (1 - Math.exp(-0.02*(waitSeconds-WAIT_THRESHOLD))));

        if (waitSeconds <= WAIT_THRESHOLD) {
            return 0.2; // 基础值
        }

        double exceedSeconds = waitSeconds - WAIT_THRESHOLD;
        double expPart = (exceedSeconds < EXP_CACHE.length) ?
                EXP_CACHE[(int) exceedSeconds] :
                0.8 * (1 - Math.exp(-0.02 * exceedSeconds));

//        double exceedSeconds = waitSeconds - WAIT_THRESHOLD;
//        // 指数增长阶段（0~300秒）
//        double expPart = 0.8 * (1 - Math.exp(-0.02 * exceedSeconds));

        // 线性增长阶段（300秒后）
        double linearPart = (exceedSeconds > LINEAR_THRESHOLD) ?
                LINEAR_FACTOR * (exceedSeconds - LINEAR_THRESHOLD) : 0;

        return 0.2 + expPart + linearPart; // 突破1.0上限
    }

    /**
     * 小车距离优先级（含负向调节）
     */
    private double calculateDistancePriority(double agvPos, double stationPos) {
        // 计算轨道有效距离（考虑单向移动）
        double distance = calculateEffectiveDistance(agvPos, stationPos);
//
//        double distance = distanceCache.get();
//        if (distance == 0.0) { // 0表示未计算
//            distance = calculateEffectiveDistance(agvPos, stationPos);
//            distanceCache.set(distance);
//        }

        // 非线性衰减公式（近距离奖励，远距离惩罚）
        double ratio = distance / MAX_DISTANCE;
//        return Math.max(DIST_PENALTY, 0.5 * (Math.pow(0.5, ratio * 3) - 0.5));
        double exponentValue = Math.pow(EXP_BASE, ratio * EXP_FACTOR);
        return Math.max(DIST_PENALTY, 0.5 * (exponentValue - 0.5));
    }

    /**
     * 计算有效距离（单方向轨道逻辑）
     */
    private double calculateEffectiveDistance(double agvPos, double stationPos) {
        // 单向轨道场景：若小车已过站点，需绕行至终点再返回起点
//        if (agvPos > stationPos) {
//            return (MAX_DISTANCE - agvPos) + stationPos;
//        }
//        return stationPos - agvPos;
        return (stationPos - agvPos + MAX_DISTANCE) % MAX_DISTANCE;
    }
}

@Data
class Task {
    private int taskId;
    private int stationId;
    private double targetPosition;
    private long createTime; // 任务创建时间戳
    private static final long THIRTY_DAYS_MS = 30L * 24 * 60 * 60 * 1000;

    public double getWaitSeconds() {
        long elapsed = (System.currentTimeMillis() - createTime) ;
        // 固定为30天
        return (elapsed > THIRTY_DAYS_MS) ? (THIRTY_DAYS_MS / 1000.0) : (elapsed / 1000.0);
    }
}

@Data
class AGV {
    private int agvId;
    private double position; // 当前轨道位置(0-MAX_DISTANCE)
}

// 系统监控类（示例）
@Data
class SystemMonitor {
    public static double getLoadFactor() {
        // 实际实现中读取系统负载率
        return 0.1;
//        return LoadHolder.cachedLoad; // 定时更新，非实时读取
    }
//    private static class LoadHolder {
//        static double cachedLoad = 0.1;
//        static { ScheduledExecutorService.scheduleAtFixedRate(() ->
//                cachedLoad = realTimeLoad(), 5, 5, TimeUnit.SECONDS); }
//    }
}