#!/usr/bin/env python3
"""Load test of the account sync (WEB docs/plan/account-sync/phases/A09-simulator.md §A09.4).

  python3 -B scripts/account_harness/sim_load.py --minutes 30 --devices 10 --port 5339

10 devices of one user + the web act at 5x a person's pace (an action every ~0.5 s per device instead of every few
seconds) for --minutes; every device also keeps a real long-poll open (wait 25 s, as the service does), so the
server's waiters are exercised. Recorded: p50/p95/max of push and pull per device call, propagation time from a
push to another device's long-poll answer, backend CPU and RSS over time, the database size before/after. At the
end the run must converge like a simulator seed (sim_check) and the backend's RSS must be flat (no waiter leak).
"""
import argparse
import bisect
import json
import os
import random
import subprocess
import sys
import threading
import time
import urllib.error
import urllib.request

HERE = os.path.dirname(os.path.abspath(__file__))
sys.path.insert(0, HERE)
import sim  # noqa: E402
import sim_check  # noqa: E402


def pct(values, p):
    values = sorted(values)
    return round(values[min(len(values) - 1, int(len(values) * p))], 1) if values else None


def backend_pid(port):
    out = subprocess.run(['lsof', '-t', '-iTCP:{}'.format(port), '-sTCP:LISTEN'], capture_output=True, text=True).stdout.split()
    return out[0] if out else None


