#!/usr/bin/env python3
"""
network_report.py — Comprehensive ISP connectivity diagnostic.
Tests a broad range of resources across different CDNs, ASNs, and regions.
HTTP 403/429/3xx all count as REACHABLE (server responded = host is up).
Uses a real browser User-Agent to avoid bot-blocking false positives.
 
Usage:
    python3 network_report.py
    pip install requests   # if not already installed
"""
 
import datetime
import os
import shutil
import socket
import subprocess
import sys
 
try:
    import requests
except ImportError:
    print("ERROR: 'requests' not installed. Run: pip install requests")
    sys.exit(1)
 
# ---------------------------------------------------------------------------
# Config
# ---------------------------------------------------------------------------
 
REPORT_FILE = f"network_report_{datetime.datetime.now().strftime('%Y%m%d_%H%M%S')}.txt"
 
# Realistic browser User-Agent — avoids 403s from bot-filtering
BROWSER_UA = (
    "Mozilla/5.0 (X11; Linux x86_64) "
    "AppleWebKit/537.36 (KHTML, like Gecko) "
    "Chrome/124.0.0.0 Safari/537.36"
)
 
HEADERS = {
    "User-Agent": BROWSER_UA,
    "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
    "Accept-Language": "en-US,en;q=0.5",
}
 
# HTTP status codes that mean the HOST IS REACHABLE (even if content blocked)
REACHABLE_CODES = {
    200, 201, 204,           # success
    301, 302, 303, 307, 308, # redirects — host is up
    400, 401, 403, 405, 429, # server responded with an error — still reachable
}
 
# (display name, url, category, notes)
TEST_URLS = [
    # --- Search / Google ecosystem ---
    ("Google Search",         "https://www.google.com",          "Google",      ""),
    ("Google DNS (8.8.8.8)",  "https://8.8.8.8",                 "Google",      "anycast"),
    ("YouTube",               "https://www.youtube.com",         "Google",      ""),
 
    # --- Cloudflare ecosystem ---
    ("Cloudflare",            "https://www.cloudflare.com",      "Cloudflare",  ""),
    ("Cloudflare 1.1.1.1",   "https://1.1.1.1",                 "Cloudflare",  "anycast"),
    ("Cloudflare WARP",       "https://blog.cloudflare.com",     "Cloudflare",  ""),
 
    # --- CDNs ---
    ("Fastly",                "https://www.fastly.com",          "CDN-Fastly",  ""),
    ("Akamai",                "https://www.akamai.com",          "CDN-Akamai",  ""),
    ("jsDelivr CDN",          "https://www.jsdelivr.com",        "CDN-jsDelivr",""),
 
    # --- Developer / tech ---
    ("GitHub",                "https://github.com",              "Dev",         ""),
    ("GitLab",                "https://gitlab.com",              "Dev",         ""),
    ("Stack Overflow",        "https://stackoverflow.com",       "Dev",         ""),
    ("npm registry",          "https://registry.npmjs.org",      "Dev",         ""),
    ("PyPI",                  "https://pypi.org",                "Dev",         ""),
 
    # --- Streaming / media ---
    ("Netflix CDN fast.com",  "https://fast.com",                "Streaming",   "Netflix CDN"),
    ("Twitch",                "https://www.twitch.tv",           "Streaming",   ""),
    ("Spotify",               "https://www.spotify.com",         "Streaming",   ""),
 
    # --- Social ---
    ("Reddit",                "https://www.reddit.com",          "Social",      ""),
    ("Facebook",              "https://www.facebook.com",        "Social",      ""),
    ("X / Twitter",           "https://x.com",                   "Social",      ""),
    ("LinkedIn",              "https://www.linkedin.com",        "Social",      ""),
 
    # --- Cloud providers ---
    ("Amazon AWS",            "https://aws.amazon.com",          "Cloud-US",    ""),
    ("Microsoft Azure",       "https://azure.microsoft.com",     "Cloud-US",    ""),
    ("Google Cloud",          "https://cloud.google.com",        "Cloud-US",    ""),
    ("Hetzner",               "https://www.hetzner.com",         "Cloud-EU",    "DE"),
    ("OVH",                   "https://www.ovhcloud.com",        "Cloud-EU",    "FR"),
    ("DigitalOcean",          "https://www.digitalocean.com",    "Cloud-US",    ""),
 
    # --- News / reference ---
    ("Wikipedia EN",          "https://en.wikipedia.org",        "Reference",   ""),
    ("BBC",                   "https://www.bbc.com",             "News",        "UK"),
    ("Reuters",               "https://www.reuters.com",         "News",        ""),
 
    # --- Security / DNS ---
    ("OpenDNS",               "https://www.opendns.com",         "DNS/Sec",     ""),
    ("Have I Been Pwned",     "https://haveibeenpwned.com",      "DNS/Sec",     ""),
]
 
