import importlib.util
import json
from pathlib import Path
import unittest
from types import SimpleNamespace
from unittest.mock import patch

ROOT = Path(__file__).parent
spec = importlib.util.spec_from_file_location("openai_router_network", ROOT / "network.py")
network = importlib.util.module_from_spec(spec)
spec.loader.exec_module(network)


class RouterTests(unittest.TestCase):
    def setUp(self):
        self.config = json.loads((ROOT / "config.json").read_text())

    def test_only_two_suffixes_are_proxied_with_no_direct_data_fallback(self):
        rules = self.config["route"]["rules"]
        self.assertEqual(rules[1]["domain_suffix"], ["chatgpt.com", "openai.com"])
        self.assertEqual(rules[1]["outbound"], "existing-proxy")
        self.assertEqual(rules[-1], {"action": "reject"})
        self.assertEqual(self.config["outbounds"], [{"type": "http", "tag": "existing-proxy",
                         "server": "127.0.0.1", "server_port": 1081}])

    def test_dns_only_selected_domains_get_persistent_fake_addresses(self):
        dns = self.config["dns"]
        fake = dns["rules"][1]
        self.assertEqual(fake["domain_suffix"], ["chatgpt.com", "openai.com"])
        self.assertEqual(fake["query_type"], ["A", "AAAA"])
        self.assertEqual(fake["server"], "openai-fake")
        self.assertEqual(fake["rewrite_ttl"], 60)
        self.assertEqual(dns["final"], "original-dns")
        self.assertTrue(dns["disable_cache"])
        self.assertTrue(self.config["experimental"]["cache_file"]["store_fakeip"])

    def test_dns_ip_hints_cannot_bypass_selected_domain_routing(self):
        rule = self.config["dns"]["rules"][0]
        self.assertEqual(rule["query_type"], ["HTTPS", "SVCB"])
        self.assertEqual(rule["action"], "predefined")
        self.assertEqual(rule["rcode"], "NOERROR")
        self.assertEqual(rule["domain_suffix"], ["chatgpt.com", "openai.com"])

    def test_dns_interception_is_limited_to_existing_resolver_and_skips_own_uid(self):
        rendered = network.render(991)
        for line in rendered.splitlines():
            if "redirect to :15353" in line:
                self.assertIn("ip daddr 192.168.35.1", line)
                self.assertIn("dport 53", line)
                self.assertTrue("meta skuid != 991" in line or 'iifname "docker0"' in line or 'iifname "br-*"' in line)
        for uid in (0, -1, "991"):
            with self.assertRaises(ValueError):
                network.render(uid)

    def test_data_interception_only_reserved_ranges_ipv4_ipv6(self):
        for line in network.render(991).splitlines():
            if "redirect to :1808" in line or "reject with icmpx" in line:
                self.assertTrue("198.19.0.0/16" in line or "fd74:6f70:656e::/48" in line)
        self.assertNotIn("flush", network.render(991))

    def test_removal_deletes_only_owned_tables_and_owned_route(self):
        with patch.object(network, "table_exists", return_value=True), \
             patch.object(network, "run") as run, patch.object(network, "remove_route") as route:
            network.remove()
        text = run.call_args.kwargs["input"]
        self.assertEqual(text, "delete table inet openai_domain_dns\ndelete table inet openai_domain_traffic\n")
        route.assert_called_once()

    def test_dns_off_keeps_cached_addresses_working_during_grace_period(self):
        with patch.object(network, "table_exists", return_value=True), \
             patch.object(network, "run") as run, patch.object(network, "remove_route") as route:
            network.remove(dns_only=True)
        self.assertEqual(run.call_args.kwargs["input"], "delete table inet openai_domain_dns\n")
        route.assert_not_called()

    def test_foreign_tables_are_not_removed(self):
        with patch.object(network, "table_exists", side_effect=RuntimeError("foreign")), \
             patch.object(network, "run") as run, patch.object(network, "remove_route") as route:
            with self.assertRaises(RuntimeError):
                network.remove()
        run.assert_not_called()
        route.assert_not_called()

    def test_foreign_ipv6_route_is_not_owned(self):
        self.assertFalse(network.owned_route({"dev": "eth0", "protocol": 186, "metric": 42760}))
        self.assertFalse(network.owned_route({"dev": "lo", "protocol": "static", "metric": 42760}))
        self.assertTrue(network.owned_route({"dev": "lo", "protocol": 186, "metric": 42760}))

    def test_nft_ownership_uses_native_comment_when_old_json_omits_it(self):
        with patch.object(network.subprocess, "run", return_value=SimpleNamespace(returncode=0,
            stdout='table inet openai_domain_dns {\n comment "Managed by openai-domain-router"\n chain output {}\n}')):
            self.assertTrue(network.table_exists(network.DNS_TABLE))
        with patch.object(network.subprocess, "run", return_value=SimpleNamespace(returncode=0,
            stdout='table inet openai_domain_dns { chain output { comment "Managed by openai-domain-router" } }')):
            with self.assertRaises(RuntimeError):
                network.table_exists(network.DNS_TABLE)

    def test_dns_listener_uses_exact_addresses_for_correct_udp_nat_replies(self):
        spec = importlib.util.spec_from_file_location("openai_router_build", ROOT / "build-runtime.py")
        module = importlib.util.module_from_spec(spec)
        spec.loader.exec_module(module)
        config, bridges = module.build(self.config, [
            {"ifname": "br-123456789abc", "addr_info": [{"family": "inet", "scope": "global", "local": "172.20.0.1"}]},
            {"ifname": "eth0", "addr_info": [{"family": "inet", "scope": "global", "local": "192.168.35.254"}]},
        ])
        self.assertEqual(bridges, ["br-123456789abc"])
        dns = [i for i in config["inbounds"] if i["tag"].startswith("dns-in")]
        self.assertEqual({i["listen"] for i in dns}, {"127.0.0.1", "172.20.0.1"})
        self.assertNotIn("0.0.0.0", {i["listen"] for i in dns})
        self.assertEqual(config["route"]["rules"][0]["inbound"], [i["tag"] for i in dns])
        self.assertIn('iifname "br-123456789abc"', network.render(991, bridges))
        with self.assertRaises(ValueError):
            network.render(991, ['br-"; flush ruleset'])


if __name__ == "__main__":
    unittest.main()
