"""
#5 オフィスビルの夜間警備（巡回）

ロボットがいないときは、警備員が2時間ごとに建物を1周する（1周40分）。
防災センターには常に1人残る決まりにする。警備員が1人しかいなければ、巡回の間はセンターが空く。
ロボットがいるときは、ロボットが巡回し、異常を見つけたらセンターに知らせ、警備員が駆けつける。
ロボットは異常でないものを異常と知らせることがあり（空振り）、そのたびに警備員が見に行く。
ロボットは電池が切れると充電台に戻る（その間は巡回が止まる）。

時刻の 0 = 19:00、720 = 7:00。単位は分。
"""
import random
import sys

import simpy

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

NIGHT = 720
SEG = 10   # 巡回ルートを10区画に分けて、区画ごとに異常を見る

SPEC = {"battery": 5.5 * 60, "charge": 1.5 * 60}   # SQ-2：1回の充電で5〜6時間、充電は最大1.5時間
ASSUMED = {
    "human_lap": 40, "robot_lap": 50,              # 1周（分）。ロボットは遅めでエレベーターも待つ
    "interval": 120,                               # 定時巡回の間隔
    "handle": (5, 10, 20),                         # 異常1件の対応
    "travel": (3, 6, 10),                          # センターから現場まで
    "check_false": 3,                              # 空振りを確かめる
}

# ビルの広さ（仮置き）。1周の時間（人・ロボット）と、センターから現場までの時間が変わる
SCALES = {
    "small": {"label": "中規模ビル", "floors": 10, "human_lap": 30, "robot_lap": 40, "travel": (2, 4, 7)},
    "mid": {"label": "大規模ビル", "floors": 20, "human_lap": 40, "robot_lap": 50, "travel": (3, 6, 10)},
    "large": {"label": "大規模複合ビル", "floors": 35, "human_lap": 60, "robot_lap": 75, "travel": (5, 9, 15)},
}

AXES = {
    "scale": list(SCALES),
    "guards": [1, 2, 3, 4, 5, 6],         # ページでは 1〜3 を並べ、4〜6 は「その他」から選ぶ
    "robots": [0, 1, 2, 3, 4, 5],         # ページでは 0〜2 を並べ、3〜5 は「その他」から選ぶ
    "incidents": [3, 6, 12],          # 1晩に起きる異常（扉の開け放し・置き去りの物・消えた照明など）
    "false_per_h": [0.0, 0.5, 1.5],   # ロボット1台が1時間巡回するあいだの空振りの知らせ
    "rmode": ["sched", "cont"],       # 定時に回る／充電中以外は回り続ける
}