# Hosts for DNS + ping tests (deduplicated subset)
TEST_HOSTS = [
    "google.com", "cloudflare.com", "github.com", "fast.com",
    "youtube.com", "reddit.com",
    "1.1.1.1", "8.8.8.8",
]
 
MTU_SIZES = [1472, 1400, 1300, 1000, 576]
 
TRACEROUTE_HOSTS = ["8.8.8.8", "1.1.1.1"]
 
 
# ---------------------------------------------------------------------------
# Helpers
# ---------------------------------------------------------------------------
 
def header(title: str) -> str:
    line = "=" * 80
    return f"\n{line}\n{title}\n{line}\n"
 
 
def subheader(title: str) -> str:
    return f"\n--- {title} ---\n"
 
 
def run(cmd: str, timeout: int = 30) -> str:
    try:
        r = subprocess.run(
            cmd, shell=True, capture_output=True, text=True, timeout=timeout
        )
        return (r.stdout + r.stderr).strip()
    except subprocess.TimeoutExpired:
        return f"[TIMEOUT after {timeout}s]"
    except Exception as e:
        return f"[ERROR: {e}]"
 
 
def get_gateway() -> str | None:
    out = run("ip route | grep default")
    parts = out.split()
    try:
        return parts[parts.index("via") + 1]
    except (ValueError, IndexError):
        return None
 
 
def get_ssid() -> str:
    if shutil.which("nmcli"):
        out = run("nmcli -t -f active,ssid dev wifi 2>/dev/null")
        for line in out.splitlines():
            if line.startswith("yes:"):
                return line[4:].strip()
    if shutil.which("iwgetid"):
        out = run("iwgetid -r")
        if out and not out.startswith("["):
            return out.strip()
    return "unknown (or ethernet)"
 
 
def is_reachable(status_code: int) -> bool:
    return status_code in REACHABLE_CODES
 
 
def reachable_label(status_code: int) -> str:
    if status_code in {200, 201, 204}:
        return "OK"
    if status_code in {301, 302, 303, 307, 308}:
        return "OK (redirect)"
    if status_code in {400, 401, 403, 405, 429}:
        return "REACHABLE (blocked/auth)"
    return f"HTTP {status_code}"
 
 
# ---------------------------------------------------------------------------
# Report sections
# ---------------------------------------------------------------------------
 
def section_metadata(f, gateway, ssid):
    f.write(header("SESSION METADATA"))
    f.write(f"Timestamp      : {datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n")
    f.write(f"Hostname       : {socket.gethostname()}\n")
    f.write(f"WiFi SSID      : {ssid}\n")
    f.write(f"Default gateway: {gateway or 'not detected'}\n")
    f.write(f"Python         : {sys.version.splitlines()[0]}\n")
    f.write(f"User-Agent     : {BROWSER_UA}\n")
    f.write(run("uname -a") + "\n")
    out = run("lsb_release -a 2>/dev/null || cat /etc/os-release")
    f.write(out + "\n")
 
 
