"""
#2 病院の院内搬送（検体・薬剤）

東京慈恵会医科大学附属柏病院の公開事例（KEENON W3・2025年6月〜）の形をもとにする。
  3ルート・ルートごとに運行時間帯が決まっている・同じ階・1台で回している
人（看護補助者など）が運ぶ場合は、ほかの仕事の合間に、たまった荷物をまとめて持っていく。
ロボットの場合は、出発地の人が荷物を載せ、着いた先の人が受け取る。止まったら出発地の人が助けに行く。

時刻の 0 = 7:30、540 = 16:30。単位は分。

使い方:
    python hospital_sim.py          # 総当たりを回して results_hospital.json を書く
    python hospital_sim.py --one    # 1条件だけ回して表示
"""
import random
import sys

import simpy

from common import tri, p90, mean, poisson_times, run_grid, grid, save

# ---- 公開資料から取った形（出典は SOURCES）
ROUTES = {
    "r1": {"label": "救急・病棟 → 検査部", "windows": [(0, 30)]},                         # 7:30〜8:00
    "r2": {"label": "内科外来 → 検査部", "windows": [(30, 210), (330, 390), (450, 540)]},   # 8:00〜11:00・13:00〜14:00・15:00〜16:30
    "r3": {"label": "薬剤部 → 外来化学療法室", "windows": [(210, 330), (390, 450)]},       # 11:00〜13:00・14:00〜15:00
}
DAY_END = 540
ROBOT_LOAD_MAX = 6          # 1便に積む荷物の上限（仮。W3 は1回で最大4か所に届けられる）

# ---- 仮置き（公開資料にない値）
ASSUMED = {
    "staff_speed": 1.2 * 60,                           # m/分
    "handover": (0.5, 1.5, 3.0),                       # 着いた先で受け取る人を見つけて渡す（分）
    "load_base": 0.5, "load_per_item": 0.2,            # ロボットに載せる手間（分）
    "unload": (0.3, 1.0, 3.0),                         # ロボットから受け取る（分）
    "elev_wait_staff": (0.5, 1.5, 4.0),                # 階をまたぐときの待ち（人）
    "elev_wait_robot": (0.5, 2.0, 6.0),                # 階をまたぐときの待ち（ロボット。人と一緒に乗れないので長め）
    "elev_peak_x": 1.5,                                # 外来の山（8:00〜11:00）はエレベーター待ちが1.5倍
    "elev_ride": 1.0,
    "self_clear": (0.2, 0.5, 1.5),                     # 止まって自然に解ける（分）
    "need_staff": 0.5,                                 # 止まったうち、人が助けに行く割合
    "rescue_work": 1.0,
    "other_job": (2, 5, 10),                           # 出発地の人のほかの仕事1件（分）
    "batch_n": 3, "batch_wait": 10,                    # 「まとめて出す」：3件たまるか、最初の荷物が10分待ったら出る
    "late_min": 15,                                    # 検査部に着くまでこれを超えたら「遅れた」
}
DEMAND = {  # 1時間あたりに出る荷物の数（少ない・普通・多い）。1日の便数 4〜9便・5〜15便 から逆に置いた
    "r1": [6, 10, 16], "r2": [2, 3.5, 5], "r3": [1.5, 2.5, 4],
}

# 病院の広さ。広さごとに病院の型が違い（中小＝1棟・廊下1本／中規模＝1棟・外来をブロックで分ける／大学＝分棟を渡り廊下でつなぐ）、
# 片道の距離は、その図面（外来の階）の上で測った長さをそのまま使う（2026-11-20 から。それまでは中規模の距離に倍率を掛けていた）
# 図面は p2m-site の tools/hospital_layouts/make_hospital_scales.py で作り、hospital_scales.json をこのフォルダに写して読む
# 荷物の量は、慈恵医大柏病院（664床）の規模を1として掛ける（仮置き・前と同じ）
import json as _json
from pathlib import Path as _Path
PLANS = _json.loads((_Path(__file__).resolve().parent / "hospital_scales.json").read_text(encoding="utf-8"))
SCALES = {
    "small": {"label": "中小病院", "beds": 200, "demand_x": 0.6, "desc": "地域の病院。検査部も薬剤部も近い"},
    "mid": {"label": "中規模病院", "beds": 660, "demand_x": 1.0, "desc": "慈恵医大柏病院（664床）の規模"},
    "large": {"label": "大学病院", "beds": 1100, "demand_x": 1.5, "desc": "建物が広く、検査部まで遠い。荷物も多い"},
}
for _k, _v in SCALES.items():
    _v["dist_m"] = PLANS[_k]["dist_m"]
    _v["floor"] = [PLANS[_k]["w"], PLANS[_k]["d"]]
    _v["desc"] = PLANS[_k]["desc"]          # 型の説明も図面から取る（広さごとに型が違う）
    _v["style"] = PLANS[_k]["style"]
    _v["routes"] = {r: PLANS[_k]["routes"][r]["label"] for r in PLANS[_k]["routes"]}