def sample(pid):
    out = subprocess.run(['ps', '-o', '%cpu=,rss=', '-p', pid], capture_output=True, text=True).stdout.split()
    return (float(out[0]), int(out[1]) // 1024) if len(out) == 2 else (None, None)


class Listener(threading.Thread):
    """A device's long-poll (the service's pull thread): records when each new revision arrived."""

    def __init__(self, base, profile, stop):
        super(Listener, self).__init__(daemon=True)
        self.base, self.profile, self.stop = base, profile, stop
        self.token = self.read_token()
        self.resigned = 0
        self.resigned_at = []                    # times of a 401 (the device signed out): no propagation measured then
        self.arrivals = []                       # (rev, time)
        self.errors = 0
        self.last_error = None

    def read_token(self):
        try:
            with open(os.path.join(self.profile, 'settings.json'), encoding='utf-8') as handle:
                return json.load(handle).get('account_token', '')
        except (OSError, ValueError):
            return ''

    def run(self):
        since = 0
        while not self.stop.is_set():
            request = urllib.request.Request('{}api/sync/changes?since={}&wait=25'.format(self.base, since), headers={
                'Authorization': 'Bearer ' + self.token, 'X-Milionar-Sync': '1', 'X-Milionar-Client': 'kodi/load'})
            try:
                with urllib.request.urlopen(request, timeout=35) as response:
                    data = json.loads(response.read().decode())
                rev = int(data.get('rev') or since)
                if rev != since:
                    self.arrivals.append((rev, time.time()))
                since = rev
            except urllib.error.HTTPError as exc:
                if exc.code == 401:                  # the device signed out and in again: its new token
                    self.resigned += 1
                    self.resigned_at.append(time.time())
                    self.token, since = self.read_token(), 0
                    time.sleep(1)
                    continue
                self.errors += 1
                self.last_error = 'HTTP {}'.format(exc.code)
                time.sleep(1)
            except Exception as exc:
                self.errors += 1
                self.last_error = '{}: {}'.format(type(exc).__name__, exc)
                time.sleep(1)


def main():
    parser = argparse.ArgumentParser()
    parser.add_argument('--minutes', type=float, default=30)
    parser.add_argument('--devices', type=int, default=10)
    parser.add_argument('--pace', type=float, default=0.5, help='seconds between actions of one device')
    parser.add_argument('--port', type=int, default=5339)
    parser.add_argument('--seed', type=int, default=4242)
    parser.add_argument('--json')
    args = parser.parse_args()
    backend = sim.start_backend(args.port, int(args.minutes) + 30)
    helper = 'http://127.0.0.1:{}'.format(args.port + 1)
    base = 'http://127.0.0.1:{}/'.format(args.port)
    pid = backend_pid(args.port)
    options = argparse.Namespace(faults='', kills=False, device_range=(args.devices, args.devices), action_range=(0, 0))
    run = sim.Run(args.seed, options, ('127.0.0.1', args.port), helper)
    stop = threading.Event()
    report = {'devices': args.devices, 'minutes': args.minutes, 'pace_s': args.pace}
    try:
        for index in range(len(run.devices)):
            run.signin(index, kills=False)
        listeners = []
        for device in run.devices:
            listener = Listener(base, device.profile, stop)
            listener.start()
            listeners.append(listener)
        db_sql = 'SELECT page_count * page_size AS bytes FROM pragma_page_count(), pragma_page_size()'
        report['db_bytes_before'] = run.web.db(db_sql)[0]['bytes']
        push_ms, pull_ms, pushes, samples = [], [], [], []
        rng = random.Random(args.seed)
        deadline = time.time() + args.minutes * 60
        next_sample = 0
        actions = 0
        step = args.pace / len(run.devices)
        while time.time() < deadline:
            started = time.time()
            if rng.random() < 0.15:
                run.web_action()
            else:
                index = rng.randrange(len(run.devices))
                run.device_action(index)
                rev_before = run.web.db('SELECT rev FROM account_rev WHERE user_id={}'.format(run.web.uid()))
                sync_started = time.time()
                result = run.devices[index].call('sync')
                push_ms += result.get('push_ms') or []
                pull_ms += result.get('pull_ms') or []
                if result.get('push_ms'):
                    pushes.append((sync_started, rev_before[0]['rev'] if rev_before else 0))
                run.ops += [dict(o, src='dev{}'.format(index)) for o in result['ops']]
            actions += 1
            if time.time() >= next_sample:
                samples.append((round(time.time()), *sample(pid)))
                next_sample = time.time() + 10
            time.sleep(max(0.0, step - (time.time() - started)))
        stop.set()
        # propagation: a push → the first long-poll answer with a newer revision, per listener
        propagation = []
        for listener in listeners:
            times = [t for _r, t in listener.arrivals]
            resigned = sorted(listener.resigned_at)
            for pushed_at, rev in pushes:
                # the first answer at or after the push that carries a newer revision (arrivals are in time order)
                first = None
                for index in range(bisect.bisect_left(times, pushed_at), len(times)):
                    if listener.arrivals[index][0] > rev:
                        first = times[index]
                        break
                if first is None:
                    continue
                # a listener of a device that signed out meanwhile waits for its new token: not a propagation delay
                low = bisect.bisect_left(resigned, pushed_at - 30)
                if low < len(resigned) and resigned[low] <= first:
                    continue
                propagation.append((first - pushed_at) * 1000)
        report.update(actions=actions, ops=len(run.ops), push_ms={'p50': pct(push_ms, .5), 'p95': pct(push_ms, .95), 'max': pct(push_ms, 1)},
                      pull_ms={'p50': pct(pull_ms, .5), 'p95': pct(pull_ms, .95), 'max': pct(pull_ms, 1)},
                      propagation_ms={'p50': pct(propagation, .5), 'p95': pct(propagation, .95)},
                      listener_errors=sum(l.errors for l in listeners), listener_last_error=[l.last_error for l in listeners if l.last_error][:3],
                      listener_resigned=sum(l.resigned for l in listeners),
                      cpu_percent={'mean': round(sum(s[1] for s in samples if s[1] is not None) / max(1, len(samples)), 1),
                                   'max': max((s[1] for s in samples if s[1] is not None), default=None)},
                      rss_mb={'first': samples[1][2] if len(samples) > 1 else None, 'last': samples[-1][2] if samples else None,
                              'max': max((s[2] for s in samples if s[2] is not None), default=None)},
                      db_bytes_after=run.web.db(db_sql)[0]['bytes'])
        result = run.finish(time.time())
        report['converged'] = result['ok']
        report['errors'] = result['errors'][:20]
    finally:
        stop.set()
        run.close()
        backend.terminate()
    print(json.dumps(report, indent=1))
    if args.json:
        with open(args.json, 'w', encoding='utf-8') as handle:
            json.dump(report, handle, indent=1)
    return 0 if report.get('converged') else 1


if __name__ == '__main__':
    sys.exit(main())
