app.py

"""
Streamlit 主入口 - 多灾难点 + 单/多路径 + GA + AI Allocation Predictor + LLM智能体模拟
- 全局容量共享（多灾难点）
- 所有方法都执行：可达性 + 容量 + 守恒 repair
- 正确重叠率 overlap_rate（edge 计数法）
运行：
streamlit run app.py --server.port 8502
"""

import time
import random
from dataclasses import dataclass
from typing import Dict, List, Any, Tuple, Optional, Any as AnyType

import numpy as np
import pandas as pd
import networkx as nx

import streamlit as st
import folium
from streamlit_folium import st_folium

# ---------------------------------------------------------
# 导入项目模块（缺失则兜底）
# ---------------------------------------------------------
try:
    from web.layout import setup_page_config, apply_custom_styles, create_header, create_footer
    from web.layout import create_sidebar_header, create_sidebar_footer
except Exception:
    def setup_page_config():
        st.set_page_config(page_title="智能应急疏散模拟系统", layout="wide", initial_sidebar_state="expanded")


    def apply_custom_styles():
        pass


    def create_header():
        st.title("🏃‍♂️ 智能应急疏散模拟系统")


    def create_footer():
        st.markdown("---")
        st.caption("Demo")


    def create_sidebar_header():
        st.sidebar.markdown("### 🎯 疏散策略配置")


    def create_sidebar_footer():
        st.sidebar.markdown("---")
        st.sidebar.info("操作指南：选灾难点/避难点 → 运行 → 看指标")

try:
    from utils.data_loader import load_graph
except Exception:
    load_graph = None

try:
    from utils.geo_utils import snap_to_graph, get_node_latlon
except Exception:
    def snap_to_graph(G, lat: float, lon: float) -> int:
        best = None
        bestd = 1e18
        for n, data in G.nodes(data=True):
            y = data.get("y", 0.0)
            x = data.get("x", 0.0)
            d = (y - lat) ** 2 + (x - lon) ** 2
            if d < bestd:
                bestd, best = d, n
        return int(best)


    def get_node_latlon(G, node_id: int) -> Tuple[float, float]:
        data = G.nodes[node_id]
        return float(data.get("y", 0.0)), float(data.get("x", 0.0))

try:
    from utils.visualization import build_base_map, add_node_marker, add_path_to_map, add_agents_to_map
except Exception:
    def build_base_map(G):
        nodes = list(G.nodes())
        if nodes:
            lat, lon = get_node_latlon(G, nodes[0])
        else:
            lat, lon = 39.968056, 116.305833
        return folium.Map(location=(lat, lon), zoom_start=16, tiles="openstreetmap")


    def add_node_marker(G, fmap, node_id: int, color: str, text: str, icon: str = "info-sign"):
        lat, lon = get_node_latlon(G, node_id)
        folium.Marker(location=(lat, lon), popup=text, icon=folium.Icon(color=color, icon=icon)).add_to(fmap)


    def add_path_to_map(G, fmap, path: List[int], color="blue", weight=5, popup_text=None, opacity=0.8):
        coords = [get_node_latlon(G, n) for n in path]
        folium.PolyLine(locations=coords, color=color, weight=weight, opacity=opacity, popup=popup_text).add_to(fmap)


    def add_agents_to_map(G, fmap, agents: List[Dict[str, Any]]):
        pass

try:
    from planning.multi_objective import ga_optimize_allocation, precompute_paths
except Exception:
    ga_optimize_allocation = None
    precompute_paths = None

# 导入智能体模拟模块
try:
    from simulation.llm_agent import LLMAgentSimulator

    LLM_AVAILABLE = True
except Exception:
    LLMAgentSimulator = None
    LLM_AVAILABLE = False
    print("警告：LLM智能体模拟模块导入失败")

try:
    from config import (
        DEFAULT_TOTAL_PEOPLE,
        DEFAULT_SHELTER_CAPACITY,
        COLOR_SCHEME,
        LAYOUT_CONFIG,
        FOLIUM_COLORS,
        LLM_CONFIG,
        AGENT_GENERATION_CONFIG
    )
except Exception:
    DEFAULT_TOTAL_PEOPLE = 1000
    DEFAULT_SHELTER_CAPACITY = 200
    COLOR_SCHEME = {
        "disaster": "red",
        "shelter": "green",
        "agent": "blue",
        "agent_child": "#339AF0",
        "agent_adult": "#FF922B",
        "agent_elderly": "#845EF7",
        "agent_panicked": "#FF6B6B",
        "agent_nervous": "#FFD93D",
        "agent_calm": "#6BCF7F",
        "path_single": "blue",
        "path_multi_1": "purple",
        "path_multi_2": "orange",
        "path_multi_3": "darkred",
        "risk_edge": "red",
        "risk_edge_mid": "orange",
        "simulation_bg": "#F8F9FA",
        "panel_bg": "#FFFFFF",
    }
    FOLIUM_COLORS = [
        "red", "blue", "green", "purple", "orange", "darkred",
        "lightred", "beige", "darkblue", "darkgreen", "cadetblue",
        "darkpurple", "white", "pink", "lightblue", "lightgreen",
        "gray", "black", "lightgray"
    ]
    LAYOUT_CONFIG = {"map_height": 600}
    LLM_CONFIG = {}
    AGENT_GENERATION_CONFIG = {}


# ---------------------------------------------------------
# ✅ 兼容 GA 返回值
# ---------------------------------------------------------
def safe_unpack_ga_result(res: AnyType) -> Tuple[List[Dict[str, Any]], Dict[str, Any]]:
    if res is None:
        return [], {}
    if isinstance(res, tuple):
        best_paths = res[0] if len(res) >= 1 else []
        best_metrics = res[1] if len(res) >= 2 and isinstance(res[1], dict) else {}
        return best_paths or [], best_metrics or {}
    if isinstance(res, dict):
        bp = res.get("best_paths", res.get("paths", []))
        bm = res.get("best_metrics", res.get("metrics", {}))
        return bp or [], bm or {}
    return [], {}


# ---------------------------------------------------------
# ✅ 正确重叠率：edge 计数法（修复你一直 0 的 bug）
# ---------------------------------------------------------
from collections import Counter


def _path_edge_set_undirected(path: List[int]) -> set:
    s = set()
    if not path or len(path) < 2:
        return s
    for u, v in zip(path[:-1], path[1:]):
        s.add((min(u, v), max(u, v)))
    return s