def section_interfaces(f):
    f.write(header("NETWORK INTERFACES & ROUTING"))
    f.write(subheader("ip addr"))
    f.write(run("ip addr") + "\n")
    f.write(subheader("ip route"))
    f.write(run("ip route") + "\n")
 
 
def section_dns_config(f):
    f.write(header("DNS CONFIGURATION"))
    f.write(run("cat /etc/resolv.conf") + "\n")
 
 
def section_public_ip(f):
    f.write(header("PUBLIC IP"))
    for label, url in [("IPv4", "https://api.ipify.org"), ("IPv6", "https://api64.ipify.org")]:
        try:
            r = requests.get(url, timeout=8, headers=HEADERS)
            f.write(f"Public {label}: {r.text.strip()}\n")
        except Exception as e:
            f.write(f"{label} detection failed: {e}\n")
 
 
def section_gateway_ping(f, gateway):
    f.write(header(f"GATEWAY PING ({gateway} ×25)"))
    f.write(run(f"ping -c 25 {gateway}", timeout=60) + "\n")
 
 
def section_public_ping(f):
    f.write(header("PUBLIC PING (×20 each)"))
    for host in ["8.8.8.8", "1.1.1.1"]:
        f.write(subheader(f"ping {host}"))
        f.write(run(f"ping -c 20 {host}", timeout=45) + "\n")
 
 
def section_mtu(f):
    f.write(header("MTU / FRAGMENTATION TESTS"))
    for size in MTU_SIZES:
        f.write(subheader(f"MTU {size} bytes (payload) → 1.1.1.1"))
        f.write(run(f"ping -M do -s {size} -c 3 1.1.1.1", timeout=15) + "\n")
 
 
def section_dns_resolution(f):
    f.write(header("DNS RESOLUTION"))
    for host in TEST_HOSTS:
        f.write(subheader(host))
        if shutil.which("dig"):
            f.write(run(f"dig +short {host}") + "\n")
        else:
            try:
                infos = socket.getaddrinfo(host, None)
                for info in infos:
                    f.write(str(info) + "\n")
            except Exception as e:
                f.write(f"FAILED: {e}\n")
 
 
def section_traceroute(f):
    cmd = "mtr --report --report-cycles=15 --no-dns" if shutil.which("mtr") else \
          "traceroute -n" if shutil.which("traceroute") else \
          "tracepath" if shutil.which("tracepath") else None
 
    f.write(header(f"ROUTE TESTS  ({'mtr' if shutil.which('mtr') else 'traceroute'})"))
    if not cmd:
        f.write("No traceroute/mtr utility available.\n")
        return
    for host in TRACEROUTE_HOSTS:
        f.write(subheader(f"{cmd.split()[0]} {host}"))
        f.write(run(f"{cmd} {host}", timeout=90) + "\n")
 
 
