#!/usr/bin/env python3
"""
Local DNS Resolver — customizable request/response handling.
Uses only the standard library + dnslib.

Usage:
    pip install dnslib
    sudo python dns_resolver.py          # binds to 0.0.0.0:53 by default
    python dns_resolver.py --port 5353   # unprivileged port for testing
"""

import argparse
import socket
import threading
from dnslib import DNSRecord, DNSHeader, RR, QTYPE, A, CNAME, AAAA


UPSTREAM_DNS = ("8.8.8.8", 53)   # fallback resolver


def handle_no_aaaa(query: DNSRecord) -> DNSRecord | None:
    """Drop all AAAA requests."""
    if QTYPE[query.q.qtype] == "AAAA":
        reply = query.reply()
        reply.header.rcode = 3  # NXDOMAIN
        return reply
    return None

def handle_blocked(query: DNSRecord) -> DNSRecord | None:
    """Block domains by returning NXDOMAIN."""
    blocked = {"blocked.example.com.", "ads.tracker.io."}
    qname = str(query.q.qname)
    if qname in blocked:
        print(f"  [BLOCKED] {qname}")
        reply = query.reply()
        reply.header.rcode = 3          # NXDOMAIN
        return reply
    return None

failer = 0
MAX_FAIL = 2
MAX_SUCCESS = 2

def handle_overrides(query: DNSRecord) -> DNSRecord | None:
    global failer
    """Return hardcoded A records for specific names (split-horizon / local dev)."""
    overrides: dict[str, str] = {
        "myapp.local.":     "127.0.0.1",
        "devserver.local.": "192.168.1.100",
        "mydomain.com.":    "127.0.0.1",
    }
    qname = str(query.q.qname)
    qtype = QTYPE[query.q.qtype]

    if qname in overrides and qtype == "A":
        failer += 1
        cycle_pos = (failer - 1) % (MAX_FAIL + MAX_SUCCESS)  # position within cycle
        should_fail = cycle_pos < MAX_FAIL

        print(f"  [OVERRIDE] request={failer} cycle_pos={cycle_pos} fail={should_fail}")

        if should_fail:
            reply = query.reply()
            reply.header.rcode = 3
            reply.header.ra = 0
            return reply

        ip = overrides[qname]
        print(f"  [OVERRIDE] {qname} → {ip}")
        reply = query.reply()
        reply.add_answer(RR(qname, QTYPE.A, rdata=A(ip), ttl=0))
        reply.header.ra = 0
        return reply

    return None


def handle_rewrite(query: DNSRecord) -> DNSRecord | None:
    """Rewrite a CNAME transparently (resolve alias locally)."""
    rewrites: dict[str, str] = {
        # "old.internal.": "new.internal.",
    }
    qname = str(query.q.qname)
    if qname in rewrites:
        target = rewrites[qname]
        print(f"  [REWRITE] {qname} → {target}")
        reply = query.reply()
        reply.add_answer(RR(qname, QTYPE.CNAME, rdata=CNAME(target), ttl=60))
        return reply
    return None


def handle_upstream(query: DNSRecord) -> DNSRecord | None:
    """Forward the query to the upstream resolver."""
    try:
        raw = query.pack()
        sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
        sock.settimeout(3)
        sock.sendto(raw, UPSTREAM_DNS)
        data, _ = sock.recvfrom(4096)
        sock.close()
        reply = DNSRecord.parse(data)
        print(f"  [UPSTREAM] {query.q.qname} → {UPSTREAM_DNS[0]}")
        return reply
    except Exception as e:
        print(f"  [UPSTREAM ERROR] {e}")
        return None


# Chain of responsibility — handlers are tried in order; first non-None wins.
HANDLERS = [
    handle_blocked,
    handle_overrides,
    handle_rewrite,
    handle_upstream,
]


# ─────────────────────────────────────────────────────────────────────────────
#  Server plumbing — no need to edit below this line
# ─────────────────────────────────────────────────────────────────────────────

def resolve(data: bytes) -> bytes:
    try:
        query = DNSRecord.parse(data)
        qname = str(query.q.qname)
        qtype = QTYPE[query.q.qtype]
        print(f"[QUERY] {qtype} {qname}")

        for handler in HANDLERS:
            reply = handler(query)
            if reply is not None:
                return reply.pack()

        # Fallback: SERVFAIL
        reply = query.reply()
        reply.header.rcode = 2
        return reply.pack()

    except Exception as e:
        print(f"[ERROR] Failed to parse/handle query: {e}")
        return b""


def udp_server(host: str, port: int) -> None:
    sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
    sock.bind((host, port))
    print(f"DNS resolver listening on {host}:{port} (UDP)")
    while True:
        data, addr = sock.recvfrom(4096)
        threading.Thread(
            target=lambda d=data, a=addr: sock.sendto(resolve(d), a),
            daemon=True,
        ).start()


def tcp_server(host: str, port: int) -> None:
    srv = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    srv.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
    srv.bind((host, port))
    srv.listen(10)
    print(f"DNS resolver listening on {host}:{port} (TCP)")

    def handle_conn(conn: socket.socket) -> None:
        with conn:
            length_bytes = conn.recv(2)
            if len(length_bytes) < 2:
                return
            length = int.from_bytes(length_bytes, "big")
            data = conn.recv(length)
            response = resolve(data)
            conn.sendall(len(response).to_bytes(2, "big") + response)

    while True:
        conn, _ = srv.accept()
        threading.Thread(target=handle_conn, args=(conn,), daemon=True).start()


def main() -> None:
    parser = argparse.ArgumentParser(description="Local DNS resolver")
    parser.add_argument("--host", default="0.0.0.0", help="Bind address")
    parser.add_argument("--port", type=int, default=53, help="Bind port (use 5353 for unprivileged)")
    args = parser.parse_args()

    t_udp = threading.Thread(target=udp_server, args=(args.host, args.port), daemon=True)
    t_tcp = threading.Thread(target=tcp_server, args=(args.host, args.port), daemon=True)
    t_udp.start()
    t_tcp.start()

    try:
        t_udp.join()
    except KeyboardInterrupt:
        print("\nShutting down.")


if __name__ == "__main__":
    main()