AXES = {
    "scale": list(SCALES),
    "robots": [0, 1, 2, 3, 4, 5],         # ページでは 0〜2 を並べ、3〜5 は「その他」から選ぶ
    "demand": [0, 1, 2],
    "floors": ["same", "elev"],
    "stop_rate": [0.0, 0.05, 0.15],
    "dispatch": ["now", "batch"],
    "busy": [0.3, 0.6],                 # 出発地の人が、ほかの仕事で手がふさがっている割合
    "speed": [0.6, 0.9, 1.2],           # ロボットの速さ（m/秒）。W3 の最高は 1.2m/秒。人の多い廊下では落とす
}


class Hospital:
    def __init__(self, env, rng, p):
        self.env, self.rng, self.p = env, rng, p
        A = ASSUMED
        self.staff = {r: simpy.PriorityResource(env, capacity=1) for r in ROUTES}
        self.robots = simpy.Resource(env, capacity=p["robots"]) if p["robots"] else None
        self.queue = {r: [] for r in ROUTES}          # 出発地で待っている荷物（出た時刻）
        self.pending = {r: False for r in ROUTES}
        self.waits, self.other_waits = [], []
        self.staff_tr = 0.0
        self.robot_busy = 0.0
        self.trips = self.items_robot = self.stops = self.rescues = self.staff_trips = 0
        sc = SCALES[p["scale"]]
        self.d = dict(sc["dist_m"])          # 図面の上で測った片道の距離（m）
        self.demand_x = sc["demand_x"]

    def elev(self, who):
        A, rng, env = ASSUMED, self.rng, self.env
        if self.p["floors"] != "elev":
            return 0.0
        w = tri(rng, A["elev_wait_robot" if who == "robot" else "elev_wait_staff"])
        if 30 <= env.now <= 210:
            w *= A["elev_peak_x"]
        return w + A["elev_ride"]

    # ---- 出発地の人のほかの仕事
    def other_work(self, r):
        rng, env = self.rng, self.env
        rate = self.p["busy"] / ASSUMED["other_job"][1]
        for t in poisson_times(rng, rate, 0, DAY_END):
            env.process(self._other(r, t))

    def _other(self, r, t):
        env = self.env
        yield env.timeout(t - env.now)
        t0 = env.now
        with self.staff[r].request(priority=2) as req:
            yield req
            self.other_waits.append(env.now - t0)
            yield env.timeout(tri(self.rng, ASSUMED["other_job"]))

    # ---- 荷物が出る
    def items(self, r):
        rng, env = self.rng, self.env
        lam = DEMAND[r][self.p["demand"]] * self.demand_x / 60
        ts = []
        for a, b in ROUTES[r]["windows"]:
            ts += poisson_times(rng, lam, a, b)
        for t in sorted(ts):
            yield env.timeout(t - env.now)
            self.queue[r].append(env.now)

    def window_open(self, r, t):
        return any(a <= t < b for a, b in ROUTES[r]["windows"])

    # ---- 出発の判断（0.5分ごとに見る）
    def dispatcher(self, r):
        env, p, A = self.env, self.p, ASSUMED
        while True:
            q = self.queue[r]
            if q and not self.pending[r]:
                if self.robots is None:
                    self.pending[r] = True
                    env.process(self.staff_trip(r))
                elif self.robots.count < self.robots.capacity:
                    go = p["dispatch"] == "now" or len(q) >= A["batch_n"] or env.now - q[0] >= A["batch_wait"] \
                        or not self.window_open(r, env.now)
                    if go:
                        self.pending[r] = True
                        env.process(self.robot_trip(r))
            if env.now > DAY_END and not any(self.queue.values()) and not any(self.pending.values()):
                return
            yield env.timeout(0.5)

    # ---- 人が運ぶ（行くときにたまっている荷物を全部持っていく）
    def staff_trip(self, r):
        env, rng, A = self.env, self.rng, ASSUMED
        with self.staff[r].request(priority=1) as req:
            yield req
            batch, self.queue[r] = self.queue[r], []
            self.pending[r] = False
            t0 = env.now
            walk = self.d[r] / A["staff_speed"]
            yield env.timeout(walk + self.elev("staff"))
            yield env.timeout(tri(rng, A["handover"]))
            self.waits += [env.now - t for t in batch]
            yield env.timeout(walk + self.elev("staff"))
            self.staff_tr += env.now - t0
            self.staff_trips += 1

    # ---- ロボットが運ぶ
    def leg(self, r):
        """片道。途中で止まることがある"""
        env, rng, A, p = self.env, self.rng, ASSUMED, self.p
        yield env.timeout(self.d[r] / (p["speed"] * 60) + self.elev("robot"))
        if rng.random() < p["stop_rate"]:
            self.stops += 1
            if rng.random() < A["need_staff"]:
                self.rescues += 1
                with self.staff[r].request(priority=0) as req:
                    yield req
                    t0 = env.now
                    yield env.timeout(self.d[r] / 2 / A["staff_speed"] * 2 + A["rescue_work"])
                    self.staff_tr += env.now - t0
            else:
                yield env.timeout(tri(rng, A["self_clear"]))

    def robot_trip(self, r):
        env, rng, A = self.env, self.rng, ASSUMED
        with self.robots.request() as rreq:
            yield rreq
            # 出発地の人が載せる
            with self.staff[r].request(priority=1) as sreq:
                yield sreq
                batch, self.queue[r] = self.queue[r][:ROBOT_LOAD_MAX], self.queue[r][ROBOT_LOAD_MAX:]
                self.pending[r] = False
                t = A["load_base"] + A["load_per_item"] * len(batch)
                yield env.timeout(t)
                self.staff_tr += t
            t0 = env.now
            yield env.process(self.leg(r))
            yield env.timeout(tri(rng, A["unload"]))
            self.waits += [env.now - t for t in batch]
            yield env.process(self.leg(r))
            self.robot_busy += env.now - t0
            self.trips += 1
            self.items_robot += len(batch)