def enrich_path_infos_with_overlap(path_infos: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
    edge_sets = [_path_edge_set_undirected(info.get("path", [])) for info in path_infos]
    cnt = Counter()
    for es in edge_sets:
        for e in es:
            cnt[e] += 1

    for info, es in zip(path_infos, edge_sets):
        info["edge_count"] = int(len(es))
        if len(es) == 0:
            info["shared_edge_count"] = 0
            info["overlap_rate"] = 0.0
        else:
            shared = sum(1 for e in es if cnt[e] > 1)
            info["shared_edge_count"] = int(shared)
            info["overlap_rate"] = float(shared / max(1, len(es)))
    return path_infos


# ---------------------------------------------------------
# 可达性判断
# ---------------------------------------------------------
def is_reachable_path(info: Dict[str, Any]) -> bool:
    path = info.get("path", [])
    L = info.get("length", None)
    if path is None or len(path) < 2:
        return False
    if L is None:
        return False
    try:
        return np.isfinite(float(L)) and float(L) > 0 and bool(info.get("reachable", True))
    except Exception:
        return False


# ---------------------------------------------------------
# ✅ 统一 repair：可达性 + 容量 + 守恒（支持容量不足 leftover）
# （所有策略都必须走它）
# ---------------------------------------------------------
def repair_allocation_with_capacity_and_reachability(
        path_infos: List[Dict[str, Any]],
        alloc: List[int],
        total_people: int,
        shelter_caps: Dict[int, int],
        redistribute: str = "heuristic",  # "heuristic" or "remaining_capacity"
        p: float = 1.3,
        overlap_penalty: float = 0.6,
) -> Tuple[List[int], int]:
    k = len(path_infos)
    if k == 0:
        return [], int(total_people)

    a = np.array([max(0, int(x)) for x in alloc], dtype=np.int64)
    if a.shape[0] != k:
        a = np.resize(a, k)
        a = np.maximum(a, 0)

    reachable = np.array([is_reachable_path(info) for info in path_infos], dtype=bool)
    caps = np.array([int(shelter_caps.get(int(info["target"]), DEFAULT_SHELTER_CAPACITY)) for info in path_infos],
                    dtype=np.int64)
    caps[~reachable] = 0

    # clamp
    a[~reachable] = 0
    a = np.minimum(a, caps)

    assigned = int(a.sum())
    leftover = int(total_people - assigned)

    # 若超配（理论上少见，但防御）
    if leftover < 0:
        need = -leftover
        while need > 0 and int(a.sum()) > total_people:
            j = int(np.argmax(a))
            if a[j] <= 0:
                break
            a[j] -= 1
            need -= 1
        assigned = int(a.sum())
        leftover = int(total_people - assigned)

    # redistribute
    if leftover > 0:
        space = caps - a
        if int(space.sum()) > 0:
            if redistribute == "remaining_capacity":
                w = space.astype(np.float64)
            else:
                # cap/(length^p) * (1 - overlap_penalty*overlap)
                w = []
                for i, info in enumerate(path_infos):
                    if space[i] <= 0:
                        w.append(0.0)
                        continue
                    L = float(info.get("length", 1e9))
                    L = max(1.0, L) if np.isfinite(L) else 1e9
                    cap = float(caps[i])
                    ov = float(info.get("overlap_rate", 0.0))
                    ov_factor = max(0.05, 1.0 - overlap_penalty * ov)
                    w.append((cap / (L ** p)) * ov_factor)
                w = np.array(w, dtype=np.float64)
                if w.sum() <= 1e-12:
                    w = space.astype(np.float64)

            w = w / max(1e-12, w.sum())
            add = np.floor(w * leftover).astype(np.int64)
            add = np.minimum(add, space)
            a += add
            leftover -= int(add.sum())

            while leftover > 0 and int((caps - a).sum()) > 0:
                j = int(np.argmax(caps - a))
                if caps[j] - a[j] <= 0:
                    break
                a[j] += 1
                leftover -= 1

    return a.astype(int).tolist(), int(max(0, leftover))


# ---------------------------------------------------------
# 生成 path_infos（含不可达）
# ---------------------------------------------------------
def make_path_infos(G: nx.Graph, source: int, shelters: List[int]) -> List[Dict[str, Any]]:
    infos: List[Dict[str, Any]] = []
    if precompute_paths is not None:
        infos = precompute_paths(G, source, shelters)  # 模块版包含 reachable/overlap
        # 保险：再 enrich 一次（不破坏）
        return enrich_path_infos_with_overlap(infos)

    for t in shelters:
        try:
            path = nx.shortest_path(G, source, t, weight="length")
            length = nx.shortest_path_length(G, source, t, weight="length")
            reachable = bool(path) and len(path) >= 2 and np.isfinite(float(length))
        except Exception:
            path = []
            length = float("inf")
            reachable = False

        infos.append({"target": int(t), "path": path, "length": float(length), "reachable": bool(reachable)})

    return enrich_path_infos_with_overlap(infos)


# ---------------------------------------------------------
# 启发式 allocation（带 overlap 惩罚）
# ---------------------------------------------------------
def heuristic_allocation(
        path_infos: List[Dict[str, Any]],
        total_people: int,
        shelter_caps: Dict[int, int],
        p: float = 1.3,
        overlap_penalty: float = 0.6,
) -> Tuple[List[int], int]:
    w = []
    for info in path_infos:
        if not is_reachable_path(info):
            w.append(0.0)
            continue
        L = max(1.0, float(info.get("length", 1e9)))
        cap = float(shelter_caps.get(int(info["target"]), DEFAULT_SHELTER_CAPACITY))
        ov = float(info.get("overlap_rate", 0.0))
        ov_factor = max(0.05, 1.0 - overlap_penalty * ov)
        w.append((cap / (L ** p)) * ov_factor)

    w = np.array(w, dtype=np.float64)
    if w.sum() <= 1e-12:
        alloc0 = [0] * len(path_infos)
        return alloc0, int(total_people)

    w = w / w.sum()
    alloc = np.floor(w * total_people).astype(int).tolist()
    diff = int(total_people - sum(alloc))
    while diff > 0:
        alloc[int(np.argmax(w))] += 1
        diff -= 1

    return repair_allocation_with_capacity_and_reachability(
        path_infos, alloc, total_people, shelter_caps, redistribute="heuristic", p=p, overlap_penalty=overlap_penalty
    )


# ---------------------------------------------------------
# AI Predictor（GA 当老师）
# ---------------------------------------------------------
FEATURE_NAMES = [
    "bias",
    "log1p(length)",
    "overlap_rate",
    "log1p(edge_count)",
    "log1p(capacity)",
    "overlap*log1p(length)",
    "reachable_flag"
]


def build_path_feature_matrix(path_infos: List[Dict[str, Any]], capacities: Dict[int, int]) -> np.ndarray:
    feats = []
    for info in path_infos:
        L = float(info.get("length", 0.0))
        ov = float(info.get("overlap_rate", 0.0))
        ec = float(info.get("edge_count", max(0, len(info.get("path", [])) - 1)))
        cap = float(capacities.get(int(info["target"]), DEFAULT_SHELTER_CAPACITY))
        reachable = 1.0 if is_reachable_path(info) else 0.0
        feats.append([
            1.0,
            np.log1p(max(0.0, L if np.isfinite(L) else 1e9)),
            ov,
            np.log1p(max(0.0, ec)),
            np.log1p(max(0.0, cap)),
            ov * np.log1p(max(0.0, L if np.isfinite(L) else 1e9)),
            reachable,
        ])
    return np.asarray(feats, dtype=np.float32)


def softmax(x: np.ndarray) -> np.ndarray:
    x = x - np.max(x)
    e = np.exp(x)
    s = np.sum(e)
    return e / max(1e-12, s)


@dataclass
class AllocationPredictorModel:
    w: np.ndarray
    loss_history: List[float]


def predict_allocation_from_model(
        path_infos: List[Dict[str, Any]],
        total_people: int,
        shelter_caps: Dict[int, int],
        model: AllocationPredictorModel
) -> Tuple[List[int], int]:
    X = build_path_feature_matrix(path_infos, shelter_caps)
    scores = X @ model.w
    shares = softmax(scores)

    alloc = np.round(shares * total_people).astype(int).tolist()
    # 统一 repair（保证：不可达/容量/守恒）
    return repair_allocation_with_capacity_and_reachability(
        path_infos, alloc, total_people, shelter_caps, redistribute="heuristic"
    )


def train_allocation_predictor(
        teacher_samples: List[Tuple[np.ndarray, np.ndarray]],
        lr: float = 0.2,
        epochs: int = 120,
        l2: float = 1e-3
) -> AllocationPredictorModel:
    if not teacher_samples:
        w = np.zeros((len(FEATURE_NAMES),), dtype=np.float32)
        return AllocationPredictorModel(w=w, loss_history=[0.0])

    d = teacher_samples[0][0].shape[1]
    w = np.zeros((d,), dtype=np.float32)
    loss_hist = []

    for _ in range(epochs):
        total_loss = 0.0
        grad = np.zeros_like(w)

        for X, y_share in teacher_samples:
            scores = X @ w
            p = softmax(scores)
            diff = (p - y_share)
            loss = float(np.mean(diff ** 2))
            total_loss += loss

            # softmax Jacobian * MSE grad（轻量够用）
            J = np.diag(p) - np.outer(p, p)
            dp = (2.0 / len(p)) * diff
            ds = J @ dp
            grad += X.T @ ds

        total_loss /= max(1, len(teacher_samples))
        grad = grad / max(1, len(teacher_samples)) + l2 * w

        w -= lr * grad.astype(np.float32)
        loss_hist.append(total_loss)

        if len(loss_hist) > 20 and abs(loss_hist[-1] - loss_hist[-20]) < 1e-6:
            break

    return AllocationPredictorModel(w=w, loss_history=loss_hist)


# ---------------------------------------------------------
# 多灾难点评估（全局拥堵/距离）
# ---------------------------------------------------------
def evaluate_multi_disaster(per_plans: List[Dict[str, Any]]) -> Dict[str, float]:
    edge_loads = {}
    total_distance = 0.0
    makespan = 0.0

    for plan in per_plans:
        path_infos = plan["path_infos"]
        allocation = plan["allocation"]

        for alloc_n, info in zip(allocation, path_infos):
            n = int(alloc_n)
            if n <= 0:
                continue
            if not is_reachable_path(info):
                continue
            L = float(info["length"])
            if not np.isfinite(L):
                continue

            total_distance += n * L
            makespan = max(makespan, L)

            for u, v in zip(info["path"][:-1], info["path"][1:]):
                key = (min(u, v), max(u, v))
                edge_loads[key] = edge_loads.get(key, 0) + n

    max_cong = float(max(edge_loads.values())) if edge_loads else 0.0
    return {
        "makespan": float(makespan),
        "total_distance": float(total_distance),
        "max_congestion": float(max_cong),
    }


# ---------------------------------------------------------
# 输出表格：每个灾难点（所有策略都用）
# ---------------------------------------------------------
def build_detail_table(
        G: nx.Graph,
        source: int,
        N: int,
        shelters: List[int],
        path_infos: List[Dict[str, Any]],
        alloc: List[int],
        caps_used: Dict[int, int],
        leftover: int,
        method: str,
) -> pd.DataFrame:
    rows = []
    for idx, (info, n) in enumerate(zip(path_infos, alloc), start=1):
        t = int(info["target"])
        L = float(info.get("length", float("inf")))
        ov = float(info.get("overlap_rate", 0.0))
        ec = int(info.get("edge_count", 0))
        shared = int(info.get("shared_edge_count", 0))
        cap = int(caps_used.get(t, DEFAULT_SHELTER_CAPACITY))
        reachable = bool(is_reachable_path(info))

        try:
            lat, lon = get_node_latlon(G, t)
            coord = f"{lat:.6f},{lon:.6f}"
        except Exception:
            coord = ""

        rows.append({
            "方法": method,
            "灾难点": int(source),
            "总人数N": int(N),
            "未安置人数": int(leftover),
            "路径编号": int(idx),
            "避难点节点": int(t),
            "可达": "✅" if reachable else "❌",
            "避难点容量(本轮可用)": int(cap),
            "分配人数": int(n),
            "占比": float(n) / max(1, int(N)),
            "路径长度(m)": float(L) if np.isfinite(L) else np.nan,
            "边数": int(ec),
            "共享边数": int(shared),
            "重叠率": float(ov),
            "人公里(people-km)": (float(n) * float(L) / 1000.0) if (reachable and np.isfinite(L)) else 0.0,
            "避难点坐标": coord,
        })
    df = pd.DataFrame(rows)
    df = df.sort_values(["分配人数", "路径长度(m)"], ascending=[False, True], na_position="last").reset_index(drop=True)
    return df


# ---------------------------------------------------------
# 智能体模拟函数
# ---------------------------------------------------------
def run_llm_agent_simulation():
    """运行LLM智能体模拟"""
    if not LLM_AVAILABLE or LLMAgentSimulator is None:
        st.error("LLM智能体模块不可用，请检查依赖安装和配置")
        return

    shelters = [int(x) for x in st.session_state.shelter_nodes]
    disasters = [int(x) for x in st.session_state.disaster_nodes]

    if not disasters or not shelters:
        st.error("请先设置灾难点和避难点")
        return

    # 初始化模拟器
    simulator = LLMAgentSimulator(G, LLM_CONFIG)

    # 生成智能体
    total_people = sum(int(v) for v in st.session_state.disaster_people.values())
    agent_count = min(st.session_state.agent_count, total_people) if total_people > 0 else st.session_state.agent_count

    agents = simulator.generate_random_agents(
        num_agents=agent_count,
        start_nodes=disasters,
        shelter_nodes=shelters,
        config=AGENT_GENERATION_CONFIG
    )

    st.session_state.llm_simulator = simulator
    st.session_state.simulation_agents = agents
    st.session_state.simulation_steps = []
    st.session_state.current_simulation_step = 0
    st.session_state.simulation_edge_congestion = {}

    # 运行模拟
    progress_bar = st.progress(0)
    status_text = st.empty()
    results_container = st.container()

    try:
        for step in range(st.session_state.max_simulation_steps):
            status_text.text(f"模拟步骤: {step + 1}/{st.session_state.max_simulation_steps}")
            progress_bar.progress((step + 1) / st.session_state.max_simulation_steps)

            # 运行一步模拟
            step_result = simulator.run_simulation_step(
                current_step=step,
                edge_congestion=st.session_state.simulation_edge_congestion
            )

            st.session_state.simulation_steps.append(step_result)
            st.session_state.current_simulation_step = step

            # 检查是否所有智能体都已到达
            if step_result.get("active_agents", 0) == 0:
                status_text.text(f"模拟完成！所有智能体已到达避难所。")
                break

            time.sleep(0.1)  # 稍微延迟以便观察

        # 计算统计信息
        st.session_state.agent_statistics = simulator.get_agent_statistics()

        # 准备结果
        st.session_state.simulation_results = {
            "total_steps": len(st.session_state.simulation_steps),
            "statistics": st.session_state.agent_statistics,
            "steps": st.session_state.simulation_steps
        }

        with results_container:
            display_simulation_results()

    except Exception as e:
        st.error(f"模拟运行失败: {str(e)}")
    finally:
        st.session_state.is_simulation_running = False


def display_simulation_results():
    """显示智能体模拟结果"""
    if not st.session_state.simulation_results:
        return

    stats = st.session_state.agent_statistics or {}

    st.markdown("### 📊 智能体模拟结果")

    # 总体统计
    cols = st.columns(4)
    with cols[0]:
        st.metric("总智能体数", stats.get("total_agents", 0))
    with cols[1]:
        st.metric("已到达数", stats.get("arrived_agents", 0))
    with cols[2]:
        st.metric("到达率", f"{stats.get('arrival_rate', 0) * 100:.1f}%")
    with cols[3]:
        st.metric("平均步数", f"{stats.get('avg_steps', 0):.1f}")

    # 详细统计
    if stats.get("age_statistics"):
        st.markdown("#### 按年龄组统计")
        age_stats = stats.get("age_statistics", {})
        age_df = pd.DataFrame.from_dict(age_stats, orient='index')
        st.dataframe(age_df, use_container_width=True)

    if stats.get("panic_statistics"):
        st.markdown("#### 按恐慌程度统计")
        panic_stats = stats.get("panic_statistics", {})
        panic_df = pd.DataFrame.from_dict(panic_stats, orient='index')
        st.dataframe(panic_df, use_container_width=True)

    # 模拟步骤可视化
    if st.session_state.simulation_steps:
        import plotly.graph_objects as go
        steps_df = pd.DataFrame(st.session_state.simulation_steps)

        fig = go.Figure()
        fig.add_trace(go.Scatter(
            x=steps_df["step"],
            y=steps_df["active_agents"],
            mode='lines+markers',
            name='活跃智能体数'
        ))
        fig.add_trace(go.Scatter(
            x=steps_df["step"],
            y=steps_df["arrived_agents"],
            mode='lines+markers',
            name='已到达智能体数'
        ))
        fig.update_layout(
            title="模拟进度",
            xaxis_title="步骤",
            yaxis_title="智能体数",
            height=300,
            template="plotly_white"
        )
        st.plotly_chart(fig, use_container_width=True)


# ---------------------------------------------------------
# 页面初始化
# ---------------------------------------------------------
setup_page_config()
apply_custom_styles()


@st.cache_data(show_spinner=True)
def get_graph_cached():
    if load_graph is None:
        raise RuntimeError("utils.data_loader.load_graph 不可用，请确认你的项目结构。")
    return load_graph()


G = get_graph_cached()
create_header()


# ---------------------------------------------------------
# Session State
# ---------------------------------------------------------
def ss_init():
    defaults = {
        "disaster_nodes": [],
        "disaster_people": {},

        "shelter_nodes": [],
        "shelter_capacities": {},

        "current_mode": "选择灾难点(可多个)",
        "strategy_type": "多目标优化(GA)",

        "result_info": "",
        "result_paths": [],
        "simulation_completed": False,
        "simulation_running": False,

        "ga_pop_size": 40,
        "ga_generations": 80,

        # AI训练
        "auto_train_ai": True,
        "teacher_samples": 12,
        "teacher_ga_pop": 20,
        "teacher_ga_gen": 35,
        "ai_lr": 0.2,
        "ai_epochs": 120,

        "teacher_time": None,
        "train_time": None,
        "ai_model": None,
        "ai_loss_history": None,
        "ai_weights": None,

        # 对比
        "compare_table": None,
        "ga_time": None,
        "ai_time": None,

        # ✅ 所有策略都输出详细表
        "detail_tables": [],
        "detail_summary": None,

        # leftover
        "unassigned_total": 0,

        # 智能体模拟状态
        "llm_simulator": None,
        "simulation_agents": [],
        "simulation_steps": [],
        "current_simulation_step": 0,
        "is_simulation_running": False,
        "simulation_edge_congestion": {},
        "agent_statistics": None,
        "simulation_results": None,

        # 智能体生成参数
        "agent_count": 20,
        "max_simulation_steps": 50,
        "use_llm_decision": True,
    }
    for k, v in defaults.items():
        if k not in st.session_state:
            st.session_state[k] = v


def ss_reset_results():
    st.session_state.result_info = ""
    st.session_state.result_paths = []
    st.session_state.simulation_completed = False
    st.session_state.compare_table = None
    st.session_state.ga_time = None
    st.session_state.ai_time = None
    st.session_state.detail_tables = []
    st.session_state.detail_summary = None
    st.session_state.unassigned_total = 0
    # 不清除智能体模拟相关状态


ss_init()


# ---------------------------------------------------------
# AI 训练（GA 当老师）——teacher 也走 repair（避免学到非法分配）
# ---------------------------------------------------------
def train_models_if_needed():
    if st.session_state.ai_model is not None:
        return
    shelters = [int(x) for x in st.session_state.shelter_nodes]
    if not shelters:
        return

    base_caps = {int(k): int(v) for k, v in
                 st.session_state.shelter_capacities.items()} if st.session_state.shelter_capacities else {}
    if not base_caps:
        # 没设就给默认
        base_caps = {s: DEFAULT_SHELTER_CAPACITY for s in shelters}

    sources_pool = st.session_state.disaster_nodes[:] if st.session_state.disaster_nodes else list(G.nodes())
    if not sources_pool:
        return

    teacher_samples = []
    t0 = time.perf_counter()

    for _ in range(int(st.session_state.teacher_samples)):
        s = int(random.choice(sources_pool))
        N = int(max(100, random.choice([500, 800, 1000, 1500, 2000, 3000])))

        path_infos = make_path_infos(G, s, shelters)

        # teacher = GA，否则启发式
        if ga_optimize_allocation is None:
            alloc, leftover = heuristic_allocation(path_infos, N, base_caps)
        else:
            try:
                # 给 GA 一些 seed（启发式 + 纯随机）
                seed1, _ = heuristic_allocation(path_infos, N, base_caps)
                seeds = [seed1]
                res = ga_optimize_allocation(
                    G, s, shelters, total_people=N,
                    pop_size=int(st.session_state.teacher_ga_pop),
                    generations=int(st.session_state.teacher_ga_gen),
                    shelter_capacities=base_caps,
                    init_allocations=seeds,
                )
                best_paths, _m = safe_unpack_ga_result(res)
                if not best_paths:
                    alloc, leftover = heuristic_allocation(path_infos, N, base_caps)
                else:
                    mp = {int(x.get("target", x.get("shelter", -1))): int(x.get("people", 0)) for x in best_paths}
                    alloc0 = [mp.get(int(tt), 0) for tt in shelters]
                    alloc, leftover = repair_allocation_with_capacity_and_reachability(path_infos, alloc0, N, base_caps)
            except Exception:
                alloc, leftover = heuristic_allocation(path_infos, N, base_caps)

        # y_share：只对已分配部分学习（leftover 不参与比例）
        assigned = max(1, N - leftover)
        y_share = (np.array(alloc, dtype=np.float32) / float(assigned))
        if float(y_share.sum()) <= 1e-9:
            continue
        y_share = y_share / float(y_share.sum())

        X = build_path_feature_matrix(path_infos, base_caps)
        teacher_samples.append((X, y_share))

    st.session_state.teacher_time = float(time.perf_counter() - t0)

    t1 = time.perf_counter()
    model = train_allocation_predictor(
        teacher_samples,
        lr=float(st.session_state.ai_lr),
        epochs=int(st.session_state.ai_epochs),
        l2=1e-3
    )
    st.session_state.train_time = float(time.perf_counter() - t1)
    st.session_state.ai_model = model
    st.session_state.ai_loss_history = model.loss_history
    st.session_state.ai_weights = model.w.copy()


# ---------------------------------------------------------
# 侧边栏
# ---------------------------------------------------------
with st.sidebar:
    create_sidebar_header()

    st.markdown("### 🏃‍♀️ 疏散策略")
    options = ["单一路径", "多路径分流", "多目标优化(GA)", "AI预测(Allocation Predictor)", "LLM智能体模拟"]
    st.session_state.strategy_type = st.selectbox(
        "选择疏散策略类型：",
        options,
        index=options.index(st.session_state.strategy_type) if st.session_state.strategy_type in options else 2
    )

    st.markdown("---")
    st.markdown("### ⚙️ 地图点击模式")
    st.session_state.current_mode = st.radio(
        "地图点击模式：",
        ["选择灾难点(可多个)", "添加/设置避难点"],
        index=0 if st.session_state.current_mode.startswith("选择灾难点") else 1
    )

    st.markdown("---")
    st.markdown("### 🔥 多灾难点人数设置")

    total_people = 0
    if st.session_state.disaster_nodes:
        for i, s in enumerate(st.session_state.disaster_nodes):
            key = str(s)
            ppl = int(st.session_state.disaster_people.get(key, 100))
            new_p = st.number_input(
                f"灾难点{i + 1} (节点{s}) 人数",
                min_value=0, max_value=100000,
                value=int(ppl),
                step=10,
                key=f"ppl_{key}"
            )
            st.session_state.disaster_people[key] = int(new_p)
            total_people += int(new_p)
    else:
        st.caption("还未设置灾难点（点击地图添加）")

    st.metric("自动汇总总疏散人数", int(total_people))

    st.markdown("---")
    st.markdown("### 🏠 避难点容量设置")
    if st.session_state.shelter_nodes:
        for idx, shelter in enumerate(st.session_state.shelter_nodes):
            skey = str(shelter)
            cur_cap = int(st.session_state.shelter_capacities.get(skey, DEFAULT_SHELTER_CAPACITY))
            new_cap = st.number_input(
                f"避难点{idx + 1} (节点{shelter}) 容量",
                min_value=0, max_value=200000,
                value=cur_cap, step=10,
                key=f"cap_{shelter}_{idx}"
            )
            st.session_state.shelter_capacities[skey] = int(new_cap)
    else:
        st.caption("还未设置避难点（点击地图添加）")

    total_capacity = sum(
        int(v) for v in st.session_state.shelter_capacities.values()) if st.session_state.shelter_capacities else 0
    st.metric("避难点总容量", int(total_capacity))
    if total_people > 0 and total_capacity > 0 and total_capacity < total_people:
        st.error(f"⚠️ 容量不足：总容量 {total_capacity} < 总疏散人数 {total_people}（将产生未安置人数）")

    # 根据选择的策略类型显示不同的参数
    st.markdown("---")

    if st.session_state.strategy_type == "多目标优化(GA)":
        st.markdown("### 🧬 GA 参数")
        st.session_state.ga_pop_size = st.slider("种群大小", 10, 120, int(st.session_state.ga_pop_size), 5)
        st.session_state.ga_generations = st.slider("迭代代数", 10, 250, int(st.session_state.ga_generations), 10)

    elif st.session_state.strategy_type == "AI预测(Allocation Predictor)":
        st.markdown("### 🤖 AI 模型（GA当老师）")
        st.session_state.auto_train_ai = st.checkbox("运行策略时若未训练则自动训练",
                                                     value=bool(st.session_state.auto_train_ai))
        st.session_state.teacher_samples = st.slider("teacher 样本数", 4, 40, int(st.session_state.teacher_samples), 2)
        st.session_state.teacher_ga_pop = st.slider("teacher GA 种群", 10, 60, int(st.session_state.teacher_ga_pop), 5)
        st.session_state.teacher_ga_gen = st.slider("teacher GA 代数", 10, 120, int(st.session_state.teacher_ga_gen), 5)
        st.session_state.ai_lr = st.slider("AI 学习率", 0.01, 0.8, float(st.session_state.ai_lr), 0.01)
        st.session_state.ai_epochs = st.slider("AI 训练轮数", 30, 400, int(st.session_state.ai_epochs), 10)

    elif st.session_state.strategy_type == "LLM智能体模拟":
        st.markdown("### 🤖 智能体模拟参数")

        if not LLM_AVAILABLE:
            st.warning("LLM模块不可用，请检查dashscope库安装和API配置")

        st.session_state.agent_count = st.slider(
            "智能体数量",
            min_value=5,
            max_value=AGENT_GENERATION_CONFIG.get("max_agents_per_simulation", 100),
            value=st.session_state.agent_count,
            step=5
        )

        st.session_state.max_simulation_steps = st.slider(
            "最大模拟步数",
            min_value=10,
            max_value=200,
            value=st.session_state.max_simulation_steps,
            step=10
        )

        st.session_state.use_llm_decision = st.checkbox(
            "使用LLM决策（如不可用则使用启发式）",
            value=st.session_state.use_llm_decision
        )

        # 显示LLM配置信息
        if LLM_CONFIG.get("api_key"):
            st.info("✅ LLM API已配置")
        else:
            st.warning("⚠️ LLM API未配置，请设置QIANWEN_API_KEY环境变量")

    else:  # 单一路径或多路径分流
        st.markdown("### ⚙️ 策略参数")
        st.info(f"当前选择: {st.session_state.strategy_type}")
        st.caption("该策略使用固定分配规则，无需额外参数配置。")

    st.markdown("---")
    colA, colB = st.columns(2)
    with colA:
        if st.button("🧹 清空设置", use_container_width=True):
            st.session_state.disaster_nodes = []
            st.session_state.disaster_people = {}
            st.session_state.shelter_nodes = []
            st.session_state.shelter_capacities = {}
            ss_reset_results()
            st.rerun()
    with colB:
        can_run = bool(st.session_state.disaster_nodes) and bool(st.session_state.shelter_nodes)
        if st.session_state.strategy_type == "LLM智能体模拟":
            # 智能体模拟不需要人数 > 0，只需要有点
            run_disabled = not can_run
        else:
            run_disabled = not (can_run and total_people > 0)

        if st.button("🎯 运行", type="primary", use_container_width=True, disabled=run_disabled):
            ss_reset_results()
            st.session_state.simulation_running = True
            st.rerun()

    create_sidebar_footer()

# ---------------------------------------------------------
# 地图显示 + 点击交互
# ---------------------------------------------------------
st.markdown("## 🗺️ 地图交互区")

current_map = build_base_map(G)

# 灾难点
for idx, d in enumerate(st.session_state.disaster_nodes):
    color = FOLIUM_COLORS[idx % len(FOLIUM_COLORS)]
    add_node_marker(G, current_map, d, color=color, text=f"灾难点{idx + 1} 节点{d}", icon="fire")

# 避难点
for idx, s in enumerate(st.session_state.shelter_nodes):
    cap = int(st.session_state.shelter_capacities.get(str(s), DEFAULT_SHELTER_CAPACITY))
    add_node_marker(G, current_map, s, color=COLOR_SCHEME.get("shelter", "green"),
                    text=f"避难点{idx + 1} 节点{s} 容量{cap}", icon="home")

# 结果路径
if st.session_state.simulation_completed and st.session_state.result_paths:
    for info in st.session_state.result_paths:
        add_path_to_map(
            G, current_map,
            info["path"],
            color=info.get("color", COLOR_SCHEME.get("path_single", "blue")),
            weight=int(info.get("weight", 5)),
            popup_text=info.get("popup", None),
        )

# 智能体显示
if st.session_state.simulation_agents:
    agents_for_display = []
    for agent in st.session_state.simulation_agents:
        agents_for_display.append({
            "id": agent.id,
            "current_node": agent.current_node,
            "age_group": agent.age_group,
            "panic_level": agent.panic_level,
            "target_shelter": agent.target_shelter,
            "has_arrived": agent.has_arrived,
            "steps_taken": agent.steps_taken,
            "total_distance": agent.total_distance
        })
    add_agents_to_map(G, current_map, agents_for_display)

map_data = st_folium(
    current_map,
    height=LAYOUT_CONFIG.get("map_height", 600),
    use_container_width=True,
    returned_objects=["last_clicked"],
    key="main_map"
)

# 点击添加点
if map_data and map_data.get("last_clicked") is not None:
    lat = map_data["last_clicked"]["lat"]
    lon = map_data["last_clicked"]["lng"]
    nearest_node = int(snap_to_graph(G, lat, lon))

    if st.session_state.current_mode.startswith("选择灾难点"):
        if nearest_node not in st.session_state.disaster_nodes:
            st.session_state.disaster_nodes.append(nearest_node)
            st.session_state.disaster_people[str(nearest_node)] = int(100)
            ss_reset_results()
            st.rerun()
    else:
        if nearest_node not in st.session_state.shelter_nodes:
            st.session_state.shelter_nodes.append(nearest_node)
            st.session_state.shelter_capacities[str(nearest_node)] = int(DEFAULT_SHELTER_CAPACITY)
            ss_reset_results()
            st.rerun()


# ---------------------------------------------------------
# 核心：跑策略（多灾难点 + 全局容量共享）
# ---------------------------------------------------------
def run_strategy(strategy: str):
    if strategy == "LLM智能体模拟":
        # 运行智能体模拟
        run_llm_agent_simulation()
        return

    # 原有的其他策略逻辑
    shelters = [int(x) for x in st.session_state.shelter_nodes]
    disasters = [int(x) for x in st.session_state.disaster_nodes]
    people_map = {int(k): int(v) for k, v in
                  st.session_state.disaster_people.items()} if st.session_state.disaster_people else {}

    base_caps = {int(k): int(v) for k, v in
                 st.session_state.shelter_capacities.items()} if st.session_state.shelter_capacities else {}
    if not base_caps:
        base_caps = {s: DEFAULT_SHELTER_CAPACITY for s in shelters}

    # 自动训练 AI
    if strategy in ["AI预测(Allocation Predictor)", "多目标优化(GA)"] and st.session_state.auto_train_ai:
        if st.session_state.ai_model is None:
            with st.spinner("🤖 正在生成 teacher & 训练 AllocationPredictor..."):
                train_models_if_needed()

    # ✅ 全局容量共享：remaining_caps
    remaining_caps = base_caps.copy()

    # 可选：按人数从大到小分配更"合理"
    disasters_sorted = sorted(disasters, key=lambda d: people_map.get(d, 0), reverse=True)

    per_plans = []
    result_paths = []
    detail_tables: List[pd.DataFrame] = []
    unassigned_total = 0

    # 用时统计
    ga_time_total = 0.0
    ai_time_total = 0.0

    disaster_colors = [FOLIUM_COLORS[i % len(FOLIUM_COLORS)] for i in range(len(disasters_sorted))]

    skipped_draw_msgs = []

    for di, src in enumerate(disasters_sorted):
        N = int(people_map.get(src, 0))
        if N <= 0:
            continue

        path_infos = make_path_infos(G, src, shelters)

        # ---------- 1) 单一路径 ----------
        if strategy == "单一路径":
            lengths = [info.get("length", float("inf")) if is_reachable_path(info) else float("inf") for info in
                       path_infos]
            best_i = int(np.argmin(lengths)) if len(lengths) else 0
            alloc0 = [0] * len(shelters)
            if len(shelters) > 0:
                alloc0[best_i] = N
            alloc, leftover = repair_allocation_with_capacity_and_reachability(path_infos, alloc0, N, remaining_caps)

        # ---------- 2) 多路径分流 ----------
        elif strategy == "多路径分流":
            # 先平均（只对可达的）
            reachable_idx = [i for i, info in enumerate(path_infos) if is_reachable_path(info)]
            alloc0 = [0] * len(shelters)
            if reachable_idx:
                base = N // len(reachable_idx)
                for i in reachable_idx:
                    alloc0[i] = base
                alloc0[reachable_idx[0]] += N - sum(alloc0)
            alloc, leftover = repair_allocation_with_capacity_and_reachability(path_infos, alloc0, N, remaining_caps)

        # ---------- 3) AI-only ----------
        elif strategy == "AI预测(Allocation Predictor)":
            t0 = time.perf_counter()
            if st.session_state.ai_model is None:
                alloc, leftover = heuristic_allocation(path_infos, N, remaining_caps)
            else:
                alloc, leftover = predict_allocation_from_model(path_infos, N, remaining_caps,
                                                                st.session_state.ai_model)
            ai_time_total += float(time.perf_counter() - t0)

        # ---------- 4) GA ----------
        else:
            if ga_optimize_allocation is None:
                alloc, leftover = heuristic_allocation(path_infos, N, remaining_caps)
            else:
                t0 = time.perf_counter()
                try:
                    # seeds：启发式 + AI（如果有）+ 少量随机（交给 GA 内部补）
                    seeds = []
                    seed_h, _ = heuristic_allocation(path_infos, N, remaining_caps)
                    seeds.append(seed_h)
                    if st.session_state.ai_model is not None:
                        seed_ai, _ = predict_allocation_from_model(path_infos, N, remaining_caps,
                                                                   st.session_state.ai_model)
                        seeds.append(seed_ai)

                    res = ga_optimize_allocation(
                        G, src, shelters, total_people=N,
                        pop_size=int(st.session_state.ga_pop_size),
                        generations=int(st.session_state.ga_generations),
                        shelter_capacities=remaining_caps,
                        init_allocations=seeds,
                    )
                    best_paths, best_metrics = safe_unpack_ga_result(res)
                    ga_time_total += float(time.perf_counter() - t0)

                    if not best_paths:
                        alloc, leftover = heuristic_allocation(path_infos, N, remaining_caps)
                    else:
                        mp = {int(x.get("target", x.get("shelter", -1))): int(x.get("people", 0)) for x in best_paths}
                        alloc0 = [mp.get(int(tt), 0) for tt in shelters]
                        alloc, leftover = repair_allocation_with_capacity_and_reachability(path_infos, alloc0, N,
                                                                                           remaining_caps)

                except Exception:
                    ga_time_total += float(time.perf_counter() - t0)
                    alloc, leftover = heuristic_allocation(path_infos, N, remaining_caps)

        # ✅ 更新全局剩余容量
        for info, n in zip(path_infos, alloc):
            t = int(info["target"])
            remaining_caps[t] = int(max(0, remaining_caps.get(t, 0) - int(n)))

        unassigned_total += int(leftover)

        # 记录 plan
        per_plans.append({"source": src, "N": N, "path_infos": path_infos, "allocation": alloc})

        # 生成表
        caps_used_this_round = {int(info["target"]): int(base_caps.get(int(info["target"]), DEFAULT_SHELTER_CAPACITY))
                                for info in path_infos}
        # 这里表里"本轮可用容量"更有意义：用 "分配前的 remaining_caps + 分配量"
        # 简化起见：用 base_caps（总容量）展示 + 你可以在汇总里看未安置人数
        df_detail = build_detail_table(G, src, N, shelters, path_infos, alloc, caps_used_this_round, leftover, strategy)
        detail_tables.append(df_detail)

        # 路线绘制：不可达不画
        for pi, (info, n) in enumerate(zip(path_infos, alloc)):
            if int(n) <= 0:
                continue
            if not is_reachable_path(info):
                skipped_draw_msgs.append(f"灾难点{src}→避难点{info['target']} 分配{n}但不可达（已被修复后理论应为0）")
                continue

            color = disaster_colors[di]
            w = int(3 + min(12, int(n) / 200))
            result_paths.append({
                "path": info["path"],
                "color": color,
                "weight": w,
                "popup": f"灾难点{src}→避难点{info['target']}：{int(n)}人，L={info['length']:.0f}m"
            })

    metrics = evaluate_multi_disaster(per_plans)

    st.session_state.result_paths = result_paths
    st.session_state.simulation_completed = True
    st.session_state.detail_tables = detail_tables
    st.session_state.unassigned_total = int(unassigned_total)

    if detail_tables:
        st.session_state.detail_summary = pd.concat(detail_tables, ignore_index=True)

    # 结果文本
    st.session_state.result_info = (
        f"✅ {strategy} 完成\n"
        f"最长路径长度: {metrics['makespan']:.1f} m\n"
        f"总行驶距离: {metrics['total_distance']:.1f} m\n"
        f"最大拥堵指数: {metrics['max_congestion']:.0f} 人"
    )
    if unassigned_total > 0:
        st.session_state.result_info += f"\n⚠️ 未安置人数（容量不足/不可达导致）: {unassigned_total}"

    # 对比表：当选择 GA 时，额外跑一遍 AI-only 做对比（同样全局容量共享）
    if strategy == "多目标优化(GA)":
        # 复用同样排序
        if st.session_state.ai_model is not None:
            t_ai = time.perf_counter()
            remaining_caps2 = base_caps.copy()
            per_ai = []
            unassigned_ai = 0

            for src in disasters_sorted:
                N = int(people_map.get(src, 0))
                if N <= 0:
                    continue
                path_infos = make_path_infos(G, src, shelters)
                alloc_ai, left_ai = predict_allocation_from_model(path_infos, N, remaining_caps2,
                                                                  st.session_state.ai_model)
                for info, n in zip(path_infos, alloc_ai):
                    t = int(info["target"])
                    remaining_caps2[t] = int(max(0, remaining_caps2.get(t, 0) - int(n)))
                unassigned_ai += int(left_ai)
                per_ai.append({"source": src, "N": N, "path_infos": path_infos, "allocation": alloc_ai})

            ai_metrics = evaluate_multi_disaster(per_ai)
            ai_time_total = float(time.perf_counter() - t_ai)
        else:
            ai_metrics = {"makespan": np.nan, "total_distance": np.nan, "max_congestion": np.nan}
            ai_time_total = np.nan
            unassigned_ai = np.nan

        st.session_state.ga_time = ga_time_total
        st.session_state.ai_time = ai_time_total

        df_cmp = pd.DataFrame([
            {
                "方法": "AI-only",
                "makespan(m)": ai_metrics["makespan"],
                "total_distance(m)": ai_metrics["total_distance"],
                "max_congestion(ppl)": ai_metrics["max_congestion"],
                "未安置人数": unassigned_ai,
                "用时(s)": ai_time_total
            },
            {
                "方法": "GA",
                "makespan(m)": metrics["makespan"],
                "total_distance(m)": metrics["total_distance"],
                "max_congestion(ppl)": metrics["max_congestion"],
                "未安置人数": unassigned_total,
                "用时(s)": ga_time_total
            }
        ])
        st.session_state.compare_table = df_cmp


# ---------------------------------------------------------
# 控制面板：执行策略
# ---------------------------------------------------------
st.markdown("## ⚙️ 控制面板")

if st.session_state.simulation_running:
    try:
        with st.spinner("⏳ 正在运行策略..."):
            run_strategy(st.session_state.strategy_type)
    finally:
        st.session_state.simulation_running = False
        st.rerun()

colL, colR = st.columns(2)

with colL:
    st.markdown("### 当前设置")
    if st.session_state.disaster_nodes:
        for i, d in enumerate(st.session_state.disaster_nodes):
            ppl = int(st.session_state.disaster_people.get(str(d), 0))
            lat, lon = get_node_latlon(G, d)
            st.write(f"- 灾难点{i + 1}: 节点{d} 人数={ppl} 坐标=({lat:.6f},{lon:.6f})")
    else:
        st.write("- 灾难点：未设置")

    if st.session_state.shelter_nodes:
        for i, s in enumerate(st.session_state.shelter_nodes):
            cap = int(st.session_state.shelter_capacities.get(str(s), DEFAULT_SHELTER_CAPACITY))
            lat, lon = get_node_latlon(G, s)
            st.write(f"- 避难点{i + 1}: 节点{s} 容量={cap} 坐标=({lat:.6f},{lon:.6f})")
    else:
        st.write("- 避难点：未设置")

with colR:
    st.markdown("### 训练面板（AI + 优化）")

    if st.session_state.strategy_type == "LLM智能体模拟":
        # 显示智能体模拟信息
        if st.session_state.agent_statistics:
            stats = st.session_state.agent_statistics
            cols = st.columns(2)
            with cols[0]:
                st.metric("总智能体数", stats.get("total_agents", 0))
                st.metric("到达率", f"{stats.get('arrival_rate', 0) * 100:.1f}%")
            with cols[1]:
                st.metric("已到达数", stats.get("arrived_agents", 0))
                st.metric("平均步数", f"{stats.get('avg_steps', 0):.1f}")

            if st.session_state.simulation_steps:
                st.info(f"模拟完成，共 {len(st.session_state.simulation_steps)} 步")
        else:
            st.info("智能体模拟待运行")

        if st.session_state.llm_simulator and not st.session_state.llm_simulator.is_initialized:
            st.warning("LLM API未初始化，请检查API配置")

    else:
        # 原有的AI训练面板
        cols = st.columns(2)
        with cols[0]:
            st.metric("生成 teacher 数据耗时(s)",
                      f"{st.session_state.teacher_time:.3f}" if st.session_state.teacher_time is not None else "-")
            st.metric("训练 AllocationPredictor 耗时(s)",
                      f"{st.session_state.train_time:.3f}" if st.session_state.train_time is not None else "-")
        with cols[1]:
            st.metric("GA 用时(s)", f"{st.session_state.ga_time:.3f}" if st.session_state.ga_time is not None else "-")
            st.metric("AI-only 用时(s)",
                      f"{st.session_state.ai_time:.3f}" if st.session_state.ai_time is not None and not (
                                  isinstance(st.session_state.ai_time, float) and np.isnan(
                              st.session_state.ai_time)) else "-")

        if st.session_state.ai_loss_history:
            lh = st.session_state.ai_loss_history
            st.write(f"AllocationPredictor loss: 初始 {lh[0]:.6f} → 结束 {lh[-1]:.6f}（len={len(lh)}）")
            df_loss = pd.DataFrame({"epoch": list(range(len(lh))), "loss": lh})
            st.line_chart(df_loss.set_index("epoch"))

        if st.session_state.ai_weights is not None:
            st.markdown("#### AllocationPredictor 权重 w")
            df_w = pd.DataFrame({"feature": FEATURE_NAMES, "w": st.session_state.ai_weights})
            st.dataframe(df_w, use_container_width=True, hide_index=True)

    if st.session_state.strategy_type != "LLM智能体模拟" and st.button("🔁 手动生成 teacher 并训练 AI（覆盖旧模型）"):
        st.session_state.ai_model = None
        with st.spinner("🤖 正在训练..."):
            train_models_if_needed()
        st.success("训练完成")
        st.rerun()

# ---------------------------------------------------------
# 结果展示（所有策略都有表格）
# ---------------------------------------------------------
st.markdown("## 📊 结果展示")

if st.session_state.strategy_type == "LLM智能体模拟":
    # 智能体模拟结果显示
    if st.session_state.simulation_results:
        display_simulation_results()
    elif st.session_state.simulation_running:
        st.info("模拟运行中...")
    else:
        st.info("请运行智能体模拟查看结果")

elif st.session_state.simulation_completed:
    if "✅" in st.session_state.result_info:
        st.success(st.session_state.result_info)
    else:
        st.error(st.session_state.result_info)

    # 所有策略：路径分配详情
    st.markdown("### 📋 路径分配详情（每个灾难点一张表 + 汇总）")
    if st.session_state.detail_tables:
        tabs = st.tabs([f"灾难点{i + 1}" for i in range(len(st.session_state.detail_tables))] + ["汇总"])
        for i, df in enumerate(st.session_state.detail_tables):
            with tabs[i]:
                st.dataframe(df, use_container_width=True, hide_index=True)
        with tabs[-1]:
            df_all = st.session_state.detail_summary
            if isinstance(df_all, pd.DataFrame):
                st.dataframe(df_all, use_container_width=True, hide_index=True)
                csv = df_all.to_csv(index=False, encoding="utf-8-sig")
                st.download_button("📥 下载详细结果 CSV", data=csv, file_name="detail_results.csv", mime="text/csv")
    else:
        st.warning("暂无表格（可能所有灾难点人数为 0）。")

    # GA 对比表
    if st.session_state.strategy_type == "多目标优化(GA)" and isinstance(st.session_state.compare_table, pd.DataFrame):
        st.markdown("### 🆚 AI-only vs GA（指标 + 用时 + 未安置人数）")
        st.dataframe(st.session_state.compare_table, use_container_width=True, hide_index=True)

create_footer()