def section_http(f):
    f.write(header(f"HTTP/HTTPS RESOURCE TESTS  ({len(TEST_URLS)} targets)"))
    f.write(
        f"\n{'#':<3} {'Resource':<28} {'Category':<14} "
        f"{'Status':<24} {'Time ms':>8}  Notes\n"
    )
    f.write("-" * 90 + "\n")
 
    results = []
    session = requests.Session()
    session.headers.update(HEADERS)
 
    for i, (name, url, category, notes) in enumerate(TEST_URLS, 1):
        t0 = datetime.datetime.now()
        try:
            r = session.get(url, timeout=10, allow_redirects=True)
            ms = int((datetime.datetime.now() - t0).total_seconds() * 1000)
            reachable = is_reachable(r.status_code)
            label = reachable_label(r.status_code)
            server = r.headers.get("server", "")
            icon = "✓" if reachable else "✗"
            detail = f"{label} [{server}]" if server else label
            results.append((name, url, category, reachable, r.status_code, ms, detail))
        except requests.exceptions.ConnectionError as e:
            ms = int((datetime.datetime.now() - t0).total_seconds() * 1000)
            results.append((name, url, category, False, 0, ms, f"CONNECTION ERROR: {e}"))
            icon, detail = "✗", f"CONNECTION ERROR"
        except requests.exceptions.Timeout:
            ms = int((datetime.datetime.now() - t0).total_seconds() * 1000)
            results.append((name, url, category, False, 0, ms, "TIMEOUT"))
            icon, detail = "✗", "TIMEOUT"
        except Exception as e:
            ms = int((datetime.datetime.now() - t0).total_seconds() * 1000)
            results.append((name, url, category, False, 0, ms, f"ERROR: {e}"))
            icon, detail = "✗", f"ERROR"
 
        name_disp, url_disp, cat_disp, reachable, code, ms, detail = results[-1]
        icon = "✓" if reachable else "✗"
        extra = notes if notes else ""
        f.write(
            f"{icon} {i:<2} {name_disp:<28} {cat_disp:<14} "
            f"{detail:<24} {ms:>6} ms  {extra}\n"
        )
        f.flush()
 
    # summary
    ok = sum(1 for r in results if r[3])
    failed = [(r[0], r[1], r[6]) for r in results if not r[3]]
    f.write("\n" + "-" * 90 + "\n")
    f.write(f"SUMMARY: {ok}/{len(results)} reachable\n")
 
    if failed:
        f.write(f"\n⚠  UNREACHABLE ({len(failed)}):\n")
        for name, url, detail in failed:
            f.write(f"   ✗  {name:<28}  {url}\n")
            f.write(f"      Reason: {detail}\n")
 
        # group failures by category for ISP report
        from collections import Counter
        cats = Counter(r[2] for r in results if not r[3])
        f.write(f"\n   Failures by category:\n")
        for cat, count in cats.most_common():
            f.write(f"   {cat}: {count} failed\n")
    else:
        f.write("   All resources reachable.\n")
 
    return results
 
 
def section_tcp_ports(f):
    f.write(header("TCP PORT CHECKS"))
    checks = [
        ("google.com", 80), ("google.com", 443),
        ("8.8.8.8", 53), ("1.1.1.1", 53),
        ("github.com", 443), ("stackoverflow.com", 443),
    ]
    for host, port in checks:
        try:
            with socket.create_connection((host, port), timeout=5):
                f.write(f"  OK    {host}:{port}\n")
        except Exception as e:
            f.write(f"  FAIL  {host}:{port}  — {e}\n")
 
 
# ---------------------------------------------------------------------------
# Main
# ---------------------------------------------------------------------------
 
def main():
    print(f"[network_report] Starting diagnostics...")
    print(f"[network_report] Report: {REPORT_FILE}")
 
    gateway = get_gateway()
    ssid = get_ssid()
 
    print(f"[network_report] SSID: {ssid} | Gateway: {gateway}")
 
    with open(REPORT_FILE, "w", encoding="utf-8") as f:
        section_metadata(f, gateway, ssid)
        section_interfaces(f)
        section_dns_config(f)
        section_public_ip(f)
 
        if gateway:
            print(f"[network_report] Pinging gateway ({gateway})...")
            section_gateway_ping(f, gateway)
 
        print("[network_report] Pinging public hosts...")
        section_public_ping(f)
 
        print("[network_report] MTU tests...")
        section_mtu(f)
 
        print("[network_report] DNS resolution...")
        section_dns_resolution(f)
 
        print("[network_report] Traceroute/MTR...")
        section_traceroute(f)
 
        print("[network_report] TCP port checks...")
        section_tcp_ports(f)
 
        print(f"[network_report] HTTP tests ({len(TEST_URLS)} targets)...")
        section_http(f)
 
        f.write(header("END OF REPORT"))
 
    print(f"\n[network_report] Done. Report saved to:\n  {os.path.abspath(REPORT_FILE)}")
 
 
if __name__ == "__main__":
    main()

/usr/bin/python3 network_report.py