"""Fault-injecting proxy (suites/robustness) against a real loopback upstream."""

from __future__ import annotations

import http.client

import sys

import threading

import unittest

from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer

from pathlib import Path

sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "suites" / "robustness"))

from robustness.faultproxy import Fault, FaultProxy  # noqa: E402

class Upstream:

    def __init__(self):

        self.seen: list[tuple[str, bytes]] = []

        outer = self

        class Handler(BaseHTTPRequestHandler):

            protocol_version = "HTTP/1.1"

            def log_message(self, *args):

                pass

            def do_POST(self):

                body = self.rfile.read(int(self.headers.get("Content-Length", "0")))

                outer.seen.append((self.path, body))

                payload = b"applied:" + body * 20

                self.send_response(200)

                self.send_header("Content-Length", str(len(payload)))

                self.end_headers()

                self.wfile.write(payload)

            do_GET = do_POST

        self.httpd = ThreadingHTTPServer(("127.0.0.1", 0), Handler)

        self.thread = threading.Thread(target=self.httpd.serve_forever, daemon=True)

        self.thread.start()

    @property

    def port(self) -> int:

        return self.httpd.server_address[1]

    def stop(self):

        self.httpd.shutdown()

        self.httpd.server_close()

def post(port: int, path: str, body: bytes = b"x") -> tuple[int, bytes]:

    conn = http.client.HTTPConnection("127.0.0.1", port, timeout=10)

    try:

        conn.request("POST", path, body=body)

        response = conn.getresponse()

        return response.status, response.read()

    finally:

        conn.close()

class FaultProxyTests(unittest.TestCase):

    def setUp(self):

        self.upstream = Upstream()

    def tearDown(self):

        self.upstream.stop()

    def test_passthrough_records_requests(self):

        with FaultProxy(self.upstream.port) as proxy:

            status, data = post(proxy.port, "/api/push?x=1", b"abc")

        self.assertEqual(status, 200)

        self.assertTrue(data.startswith(b"applied:abc"))

        self.assertEqual(proxy.keys_in_order(), [("POST /api/push", 1)])

    def test_fail_status_never_forwards(self):

        with FaultProxy(self.upstream.port, [Fault("fail_status", key="POST /api/push", status=503)]) as proxy:

            status, _ = post(proxy.port, "/api/push")

            second, _ = post(proxy.port, "/api/push")

        self.assertEqual((status, second), (503, 200))

        self.assertEqual(len(self.upstream.seen), 1)  # only the second reached the server

    def test_drop_after_send_applies_then_loses_reply(self):

        with FaultProxy(self.upstream.port, [Fault("drop_after_send", key="POST /api/push")]) as proxy:

            with self.assertRaises((http.client.HTTPException, ConnectionError, OSError)):

                post(proxy.port, "/api/push")

        self.assertEqual(len(self.upstream.seen), 1)  # the server applied it: unknown outcome

        self.assertEqual(proxy.records[0].tag, "REPLY_DROPPED")

    def test_truncated_reply_is_detectably_incomplete(self):

        with FaultProxy(self.upstream.port, [Fault("truncate_reply", key="POST /api/push")]) as proxy:

            with self.assertRaises((http.client.IncompleteRead, http.client.HTTPException, ConnectionError, OSError)):

                post(proxy.port, "/api/push", b"0123456789")

    def test_kill_hooks_fire_before_and_after_upstream(self):

        calls: list[str] = []

        faults = [Fault("kill_before_forward", key="POST /a"), Fault("kill_after_upstream", key="POST /b")]

        with FaultProxy(self.upstream.port, faults, kill_hook=lambda: calls.append("kill")) as proxy:

            for path in ("/a", "/b"):

                with self.assertRaises((http.client.HTTPException, ConnectionError, OSError)):

                    post(proxy.port, path)

        self.assertEqual(calls, ["kill", "kill"])

        self.assertEqual([p for p, _ in self.upstream.seen], ["/b"])

    def test_occurrence_targets_the_nth_request(self):

        with FaultProxy(self.upstream.port, [Fault("fail_status", key="POST /p", occurrence=2)]) as proxy:

            statuses = [post(proxy.port, "/p")[0] for _ in range(3)]

        self.assertEqual(statuses, [200, 503, 200])

    def test_refuses_non_loopback_upstream(self):

        with self.assertRaises(ValueError):

            FaultProxy(443, upstream_host="104.18.0.1")

if __name__ == "__main__":

    unittest.main()