"""
#6 屋外配送（歩道を走る小型ロボット）

店で荷物を載せ、歩道を走って届け先へ行き、客が受け取ったら店へ戻る。
走っている間に、人や車に道をふさがれる・判断に迷うなどで止まり、遠隔のオペレーターを呼ぶ（介入）。
オペレーターは1度に1件の介入しか扱えない。さらに、1人が見ていられる台数に上限があり、
上限を超えると、店で出発を待つ。

時刻の 0 = 11:00、540 = 20:00（受付終了）。単位は分。
"""
import random
import sys

import simpy

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

HOURS = 540
ORDER_WINDOWS = [(0, 30, 3), (30, 150, 30), (150, 390, 20), (390, 510, 30), (510, 540, 3)]  # 昼と夜に山（仮置き）

ASSUMED = {
    "one_way": (4, 7, 12),       # 片道（分）。Uber Eats × 三菱電機 の日本橋ルート 約7分 から
    "load": 2.0,                 # 店で載せる
    "pickup": (0.5, 1.5, 5.0),   # 客が出てきて受け取る
    "noshow": 0.05, "noshow_wait": 5.0,
    "fix": (0.5, 1.5, 4.0),      # 介入1件をオペレーターが片づける（分）
    "late_min": 45,              # 注文から届くまでこれを超えたら「遅れた」
}

# 配達エリアの広さ（仮置き）。片道の時間（最短, よくある値, 最長）が変わる。距離は時速5kmで歩道を走ったときの目安
SCALES = {
    "near": {"label": "狭いエリア", "one_way": (2, 4, 7), "radius_m": 330, "desc": "駅前の店から近所へ"},
    "mid": {"label": "ふつうのエリア", "one_way": (4, 7, 12), "radius_m": 580, "desc": "日本橋の実証の片道約7分"},
    "wide": {"label": "広いエリア", "one_way": (7, 12, 20), "radius_m": 1000, "desc": "郊外の住宅地へ"},
}

AXES = {
    "scale": list(SCALES),
    "robots": [1, 2, 3, 4, 5, 6, 8, 10, 12, 15, 20],   # ページでは 1・2・4・10 を並べ、ほかは「その他」から選ぶ
    "operators": [1, 2, 3, 4, 5],                     # ページでは 1・2 を並べ、3〜5 は「その他」から選ぶ
    "orders": [20, 60, 120, 200],     # 1日の注文。今の日本の実績は1エリアで1日約20件
    "int_rate": [0.05, 0.2, 0.5],     # 片道1回あたりの介入の回数
    "watch": [4, 10],                 # オペレーター1人が見られる台数（ハコボ：2022年 4台 → 2025年 10台）
}


class Area:
    def __init__(self, env, rng, p):
        self.env, self.rng, self.p = env, rng, p
        self.robots = simpy.Resource(env, capacity=p["robots"])
        self.ops = simpy.Resource(env, capacity=p["operators"])
        self.watch = simpy.Resource(env, capacity=p["operators"] * p["watch"])   # 走っていてよい台数
        self.lead, self.int_waits, self.depart_waits = [], [], []
        self.op_busy = self.robot_busy = 0.0
        self.ints = self.noshow_n = 0
        self.last = 0.0

    def orders(self):
        env = self.env
        for t in profile_times(self.rng, self.p["orders"], ORDER_WINDOWS):
            yield env.timeout(t - env.now)
            env.process(self.order())

    def leg(self, minutes):
        """片道。途中で介入が起きたらオペレーターを待つ"""
        env, rng, A = self.env, self.rng, ASSUMED
        n = _poisson(rng, self.p["int_rate"])
        cuts = sorted(rng.uniform(0, minutes) for _ in range(n))
        done = 0.0
        for c in cuts:
            yield env.timeout(c - done)
            done = c
            self.ints += 1
            t0 = env.now
            with self.ops.request() as req:
                yield req
                self.int_waits.append(env.now - t0)
                f = tri(rng, A["fix"])
                yield env.timeout(f)
                self.op_busy += f
        yield env.timeout(minutes - done)

    def order(self):
        env, rng, A = self.env, self.rng, ASSUMED
        t_order = env.now
        with self.robots.request() as rreq:
            yield rreq
            t_r = env.now
            yield env.timeout(A["load"])
            t_w = env.now
            with self.watch.request() as wreq:
                yield wreq
                self.depart_waits.append(env.now - t_w)
                trip = tri(rng, SCALES[self.p["scale"]]["one_way"])
                yield env.process(self.leg(trip))
                if rng.random() < A["noshow"]:
                    self.noshow_n += 1
                    yield env.timeout(A["noshow_wait"])
                else:
                    yield env.timeout(tri(rng, A["pickup"]))
                    self.lead.append(env.now - t_order)
                yield env.process(self.leg(trip))
            self.robot_busy += env.now - t_r
            self.last = max(self.last, env.now)