class Night:
    def __init__(self, env, rng, p):
        self.env, self.rng, self.p = env, rng, p
        self.sc = SCALES[p["scale"]]
        self.mobile_n = p["guards"] - 1 if p["guards"] >= 2 else 1
        self.guards = simpy.PriorityResource(env, capacity=self.mobile_n)
        self.anoms = []        # [出た時刻, 区画, 見つけた時刻, 人が着いた時刻]
        self.lap_starts = []
        self.center_empty = 0.0
        self.foot = 0.0
        self.dispatch_true = self.dispatch_false = self.laps_robot = 0

    def spawn_anoms(self):
        rng = self.rng
        for t in poisson_times(rng, self.p["incidents"] / NIGHT, 0, NIGHT):
            self.anoms.append([t, rng.randrange(SEG), None, None])

    def busy(self, t):
        self.foot += t
        if self.p["guards"] == 1:
            self.center_empty += t

    # ---- 人の巡回
    def human_patrol(self):
        env, A = self.env, ASSUMED
        for k in range(NIGHT // A["interval"]):
            at = k * A["interval"]
            if env.now < at:
                yield env.timeout(at - env.now)
            with self.guards.request(priority=1) as req:
                yield req
                t0 = env.now
                self.lap_starts.append(env.now)
                for s in range(SEG):
                    yield env.timeout(self.sc["human_lap"] / SEG)
                    for a in self.anoms:
                        if a[1] == s and a[2] is None and a[0] <= env.now:
                            a[2] = a[3] = env.now
                            yield env.timeout(tri(self.rng, A["handle"]))
                self.busy(env.now - t0)

    # ---- ロボットの巡回
    def robot_patrol(self, idx):
        env, A, p, rng = self.env, ASSUMED, self.p, self.rng
        batt = SPEC["battery"]
        lap = self.sc["robot_lap"]
        if p["rmode"] == "cont":
            yield env.timeout(idx * lap / max(p["robots"], 1))  # 2台目は半周ずらす
        k = 0
        while env.now < NIGHT:
            if p["rmode"] == "sched":
                at = k * A["interval"] + idx * A["interval"] / max(p["robots"], 1)
                k += 1
                if at >= NIGHT:
                    return
                if env.now < at:
                    yield env.timeout(at - env.now)
            if batt < lap:
                yield env.timeout(SPEC["charge"])
                batt = SPEC["battery"]
                if p["rmode"] == "sched":
                    continue
            self.lap_starts.append(env.now)
            self.laps_robot += 1
            for s in range(SEG):
                yield env.timeout(lap / SEG)
                batt -= lap / SEG
                for a in self.anoms:
                    if a[1] == s and a[2] is None and a[0] <= env.now:
                        a[2] = env.now
                        self.dispatch_true += 1
                        env.process(self.respond(a))
                if rng.random() < p["false_per_h"] * lap / SEG / 60:
                    self.dispatch_false += 1
                    env.process(self.respond(None))

    def respond(self, a):
        env, rng, A = self.env, self.rng, ASSUMED
        with self.guards.request(priority=0) as req:
            yield req
            t0 = env.now
            go = tri(rng, self.sc["travel"])
            yield env.timeout(go)
            if a is not None:
                a[3] = env.now
                yield env.timeout(tri(rng, A["handle"]))
            else:
                yield env.timeout(A["check_false"])
            yield env.timeout(go)
            self.busy(env.now - t0)


def run_once(params, seed):
    env = simpy.Environment()
    n = Night(env, random.Random(seed), params)
    n.spawn_anoms()
    if params["robots"] == 0:
        env.process(n.human_patrol())
    else:
        for i in range(params["robots"]):
            env.process(n.robot_patrol(i))
    env.run(until=NIGHT + 240)
    # 見つからないまま朝になった異常は、朝7時に見つかったとして数える
    det, reach = [], []
    missed = 0
    for t, s, d, r in n.anoms:
        if d is None:
            missed += 1
            d = r = max(NIGHT, t)
        if r is None:
            r = d
        det.append(d - t)
        reach.append(r - t)
    starts = sorted(n.lap_starts)
    gaps = [b - a for a, b in zip([0] + starts, starts + [NIGHT])]
    return {
        "detect_mean": mean(det), "detect_p90": p90(det),
        "reach_mean": mean(reach), "reach_p90": p90(reach),   # 異常が出てから人が現場に着くまで
        "missed": missed,                                    # 朝まで見つからなかった
        "max_gap": max(gaps) if gaps else NIGHT,             # 巡回が始まらなかった最も長い間
        "center_empty": n.center_empty,
        "foot_min": n.foot,                                  # 警備員がセンターの外にいた分（合計）
        "calls": n.dispatch_true + n.dispatch_false, "false_calls": n.dispatch_false,
        "anoms": len(n.anoms), "robot_laps": n.laps_robot,
    }


def conditions():
    return list(grid(AXES, skip=lambda c: c["robots"] == 0 and (c["false_per_h"] > 0 or c["rmode"] != "sched")))


SOURCES = [
    ("SEQSENSE SQ-2：1回の充電で5〜6時間、充電は最大1.5時間、レンタルのみ", "https://www.irisohyama.co.jp/b2b/robotics/products/sq-2/"),
    ("大成 × ugo：12物件に17台、品川シーズンテラスで夜間巡回の要員を1名減", "https://www.taisei-bm.co.jp/wp-content/uploads/2024/10/news20240325.pdf"),
    ("TIS（豊洲）：警備員2名分の費用、施設スタッフの作業が週約200分減", "https://www.meti.go.jp/policy/mono_info_service/mono/robot/2503_facilitybook.pdf"),
    ("警備員の約47%が60歳以上、保安職の有効求人倍率 5.64倍（2026年5月）", "https://cdn.j-bma.or.jp/wp-content/uploads/2026/08/03135956/20260729_%E9%81%93%E8%B7%AF%E4%BA%A4%E9%80%9A%E6%B3%95%E6%94%B9%E6%AD%A3%E3%81%A7%E9%80%B2%E3%82%80%E8%AD%A6%E5%82%99%E3%83%AD%E3%83%9C%E3%83%83%E3%83%88%E3%81%AE%E5%85%AC%E9%81%93%E6%B4%BB%E7%94%A8_02%EF%BC%88%E5%B7%AE%E3%81%97%E6%9B%BF%E3%81%88%E5%88%86%EF%BC%89.pdf"),
]

if __name__ == "__main__":
    if "--one" in sys.argv:
        for g, rb, m in [(2, 0, "sched"), (1, 1, "sched"), (1, 1, "cont"), (2, 1, "cont"), (2, 2, "cont")]:
            c = {"scale": "mid", "guards": g, "robots": rb, "incidents": 6, "false_per_h": 0.5 if rb else 0.0, "rmode": m}
            print(g, rb, m, run_grid(run_once, [c], procs=1)[0])
    else:
        rows = run_grid(run_once, conditions())
        save("results_security.json", {"scales": SCALES, "spec": SPEC, "assumed": ASSUMED, "axes": AXES, "sources": SOURCES, "rows": rows})
        print(len(rows), "conditions")