def run_once(params, seed):
    env = simpy.Environment()
    h = Hospital(env, random.Random(seed), params)
    for r in ROUTES:
        h.other_work(r)
        env.process(h.items(r))
        env.process(h.dispatcher(r))
    env.run(until=DAY_END + 240)
    w = h.waits
    return {
        "wait_mean": mean(w), "wait_p90": p90(w),
        "late_share": sum(x > ASSUMED["late_min"] for x in w) / len(w) if w else 0.0,
        "items": len(w),
        "staff_tr_min": h.staff_tr,                    # 人が搬送（運ぶ・載せる・助けに行く）に使った分
        "other_wait": mean(h.other_waits),              # 出発地の人のほかの仕事が待たされた分（平均）
        "robot_trips": h.trips, "staff_trips": h.staff_trips,
        "per_trip": h.items_robot / h.trips if h.trips else 0.0,
        "robot_util": h.robot_busy / (params["robots"] * DAY_END) if params["robots"] else 0.0,
        "stops": h.stops, "calls": h.rescues,
    }


def conditions():
    return list(grid(AXES, skip=lambda c: c["robots"] == 0 and (c["stop_rate"] > 0 or c["dispatch"] != "now" or c["speed"] != 0.9)))


SOURCES = [
    ("3ルートと運行時間帯、1日の便数（内科 4〜9便・薬剤 5〜15便）、1日66〜172分の削減（病院の発表）", "https://prtimes.jp/main/html/rd/p/000000111.000028572.html"),
    ("実証でのスタッフの平均移動時間 9分39秒→4分57秒、1日の平均運搬回数 9.5回→4.8回、1度に最大4か所", "https://www.logi-today.com/764565"),
    ("同じ階だけで運行・エレベーター連携はこれから", "https://www.nikkan.co.jp/releases/view/221980"),
    ("エレベーターでは人とロボットが一緒に乗れない（HOSPI の事例）", "https://content.connect.panasonic.com/jp-ja/fai/file/769"),
]

if __name__ == "__main__":
    if "--one" in sys.argv:
        for rb in [0, 1, 2]:
            c = {"scale": "mid", "robots": rb, "demand": 1, "floors": "same", "stop_rate": 0.05 if rb else 0.0, "dispatch": "now", "busy": 0.6, "speed": 0.9}
            print(rb, run_grid(run_once, [c], procs=1)[0])
    else:
        conds = conditions()
        rows = run_grid(run_once, conds)
        save("results_hospital.json", {"scales": SCALES, "assumed": ASSUMED, "demand": DEMAND, "routes": ROUTES, "axes": AXES,
                                       "sources": SOURCES, "rows": rows})
        print(len(rows), "conditions")
