#!/usr/bin/env python3
"""Account sync simulator (WEB docs/plan/account-sync/phases/A09-simulator.md, 07-testing.md §4).

  python3 -B scripts/account_harness/sim.py --seeds 1-1000 --devices 2-4 --actions 40-120 --faults all --workers 6
  python3 -B scripts/account_harness/sim.py --seeds regress          # every seed of seeds.json

N devices (separate processes, the real addon code on its own profile, own clock offset and drift, each behind its
own fault proxy) and the web user act on one account in a seeded random order: play progress, finish, mark/unmark,
list add/remove, hide from Continue, feedback, channels (create/rename/delete/items), settings, reset, sign-out and
sign-in. Devices are killed at random points of a sync or a switch and restarted. At the end the faults stop, every
device syncs until idle, a fresh device signs in, and sim_check compares everything. Starts its own harness backend
(WEB scripts/harness/sync-backend.ts) on --port and stops it. Exit 0 only when every seed passed.
"""
import argparse
import json
import multiprocessing
import os
import random
import shutil
import subprocess
import sys
import tempfile
import time
import uuid

HERE = os.path.dirname(os.path.abspath(__file__))
sys.path.insert(0, HERE)
import sim_check  # noqa: E402
from sim_actors import DeviceHandle, WebActor, http_json  # noqa: E402
from sim_proxy import FAULTS, FaultProxy  # noqa: E402

WEB = '/Users/chudy/Documents/Projector/Projects/milionar'
SEEDS_FILE = os.path.join(HERE, 'seeds.json')
MOVIES = [101, 102, 103, 104]
EPISODES = [(201, 1, 1), (201, 1, 2), (202, 1, 1)]
SETTINGS = {'mytv_upcoming_count': ['8', '12', '20', '30'], 'autoplay_first_item_delay': ['3', '5', '8']}
HOUR_MS = 3600 * 1000


def watch_target(rng):
    if rng.random() < 0.6:
        return ('movie', rng.choice(MOVIES), None, None)
    show, season, episode = rng.choice(EPISODES)
    return ('tv', show, season, episode)


def wkey(target):
    media, tmdb_id, season, episode = target
    return 'movie:{}'.format(tmdb_id) if media == 'movie' else 'tv:{}:{}:{}'.format(tmdb_id, season, episode)