def _poisson(rng, lam):
    # 小さい lam 用の簡単なポアソン乱数
    import math
    L, k, p = math.exp(-lam), 0, 1.0
    while True:
        p *= rng.random()
        if p <= L:
            return k
        k += 1


def run_once(params, seed):
    env = simpy.Environment()
    a = Area(env, random.Random(seed), params)
    env.process(a.orders())
    env.run()   # 受付の終わった注文を、全部届け終わるまで回す
    span = max(HOURS, a.last)
    L = a.lead
    return {
        "lead_mean": mean(L), "lead_p90": p90(L),
        "late_share": sum(x > ASSUMED["late_min"] for x in L) / len(L) if L else 0.0,
        "int_wait": mean(a.int_waits),                         # 止まってオペレーターを待った分（1回あたり）
        "depart_wait": mean(a.depart_waits),                   # 見られる台数の上限で、店で出発を待った分
        "op_util": a.op_busy / (params["operators"] * span),  # オペレーターが介入にかかりきりの割合
        "robot_util": a.robot_busy / (params["robots"] * span),
        "end": span,                                           # 最後の配達が終わった時刻（11:00 からの分）
        "calls": a.ints, "delivered": len(L), "noshow": a.noshow_n,
    }


def conditions():
    return list(grid(AXES))


SOURCES = [
    ("2023年4月の改正道路交通法：遠隔操作型小型車（時速6km以下・届け出制）", "https://www.meti.go.jp/policy/economy/distribution/deliveryrobot/gaiyou.pdf"),
    ("パナソニック ハコボ：遠隔オペレーター1人で4台（2022年）→10台（2025年）", "https://monoist.itmedia.co.jp/mn/spv/2502/18/news098.html"),
    ("丸の内の実証：注文は1日約20件、横断約50回で保安要員の介入なし（遠隔操作の介入はタクシーの乗り降りで1回）", "https://www.meti.go.jp/shingikai/mono_info_service/jidosoko_robot/pdf/007_07_00.pdf"),
    ("Uber Eats × 三菱電機：日本橋で片道約7分のルート、最高速度5.4km", "https://monoist.itmedia.co.jp/mn/spv/2403/06/news082.html"),
    ("甲賀市の実証：18日で450個、ロボットだけで届いたのは94%、大雪で1日運休", "https://www.logi-today.com/945458"),
]

if __name__ == "__main__":
    if "--one" in sys.argv:
        for rb, op, od, ir, w in [(2, 1, 20, 0.2, 10), (4, 1, 150, 0.2, 10), (10, 1, 300, 0.5, 10), (10, 2, 300, 0.5, 10), (10, 1, 300, 0.2, 4)]:
            c = {"scale": "mid", "robots": rb, "operators": op, "orders": od, "int_rate": ir, "watch": w}
            print(c, {k: v for k, v in run_grid(run_once, [c], procs=1)[0].items() if k not in c})
    else:
        rows = run_grid(run_once, conditions())
        save("results_outdoor.json", {"scales": SCALES, "assumed": ASSUMED, "order_windows": ORDER_WINDOWS, "axes": AXES,
                                      "sources": SOURCES, "rows": rows})
        print(len(rows), "conditions")
