# -*- coding: utf-8 -*-
"""Fault proxy between one simulated device and the harness backend (WEB docs/plan/account-sync/phases/A09 §A09.2).

Each device gets its own proxy and its own seeded random stream, so a device's sequence of faults is reproducible
(the device sends one request at a time). Faults, per request when `enabled`:
  drop_request   the connection closes before the server saw the request
  drop_response  the server applied the request, the device never gets the answer
  delay          0-300 ms before forwarding and before answering (also skews the learned clock offset)
  duplicate      the request reaches the server twice (the device gets the second answer)
  late_copy      a push is kept and sent again later, after newer pushes (an old request arriving last)
  error          503 without forwarding
  hang           the answer never comes within the device's timeout
"""
import http.client
import random
import socketserver
import threading
import time
from http.server import BaseHTTPRequestHandler, HTTPServer

FAULTS = ('drop_request', 'drop_response', 'delay', 'duplicate', 'late_copy', 'error', 'hang')
RATES = {'drop_request': 0.03, 'drop_response': 0.04, 'delay': 0.15, 'duplicate': 0.04, 'late_copy': 0.04,
         'error': 0.03, 'hang': 0.003}
HANG_S = 9.5


class _Server(socketserver.ThreadingMixIn, HTTPServer):
    daemon_threads = True
    allow_reuse_address = True


class FaultProxy(object):
    def __init__(self, backend_host, backend_port, seed, faults=FAULTS):
        self.backend = (backend_host, backend_port)
        self.random = random.Random(seed)
        self.faults = set(faults)
        self.enabled = False
        self.lock = threading.Lock()
        self.late = []                     # (method, path, headers, body) of pushes to send again later
        self.counts = {name: 0 for name in FAULTS}
        proxy = self

        class Handler(BaseHTTPRequestHandler):
            protocol_version = 'HTTP/1.1'

            def log_message(self, *args):
                pass

            def do_GET(self):
                proxy.handle(self)

            do_POST = do_PUT = do_DELETE = do_GET

        self.server = _Server(('127.0.0.1', 0), Handler)
        self.port = self.server.server_address[1]
        self.thread = threading.Thread(target=self.server.serve_forever, daemon=True)
        self.thread.start()

    @property
    def url(self):
        return 'http://127.0.0.1:{}/'.format(self.port)

    def close(self):
        self.server.shutdown()
        self.server.server_close()

    def _pick(self):
        with self.lock:
            if not self.enabled:
                return set()
            return {name for name in self.faults if self.random.random() < RATES[name]}

    def _forward(self, method, path, headers, body):
        conn = http.client.HTTPConnection(*self.backend, timeout=30)
        try:
            conn.request(method, path, body=body, headers=headers)
            response = conn.getresponse()
            return response.status, response.getheaders(), response.read()
        finally:
            conn.close()

    def flush_late(self):
        """Send the kept old pushes now (they reach the server after newer ones)."""
        with self.lock:
            late, self.late = self.late, []
        for request in late:
            try:
                self._forward(*request)
            except Exception:
                pass

    def handle(self, handler):
        length = int(handler.headers.get('Content-Length') or 0)
        body = handler.rfile.read(length) if length else None
        headers = {k: v for k, v in handler.headers.items() if k.lower() not in ('host', 'connection', 'accept-encoding')}
        method, path = handler.command, handler.path
        faults = self._pick()
        for name in faults:
            self.counts[name] += 1
        if 'delay' in faults:
            time.sleep(self.random.random() * 0.3)
        if 'drop_request' in faults:
            handler.close_connection = True
            handler.connection.close()
            return
        if 'error' in faults:
            self._reply(handler, 503, [('Content-Type', 'application/json')], b'{"error":{"code":"unavailable"}}')
            return
        if 'hang' in faults:
            time.sleep(HANG_S)
            handler.close_connection = True
            handler.connection.close()
            return
        if self.late and self.random.random() < 0.5:
            self.flush_late()
        try:
            status, response_headers, data = self._forward(method, path, headers, body)
            if 'duplicate' in faults:
                status, response_headers, data = self._forward(method, path, headers, body)
            if 'late_copy' in faults and path.split('?')[0].endswith('/sync/push'):
                with self.lock:
                    self.late.append((method, path, headers, body))
        except Exception:
            self._reply(handler, 502, [('Content-Type', 'application/json')], b'{"error":{"code":"bad_gateway"}}')
            return
        if 'drop_response' in faults:
            handler.close_connection = True
            handler.connection.close()
            return
        if 'delay' in faults:
            time.sleep(self.random.random() * 0.3)
        self._reply(handler, status, response_headers, data)

    def _reply(self, handler, status, headers, data):
        handler.send_response(status)
        for name, value in headers:
            if name.lower() not in ('transfer-encoding', 'connection', 'content-length', 'date', 'keep-alive'):
                handler.send_header(name, value)
        handler.send_header('Content-Length', str(len(data)))
        handler.send_header('Connection', 'close')
        handler.end_headers()
        try:
            handler.wfile.write(data)
        except OSError:
            pass                                  # the device gave up waiting (its timeout)
        handler.close_connection = True