class Run(object):
    def __init__(self, seed, args, backend, helper):
        self.seed, self.args = seed, args
        self.rng = random.Random(seed)
        self.helper = helper
        self.backend = backend
        self.root = tempfile.mkdtemp(prefix='milionar-sim-{}-'.format(seed))
        self.email = 'sim-{}-{}@harness.test'.format(seed, uuid.uuid4().hex[:6])
        http_json(helper + '/user', {'email': self.email, 'name': 'Sim {}'.format(seed)})
        self.web = WebActor(helper, self.email)
        self.ops = []
        self.devices, self.proxies, self.local = [], [], {}
        self.log = []
        self.faults = set(FAULTS) if args.faults == 'all' else set(f for f in args.faults.split(',') if f in FAULTS)
        low, high = args.device_range
        for index in range(self.rng.randint(low, high)):
            self.add_device(index)

    # ------------------------------------------------------------------ devices
    def add_device(self, index, clock=True):
        host, port = self.backend
        proxy = FaultProxy(host, port, self.seed * 100 + index, self.faults)
        spec = None
        if clock and 'clock' in self.args.faults.split(',') + (['clock'] if self.args.faults == 'all' else []):
            spec = '{},{}'.format(int(self.rng.uniform(-6, 6) * HOUR_MS), int(self.rng.uniform(-800, 800)))
        name = 'dev{}'.format(index)
        device = DeviceHandle(name, os.path.join(self.root, name), proxy.url, self.helper, spec)
        self.devices.append(device)
        self.proxies.append(proxy)
        return device

    def calm(self, index, on):
        self.proxies[index].enabled = not on and bool(self.faults)

    def signin(self, index, kills=True):
        device = self.devices[index]
        self.local[index] = device.call('dump')               # S4: this comes back at the sign-out
        self.calm(index, True)
        try:
            if kills and self.args.kills and self.rng.random() < 0.15:
                device.call_or_kill(self.rng.uniform(0.05, 0.6), 'pair', self.email)
            else:
                device.call('pair', self.email)
        finally:
            self.calm(index, False)
        self.after_switch(index)

    def signout(self, index):
        device = self.devices[index]
        self.flush(index)
        if self.args.kills and self.rng.random() < 0.2:
            device.call_or_kill(self.rng.uniform(0.02, 0.4), 'signout')
        else:
            device.call('signout')
        self.after_switch(index)

    def after_switch(self, index):
        status = self.devices[index].call('status')
        if not status['signed_in'] and index in self.local:
            restored = self.devices[index].call('dump')
            for line in sim_check.diff(self.local.pop(index), restored)[:8]:
                self.fail('dev{} local data not restored after sign-out: {}'.format(index, line))

    def flush(self, index, rounds=6):
        """Faults off for this device, everything sent (before a sign-out, as the S20 wait does)."""
        self.calm(index, True)
        try:
            for _ in range(rounds):
                self.devices[index].call('due_now')
                result = self.devices[index].call('sync')
                self.ops += [dict(o, src='dev{}'.format(index)) for o in result['ops']]
                if result['error']:
                    self.log.append('dev{} flush error {} outbox {}'.format(index, result['error'], result['outbox']))
                if not result['outbox'] and not result['error']:
                    break
        finally:
            self.calm(index, False)

    def sync(self, index):
        device = self.devices[index]
        if self.args.kills and self.rng.random() < 0.04:
            result, killed = device.call_or_kill(self.rng.uniform(0.0, 0.08), 'sync')
            if killed:
                self.log.append('killed dev{} in a sync: {}'.format(index, device.call('status')))
                self.after_switch(index)
                return
        else:
            result = device.call('sync')
        self.ops += [dict(o, src='dev{}'.format(index)) for o in result['ops']]
        if result.get('logout'):
            self.after_switch(index)

    def fail(self, message):
        self.log.append('FAIL ' + message)

    # ------------------------------------------------------------------ actions
    def device_action(self, index):
        rng, device = self.rng, self.devices[index]
        roll = rng.random()
        target = watch_target(rng)
        media, tmdb_id, season, episode = target
        title = (media, tmdb_id)
        self.log.append('dev{} {:.2f} {}'.format(index, roll, target))
        if roll < 0.30:
            ops = device.call('act', 'progress', media, tmdb_id, rng.choice([300, 1200, 2400, 3600, 5000]), 6000, season, episode)
        elif roll < 0.42:
            ops = device.call('act', 'watched', media, tmdb_id, season, episode)
        elif roll < 0.48:
            ops = device.call('act', 'unwatched', media, tmdb_id, season, episode)
        elif roll < 0.51:
            ops = device.call('act', 'clear_resume', media, tmdb_id, season, episode)
        elif roll < 0.61:
            ops = device.call('act', 'list_add', title[0], title[1], rng.random() < 0.6)
        elif roll < 0.65:
            ops = device.call('act', 'hide', title[0], title[1], rng.random() < 0.6)
        elif roll < 0.69:
            ops = device.call('act', 'feedback', title[0], title[1], rng.choice(['like', 'dislike', None]))
        elif roll < 0.80:
            ops = self.device_channel(device)
        elif roll < 0.85:
            key = rng.choice(sorted(SETTINGS))
            ops = device.call('act', 'setting', key, rng.choice(SETTINGS[key]))
        elif roll < 0.86:
            ops = device.call('act', 'reset')
        elif roll < 0.90:
            status = device.call('status')
            if status['signed_in'] and rng.random() < 0.5:
                self.signout(index)
            elif not status['signed_in']:
                self.signin(index)
            ops = []
        else:
            self.sync(index)
            ops = []
        self.ops += [dict(o, src='dev{}'.format(index)) for o in ops]

    def device_channel(self, device):
        rng = self.rng
        dump = device.call('dump')
        mine = sorted(dump['channels'])
        roll = rng.random()
        if not mine or roll < 0.3:
            kind = rng.choice(['tv', 'cinema'])
            items = [{'id': rng.choice(MOVIES if kind == 'cinema' else [201, 202]), 'name': 'x'}]
            return device.call('act', 'channel', uuid.uuid4().hex[:12], 'K{}'.format(rng.randint(1, 99)), items, kind)
        uuid_ = rng.choice(mine)
        kind = dump['channels'][uuid_][0]
        if roll < 0.55:
            return device.call('act', 'channel_rename', uuid_, 'R{}'.format(rng.randint(1, 99)), kind)
        if roll < 0.7:
            return device.call('act', 'channel_delete', uuid_, kind)
        item = {'id': rng.choice(MOVIES if kind == 'cinema' else [201, 202]), 'name': 'x'}
        return device.call('act', 'channel_item', uuid_, item, rng.random() < 0.6, kind)

    def web_action(self):
        rng, web = self.rng, self.web
        roll = rng.random()
        target = watch_target(rng)
        key = wkey(target)
        self.log.append('web {:.2f} {}'.format(roll, key))
        if roll < 0.35:
            ops = web.progress(key, rng.choice([400, 1500, 3000, 4500, 5900]), 6000)
        elif roll < 0.45 and target[0] == 'tv':
            ops = web.episodes(key, rng.random() < 0.6)
        elif roll < 0.6:
            ops = web.list_set('{}:{}'.format(target[0], target[1]), rng.random() < 0.6)
        elif roll < 0.65:
            ops = web.feedback('{}:{}'.format(target[0], target[1]), rng.choice(['like', 'dislike']))
        elif roll < 0.85:
            channels = web.channels()
            sub = rng.random()
            if not channels or sub < 0.3:
                ops = web.channel_create(rng.choice(['tv', 'cinema']), 'W{}'.format(rng.randint(1, 99)))
            else:
                channel = rng.choice(channels)
                if sub < 0.55:
                    ops = web.channel_rename(channel, 'V{}'.format(rng.randint(1, 99)))
                elif sub < 0.7:
                    ops = web.channel_delete(channel)
                else:
                    ops = web.channel_item(channel, 'movie' if channel['channel_type'] == 'cinema' else 'tv',
                                           rng.choice(MOVIES if channel['channel_type'] == 'cinema' else [201, 202]), rng.random() < 0.6)
        else:
            setting = rng.choice(sorted(SETTINGS))
            ops = web.setting(setting, rng.choice(SETTINGS[setting]))
        self.ops += [dict(o, src='web') for o in ops]

    # ------------------------------------------------------------------ run
    def run(self):
        started = time.time()
        for index in range(len(self.devices)):
            self.signin(index, kills=False)
            self.sync(index)
        for proxy in self.proxies:
            proxy.enabled = bool(self.faults)
        low, high = self.args.action_range
        for _ in range(self.rng.randint(low, high)):
            if self.rng.random() < 0.22:
                self.web_action()
            else:
                self.device_action(self.rng.randrange(len(self.devices)))
            if self.rng.random() < 0.3:
                self.sync(self.rng.randrange(len(self.devices)))
        return self.finish(started)

    def finish(self, started):
        for proxy in self.proxies:
            proxy.enabled = False
            proxy.flush_late()
        for index, device in enumerate(self.devices):
            if not device.call('status')['signed_in']:
                self.signin(index, kills=False)
        for _round in range(4):
            for index in range(len(self.devices)):
                self.flush(index)
        statuses = {d.name: d.call('status') for d in self.devices}
        dumps = {d.name: d.call('dump') for d in self.devices}
        fresh = self.add_device(len(self.devices), clock=False)
        self.proxies[-1].enabled = False
        fresh.call('pair', self.email)
        fresh.call('sync')
        reference = fresh.call('dump')
        errors = [line[5:] for line in self.log if line.startswith('FAIL ')]
        errors += sim_check.check_all(self.ops, dumps, reference, statuses, self.web)
        faults = {}
        for proxy in self.proxies:
            for name, count in proxy.counts.items():
                faults[name] = faults.get(name, 0) + count
        detail = {'ops': self.ops, 'log': self.log, 'dumps': dumps, 'reference': reference} if errors else None
        return {'seed': self.seed, 'ok': not errors, 'errors': errors, 'devices': len(self.devices) - 1, 'ops': len(self.ops), 'detail': detail,
                'restarts': sum(d.restarts for d in self.devices), 'faults': faults, 'seconds': round(time.time() - started, 1)}

    def close(self):
        for device in self.devices:
            device.close()
        for proxy in self.proxies:
            proxy.close()
        shutil.rmtree(self.root, ignore_errors=True)


