import argparse
import hashlib
import json
from pathlib import Path
import sys
import time

import serial


def read_until(port, predicate, timeout, limit=4096):
    data = bytearray()
    deadline = time.monotonic() + timeout
    while time.monotonic() < deadline and len(data) < limit:
        data.extend(port.read(max(1, min(port.in_waiting, limit - len(data)))))
        if predicate(bytes(data)):
            break
    return bytes(data)


def run(port_name):
    result = {"port": port_name, "baud": 9600, "format": "8N1", "tests": []}
    lines = ["TASK 10 / ATmega328P USART", f"PORT: {port_name}", "SETTINGS: 9600 baud, 8N1, no flow control"]
    ok = False
    try:
        with serial.Serial(port_name, 9600, timeout=0.1, write_timeout=2,
                           bytesize=serial.EIGHTBITS, parity=serial.PARITY_NONE,
                           stopbits=serial.STOPBITS_ONE,
                           xonxoff=False, rtscts=False, dsrdtr=False) as port:
            port.dtr = False
            time.sleep(0.1)
            port.reset_input_buffer()
            port.dtr = True

            expected = b"ATmega328P ready\r\n"
            banner = read_until(port, lambda data: expected in data, 6)
            result["greeting"] = banner.decode("ascii", errors="backslashreplace")
            result["greeting_ok"] = expected in banner
            lines.append(f"RX greeting: {banner!r}")
            if expected not in banner:
                raise RuntimeError("Greeting not received after DTR reset")
            lines.append("Greeting: PASS")

            cases = [
                ("text", b"Hello, UART!\r\n"),
                ("digits", b"0123456789\r\n"),
                ("printable ASCII", bytes(range(32, 127)) + b"\r\n"),
                ("all 256 byte values", bytes(range(256))),
            ]
            for name, payload in cases:
                port.reset_input_buffer()
                port.write(payload)
                port.flush()
                received = read_until(port, lambda data: len(data) >= len(payload), 4)
                same = received == payload
                test = {
                    "name": name, "sent_bytes": len(payload),
                    "received_bytes": len(received), "passed": same,
                    "tx_sha256": hashlib.sha256(payload).hexdigest(),
                    "rx_sha256": hashlib.sha256(received).hexdigest(),
                }
                result["tests"].append(test)
                lines.append(f"\n{name}: {'PASS' if same else 'FAIL'} ({len(received)}/{len(payload)} bytes)")
                if name in ("text", "digits"):
                    lines.extend([f"TX: {payload!r}", f"RX: {received!r}"])
                else:
                    lines.extend([f"TX SHA256: {test['tx_sha256']}", f"RX SHA256: {test['rx_sha256']}"])
                if not same:
                    raise RuntimeError(f"Echo mismatch: {name}")
            ok = True
    except Exception as error:
        result["error"] = str(error)
        lines.append(f"ERROR: {error}")

    result["passed"] = ok
    lines.extend(["", f"RESULT: {'PASS' if ok else 'FAIL'}", "Serial port closed."])
    report = "\n".join(lines) + "\n"
    Path("terminal-test.txt").write_text(report, encoding="utf-8")
    Path("terminal-test.json").write_text(json.dumps(result, indent=2), encoding="utf-8")
    print(report, end="")
    return 0 if ok else 1


if __name__ == "__main__":
    parser = argparse.ArgumentParser()
    parser.add_argument("--port", default="COM8")
    args = parser.parse_args()
    sys.exit(run(args.port))