def run_seed(job):
    seed, args, backend, helper = job
    run = None
    try:
        run = Run(seed, args, backend, helper)
        return run.run()
    except Exception as exc:
        import traceback
        return {'seed': seed, 'ok': False, 'errors': ['crash: {}: {}'.format(type(exc).__name__, exc), traceback.format_exc()[-1500:]]}
    finally:
        if run:
            run.close()


def parse_range(text):
    low, _sep, high = text.partition('-')
    return int(low), int(high or low)


def seed_list(text):
    if text == 'regress':
        with open(SEEDS_FILE, encoding='utf-8') as handle:
            return [entry['seed'] for entry in json.load(handle)]
    low, high = parse_range(text)
    return list(range(low, high + 1))


def start_backend(port, ttl):
    process = subprocess.Popen(['npx', 'tsx', 'scripts/harness/sync-backend.ts', '--port', str(port), '--ttl', str(ttl)],
                               cwd=WEB, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True)
    for line in process.stdout:
        if line.startswith('SYNC_HELPER='):
            return process
    raise RuntimeError('harness backend did not start')


def main():
    parser = argparse.ArgumentParser()
    parser.add_argument('--seeds', default='1-20')
    parser.add_argument('--devices', default='2-4')
    parser.add_argument('--actions', default='40-120')
    parser.add_argument('--faults', default='all', help="'all', 'none' or a comma list of {} and clock".format(', '.join(FAULTS)))
    parser.add_argument('--no-kills', dest='kills', action='store_false')
    parser.add_argument('--workers', type=int, default=4)
    parser.add_argument('--port', type=int, default=5239)
    parser.add_argument('--ttl', type=int, default=240)
    parser.add_argument('--json', help='write every result here')
    args = parser.parse_args()
    args.device_range, args.action_range = parse_range(args.devices), parse_range(args.actions)
    if args.faults == 'none':
        args.faults = ''
    seeds = seed_list(args.seeds)
    backend = start_backend(args.port, args.ttl)
    helper = 'http://127.0.0.1:{}'.format(args.port + 1)
    results = []
    started = time.time()
    try:
        jobs = [(seed, args, ('127.0.0.1', args.port), helper) for seed in seeds]
        with multiprocessing.Pool(args.workers) as pool:
            for result in pool.imap_unordered(run_seed, jobs):
                results.append(result)
                mark = 'ok  ' if result['ok'] else 'FAIL'
                print('{} seed {} devices {} ops {} restarts {} {}s'.format(mark, result['seed'], result.get('devices'), result.get('ops'),
                                                                         result.get('restarts'), result.get('seconds')), flush=True)
                if not result['ok']:
                    for line in result['errors'][:10]:
                        print('     ' + line, flush=True)
    finally:
        backend.terminate()
        try:
            backend.wait(timeout=10)
        except Exception:
            backend.kill()
    failed = sorted(r['seed'] for r in results if not r['ok'])
    faults = {}
    for r in results:
        for name, count in (r.get('faults') or {}).items():
            faults[name] = faults.get(name, 0) + count
    print('{} / {} seeds passed in {:.0f} s; faults injected: {}'.format(len(results) - len(failed), len(results), time.time() - started, faults))
    if failed:
        print('failed seeds: {}'.format(failed))
    if args.json:
        with open(args.json, 'w', encoding='utf-8') as handle:
            json.dump(results, handle, indent=1)
    return 1 if failed else 0


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