#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Agapia ProxyTool — Tim + Kiem tra + Cham diem proxy (HTTP / SOCKS5 / SOCKS4).
GUI dark theme, stdlib thuan (khong can cai gi — tkinter co san trong Python Windows).

Chay:  python proxytool_gui.py
       (neu hien console den, doi duoi file thanh .pyw roi double-click)

Tinh nang:
  • 🔎 Tim proxy free tu nhieu nguon tren internet (1 nut).
  • ▶ Kiem tra + tu detect loai (HTTP/SOCKS5/SOCKS4) song song.
  • 🎯 Cham diem "dung duoc cho tool mail" (login Outlook qua proxy):
        ✅ Tot · ⚠️ Rui ro · ❌ Loai  — ghi ro ly do tung con.
  • 📋 Copy danh sach dung duoc · 💾 Luu ra file.
"""
import sys, re, time, json, socket, struct, base64, threading, queue
import urllib.request
from concurrent.futures import ThreadPoolExecutor

try:
    import tkinter as tk
    from tkinter import ttk, filedialog, messagebox
    HAVE_TK = True
except Exception:                       # cho phep test engine headless
    HAVE_TK = False

# ───────────────────────── CAU HINH ─────────────────────────
T_HOST, T_PORT = "ip-api.com", 80
T_PATH = "/json/?fields=status,query,country,countryCode,city,isp,org,proxy,hosting,mobile"
MS_HOST, MS_PORT = "login.live.com", 443      # host that tool mail phai vao (HTTPS)

SCHEME_MAP = {"http": "http", "https": "http", "socks5": "socks5", "socks5h": "socks5",
              "socks4": "socks4", "socks4a": "socks4", "socks": "socks5"}

# Nguon proxy free (txt, moi dong ip:port). Da verify song. Chi nguon protocol-specific
# (khong dung list mixed de detect khong sai loai). Bo cac nguon 404/502 va list 100k stale.
SOURCES = {
    "http": [
        "https://api.proxyscrape.com/v4/free-proxy-list/get?request=display_proxies&protocol=http&proxy_format=ipport&format=text",
        "https://raw.githubusercontent.com/TheSpeedX/PROXY-List/master/http.txt",
        "https://raw.githubusercontent.com/monosans/proxy-list/main/proxies/http.txt",
        "https://raw.githubusercontent.com/jetkai/proxy-list/main/online-proxies/txt/proxies-http.txt",
        "https://raw.githubusercontent.com/proxifly/free-proxy-list/main/proxies/protocols/http/data.txt",
        "https://raw.githubusercontent.com/mmpx12/proxy-list/master/http.txt",
        "https://raw.githubusercontent.com/clarketm/proxy-list/master/proxy-list-raw.txt",
        "https://raw.githubusercontent.com/vakhov/fresh-proxy-list/master/http.txt",
        "https://raw.githubusercontent.com/ShiftyTR/Proxy-List/master/http.txt",
        "https://raw.githubusercontent.com/roosterkid/openproxylist/main/HTTPS_RAW.txt",
        "https://proxyspace.pro/http.txt",
    ],
    "socks4": [
        "https://api.proxyscrape.com/v4/free-proxy-list/get?request=display_proxies&protocol=socks4&proxy_format=ipport&format=text",
        "https://raw.githubusercontent.com/TheSpeedX/PROXY-List/master/socks4.txt",
        "https://raw.githubusercontent.com/monosans/proxy-list/main/proxies/socks4.txt",
        "https://raw.githubusercontent.com/mmpx12/proxy-list/master/socks4.txt",
        "https://raw.githubusercontent.com/ShiftyTR/Proxy-List/master/socks4.txt",
        "https://raw.githubusercontent.com/roosterkid/openproxylist/main/SOCKS4_RAW.txt",
        "https://proxyspace.pro/socks4.txt",
    ],
    "socks5": [
        "https://api.proxyscrape.com/v4/free-proxy-list/get?request=display_proxies&protocol=socks5&proxy_format=ipport&format=text",
        "https://raw.githubusercontent.com/TheSpeedX/PROXY-List/master/socks5.txt",
        "https://raw.githubusercontent.com/monosans/proxy-list/main/proxies/socks5.txt",
        "https://raw.githubusercontent.com/hookzof/socks5_list/master/proxy.txt",
        "https://raw.githubusercontent.com/mmpx12/proxy-list/master/socks5.txt",
        "https://raw.githubusercontent.com/ShiftyTR/Proxy-List/master/socks5.txt",
        "https://raw.githubusercontent.com/roosterkid/openproxylist/main/SOCKS5_RAW.txt",
        "https://proxyspace.pro/socks5.txt",
    ],
}

# ───────────────────────── PARSE ─────────────────────────
def parse_line(line):
    """Tra (scheme_or_None, host, port:int, user, pwd) hoac None."""
    line = (line or "").strip()
    if not line or line.startswith("#"):
        return None
    scheme = None
    m = re.match(r"^(\w+)://(.*)$", line)
    if m:
        scheme = SCHEME_MAP.get(m.group(1).lower())
        line = m.group(2)
    tag = re.search(r"\(([^)]*)\)\s*$", line)
    if tag:
        scheme = scheme or SCHEME_MAP.get(re.sub(r"[^a-z0-9]", "", tag.group(1).lower()))
        line = line[:tag.start()].strip()
    line = line.split()[0] if " " in line else line
    if "@" in line:
        cred, hp = line.rsplit("@", 1)
        hpp = hp.split(":")
        if len(hpp) < 2:
            return None
        host, port = hpp[0], hpp[1]
        up = cred.split(":", 1)
        user, pwd = up[0], (up[1] if len(up) > 1 else "")
    else:
        parts = line.split(":")
        if len(parts) >= 4:
            host, port, user, pwd = parts[0], parts[1], parts[2], ":".join(parts[3:])
        elif len(parts) == 2:
            host, port, user, pwd = parts[0], parts[1], "", ""
        else:
            return None
    if not port.isdigit():
        return None
    return scheme, host, int(port), user, pwd


# ───────────────── doc HTTP response ─────────────────
def _read_all(s, cap=65536):
    buf = b""
    while len(buf) < cap:
        try:
            c = s.recv(4096)
        except socket.timeout:
            break
        if not c:
            break
        buf += c
    return buf


def _parse_http(raw):
    if b"\r\n\r\n" not in raw:
        return -1, ""
    head, _, body = raw.partition(b"\r\n\r\n")
    first = head.split(b"\r\n", 1)[0].decode("latin1", "ignore").split()
    code = int(first[1]) if len(first) > 1 and first[1].isdigit() else -1
    return code, body.decode("utf-8", "ignore")


def _recvn(s, n):
    buf = b""
    while len(buf) < n:
        c = s.recv(n - len(buf))
        if not c:
            raise RuntimeError("conn closed")
        buf += c
    return buf


# ───────────── tunnel toi 1 (host,port) qua tung loai proxy ─────────────
def _socks5_tunnel(s, host, port, user, pwd):
    methods = b"\x00\x02" if user else b"\x00"
    s.sendall(bytes([5, len(methods)]) + methods)
    _, method = _recvn(s, 2)
    if method == 2:
        if not user:
            raise RuntimeError("can auth")
        s.sendall(b"\x01" + bytes([len(user)]) + user.encode() + bytes([len(pwd)]) + pwd.encode())
        if _recvn(s, 2)[1] != 0:
            raise RuntimeError("sai user/pass")
    elif method != 0:
        raise RuntimeError("no method")
    dh = host.encode()
    s.sendall(b"\x05\x01\x00\x03" + bytes([len(dh)]) + dh + struct.pack(">H", port))
    rep = _recvn(s, 4)
    if rep[1] != 0:
        raise RuntimeError("rep %d" % rep[1])
    atyp = rep[3]
    if atyp == 1:
        _recvn(s, 6)
    elif atyp == 3:
        _recvn(s, _recvn(s, 1)[0] + 2)
    elif atyp == 4:
        _recvn(s, 18)


def _socks4_tunnel(s, host, port, user):
    uid = (user or "").encode()
    s.sendall(b"\x04\x01" + struct.pack(">H", port) + b"\x00\x00\x00\x01"
              + uid + b"\x00" + host.encode() + b"\x00")
    if _recvn(s, 8)[1] != 0x5A:
        raise RuntimeError("reject")


def _http_get_rel(s):
    s.sendall(("GET %s HTTP/1.0\r\nHost: %s\r\nUser-Agent: Mozilla/5.0\r\n"
               "Connection: close\r\n\r\n" % (T_PATH, T_HOST)).encode())
    return _parse_http(_read_all(s))


def via_http(host, port, user, pwd, timeout):
    s = socket.create_connection((host, port), timeout); s.settimeout(timeout)
    try:
        req = "GET http://%s%s HTTP/1.0\r\nHost: %s\r\n" % (T_HOST, T_PATH, T_HOST)
        if user:
            cred = base64.b64encode(("%s:%s" % (user, pwd)).encode()).decode()
            req += "Proxy-Authorization: Basic %s\r\n" % cred
        req += "User-Agent: Mozilla/5.0\r\nConnection: close\r\n\r\n"
        s.sendall(req.encode())
        code, body = _parse_http(_read_all(s))
        if code == 200:
            return body
        raise RuntimeError("HTTP %s" % (code if code > 0 else "?"))
    finally:
        s.close()


def via_socks5(host, port, user, pwd, timeout):
    s = socket.create_connection((host, port), timeout); s.settimeout(timeout)
    try:
        _socks5_tunnel(s, T_HOST, T_PORT, user, pwd)
        code, body = _http_get_rel(s)
        if code == 200:
            return body
        raise RuntimeError("HTTP %s" % (code if code > 0 else "?"))
    finally:
        s.close()


def via_socks4(host, port, user, pwd, timeout):
    s = socket.create_connection((host, port), timeout); s.settimeout(timeout)
    try:
        _socks4_tunnel(s, T_HOST, T_PORT, user)
        code, body = _http_get_rel(s)
        if code == 200:
            return body
        raise RuntimeError("HTTP %s" % (code if code > 0 else "?"))
    finally:
        s.close()


CHECKERS = {"http": via_http, "socks5": via_socks5, "socks4": via_socks4}
TRY_ORDER = ["http", "socks5", "socks4"]


# ───────────── probe: vao duoc login.live.com:443 khong (CONNECT) ─────────────
def mail_probe(typ, host, port, user, pwd, timeout):
    """True neu tunnel duoc HTTPS toi Microsoft login (CONNECT 443)."""
    try:
        s = socket.create_connection((host, port), timeout); s.settimeout(timeout)
    except Exception:
        return False
    try:
        if typ == "http":
            req = "CONNECT %s:%d HTTP/1.1\r\nHost: %s:%d\r\n" % (MS_HOST, MS_PORT, MS_HOST, MS_PORT)
            if user:
                cred = base64.b64encode(("%s:%s" % (user, pwd)).encode()).decode()
                req += "Proxy-Authorization: Basic %s\r\n" % cred
            req += "\r\n"
            s.sendall(req.encode())
            line = s.recv(256).decode("latin1", "ignore").split("\r\n", 1)[0]
            return " 200" in line
        elif typ == "socks5":
            _socks5_tunnel(s, MS_HOST, MS_PORT, user, pwd)
            return True
        elif typ == "socks4":
            _socks4_tunnel(s, MS_HOST, MS_PORT, user)
            return True
    except Exception:
        return False
    finally:
        s.close()
    return False


# ───────────── check 1 proxy: alive + thong tin IP + cham diem ─────────────
def basic_check(raw, timeout, mail_mode=True):
    p = parse_line(raw)
    if not p:
        return {"raw": (raw or "").strip(), "ok": False, "verdict": "loai",
                "reason": "format sai", "skip": True}
    scheme, host, port, user, pwd = p
    norm = "{}:{}:{}:{}".format(host, port, user, pwd) if user else "{}:{}".format(host, port)

    t0 = time.time()
    try:
        socket.create_connection((host, port), timeout).close()
    except Exception as e:
        return {"raw": norm, "ok": False, "verdict": "loai",
                "reason": "connect: " + (str(e).split("] ")[-1][:22] or "timeout"),
                "ms": int((time.time() - t0) * 1000)}

    order = [scheme] if scheme else TRY_ORDER
    d = None; typ = None; ms = 0; last = "?"
    for t in order:
        ts = time.time()
        try:
            body = CHECKERS[t](host, port, user, pwd, timeout)
            j = json.loads(body)
            if j.get("status") != "success":
                last = "resp la"; continue
            d, typ, ms = j, t, int((time.time() - ts) * 1000)
            break
        except Exception as e:
            last = str(e)[:24]
    if not d:
        return {"raw": norm, "ok": False, "verdict": "loai", "reason": last,
                "ms": int((time.time() - t0) * 1000)}

    has_auth = bool(user)
    hosting = bool(d.get("hosting")); flagged = bool(d.get("proxy")); mobile = bool(d.get("mobile"))
    iptype = "Mobile" if mobile else ("Datacenter" if hosting else "Residential")
    r = {"raw": norm, "ok": True, "type": typ, "ms": ms,
         "ip": d.get("query", "?"), "cc": d.get("countryCode", ""),
         "country": d.get("country", "?"), "isp": (d.get("isp") or d.get("org") or "")[:26],
         "hosting": hosting, "flagged": flagged, "mobile": mobile, "iptype": iptype,
         "https": False, "ms_ok": False}

    # ── cham diem cho tool mail ──
    if not mail_mode:
        r["verdict"], r["reason"] = "tot", "sống (chưa chấm mail)"
        return r

    if typ in ("socks5", "socks4") and has_auth:
        r["verdict"], r["reason"] = "loai", "SOCKS có auth — Camoufox không hỗ trợ"
        return r

    https_ok = mail_probe(typ, host, port, user, pwd, timeout)
    r["https"] = https_ok; r["ms_ok"] = https_ok
    if not https_ok:
        r["verdict"] = "loai"
        r["reason"] = "không CONNECT 443 / không vào được login.live.com"
        return r
    if ms > 8000:
        r["verdict"], r["reason"] = "loai", "latency quá cao (>8s, login dễ timeout)"
        return r

    # qua het gate bat buoc -> tot/rui ro theo chat luong IP
    if flagged:
        r["verdict"], r["reason"] = "ruiro", "IP bị gắn cờ proxy/VPN — dễ bị Microsoft chặn"
    elif hosting:
        r["verdict"], r["reason"] = "ruiro", "datacenter — Microsoft hay challenge IP server"
    elif ms > 3000:
        r["verdict"], r["reason"] = "ruiro", "latency hơi cao (%dms)" % ms
    elif mobile:
        r["verdict"], r["reason"] = "tot", "mobile IP (rất sạch), vào được Microsoft ✓"
    else:
        r["verdict"], r["reason"] = "tot", "residential, vào được Microsoft ✓"
    return r


# ───────────── fetch proxy free ─────────────
def fetch_free(types, log=lambda s: None):
    seen, out = set(), []
    for typ in types:
        for url in SOURCES.get(typ, []):
            try:
                req = urllib.request.Request(url, headers={"User-Agent": "Mozilla/5.0"})
                txt = urllib.request.urlopen(req, timeout=15).read().decode("utf-8", "ignore")
            except Exception as e:
                log("  ✗ nguồn lỗi: %s (%s)" % (url.split("/")[2], str(e)[:30]))
                continue
            n = 0
            for line in txt.splitlines():
                m = re.search(r"(\d{1,3}(?:\.\d{1,3}){3}):(\d{2,5})", line)
                if not m:
                    continue
                key = "%s:%s" % (m.group(1), m.group(2))
                if key in seen:
                    continue
                seen.add(key)
                out.append("%s://%s" % (typ, key))
                n += 1
            log("  ✓ %-22s +%d (%s)" % (url.split("/")[2], n, typ))
    return out


# ═══════════════════════════ GUI ═══════════════════════════
BG = "#0f1117"; PANEL = "#171a23"; CARD = "#1c2030"; LINE = "#2a2f3e"
TXT = "#e7e9ee"; MUT = "#8b90a0"; GOLD = "#e8b04b"
GREEN = "#46d39a"; ORANGE = "#f0a843"; RED = "#ef5e6a"; BLUE = "#5cc8ff"

COLS = [("#", 38), ("Proxy", 168), ("Loại", 60), ("IP thoát", 124), ("Quốc gia", 92),
        ("ISP", 168), ("ms", 56), ("443", 42), ("MS", 42), ("Kiểu IP", 88), ("Đánh giá", 300)]


class App:
    def __init__(self, root, parent=None):
        # root = toplevel (cho after/clipboard); parent = noi nhung widget (mac dinh = root).
        # Khi nhung vao 1 tab Notebook -> truyen parent = frame cua tab.
        self.root = root
        self.parent = parent if parent is not None else root
        self.q = queue.Queue()
        self.stop = threading.Event()
        self.running = False
        self.rows = []           # ket qua dung duoc/song
        self.input = []          # list proxy raw cho lan check
        if isinstance(root, (tk.Tk, tk.Toplevel)):
            root.title("Agapia ProxyTool")
            root.geometry("1180x720")
            root.minsize(980, 560)
        try: self.parent.configure(bg=BG)
        except Exception: pass
        self._style()
        self._build()
        self.root.after(80, self._pump)

    def _style(self):
        s = ttk.Style()
        try: s.theme_use("clam")
        except Exception: pass
        s.configure(".", background=BG, foreground=TXT, fieldbackground=CARD, borderwidth=0)
        s.configure("TFrame", background=BG)
        s.configure("Card.TFrame", background=PANEL)
        s.configure("TLabel", background=BG, foreground=TXT, font=("Segoe UI", 10))
        s.configure("Mut.TLabel", background=BG, foreground=MUT, font=("Segoe UI", 9))
        s.configure("Card.TLabel", background=PANEL, foreground=TXT, font=("Segoe UI", 10))
        s.configure("CardMut.TLabel", background=PANEL, foreground=MUT, font=("Segoe UI", 9))
        s.configure("TCheckbutton", background=PANEL, foreground=TXT, font=("Segoe UI", 9))
        s.map("TCheckbutton", background=[("active", PANEL)])
        s.configure("TSpinbox", arrowsize=12, fieldbackground=CARD, foreground=TXT, background=CARD)
        # buttons
        s.configure("Tool.TButton", background=CARD, foreground=TXT, font=("Segoe UI Semibold", 9),
                    borderwidth=0, focusthickness=0, padding=(12, 7))
        s.map("Tool.TButton", background=[("active", "#262c3c"), ("disabled", "#161a24")],
              foreground=[("disabled", "#555b6b")])
        s.configure("Gold.TButton", background=GOLD, foreground="#1a1200",
                    font=("Segoe UI Semibold", 9), borderwidth=0, padding=(14, 7))
        s.map("Gold.TButton", background=[("active", "#f2c160"), ("disabled", "#5a4a23")])
        # treeview
        s.configure("Treeview", background=CARD, fieldbackground=CARD, foreground=TXT,
                    rowheight=27, borderwidth=0, font=("Consolas", 9))
        s.configure("Treeview.Heading", background=PANEL, foreground=GOLD,
                    font=("Segoe UI Semibold", 9), borderwidth=0, relief="flat")
        s.map("Treeview.Heading", background=[("active", PANEL)])
        s.map("Treeview", background=[("selected", "#2d3447")], foreground=[("selected", "#fff")])
        s.configure("gold.Horizontal.TProgressbar", troughcolor=CARD, background=GOLD,
                    borderwidth=0, thickness=10)

    def _build(self):
        pad = dict(padx=14)
        # ── header ──
        head = tk.Frame(self.parent, bg=BG); head.pack(fill="x", pady=(12, 6), **pad)
        tk.Label(head, text="◆ Agapia ProxyTool", bg=BG, fg=GOLD,
                 font=("Segoe UI Semibold", 16)).pack(side="left")
        tk.Label(head, text="  Tìm · Kiểm tra · Chấm điểm proxy cho automation", bg=BG, fg=MUT,
                 font=("Segoe UI", 10)).pack(side="left", pady=(6, 0))

        # ── toolbar ──
        bar = tk.Frame(self.parent, bg=BG); bar.pack(fill="x", pady=4, **pad)
        self.b_find = ttk.Button(bar, text="🔎 Tìm proxy free", style="Gold.TButton", command=self.on_find)
        self.b_find.pack(side="left", padx=(0, 6))
        self.b_imp = ttk.Button(bar, text="📥 Nhập file / Dán", style="Tool.TButton", command=self.on_import)
        self.b_imp.pack(side="left", padx=3)
        self.b_run = ttk.Button(bar, text="▶ Kiểm tra & Chấm điểm", style="Tool.TButton", command=self.on_run)
        self.b_run.pack(side="left", padx=3)
        self.b_stop = ttk.Button(bar, text="⏹ Dừng", style="Tool.TButton", command=self.on_stop)
        self.b_stop.pack(side="left", padx=3); self.b_stop.state(["disabled"])
        self.b_copy = ttk.Button(bar, text="📋 Copy “dùng được”", style="Tool.TButton", command=self.on_copy)
        self.b_copy.pack(side="left", padx=3)
        self.b_save = ttk.Button(bar, text="💾 Lưu…", style="Tool.TButton", command=self.on_save)
        self.b_save.pack(side="left", padx=3)

        # ── options ──
        opt = tk.Frame(self.parent, bg=PANEL); opt.pack(fill="x", pady=4, **pad)
        inner = tk.Frame(opt, bg=PANEL); inner.pack(fill="x", padx=12, pady=8)
        tk.Label(inner, text="Luồng", bg=PANEL, fg=MUT, font=("Segoe UI", 9)).pack(side="left")
        self.v_threads = tk.IntVar(value=100)
        ttk.Spinbox(inner, from_=10, to=500, increment=10, width=5, textvariable=self.v_threads).pack(side="left", padx=(4, 14))
        tk.Label(inner, text="Timeout(s)", bg=PANEL, fg=MUT, font=("Segoe UI", 9)).pack(side="left")
        self.v_to = tk.IntVar(value=8)
        ttk.Spinbox(inner, from_=3, to=30, width=4, textvariable=self.v_to).pack(side="left", padx=(4, 14))
        tk.Label(inner, text="Nguồn:", bg=PANEL, fg=MUT, font=("Segoe UI", 9)).pack(side="left")
        self.v_http = tk.BooleanVar(value=True); self.v_s4 = tk.BooleanVar(value=True); self.v_s5 = tk.BooleanVar(value=True)
        for txt_, var in (("HTTP", self.v_http), ("SOCKS4", self.v_s4), ("SOCKS5", self.v_s5)):
            ttk.Checkbutton(inner, text=txt_, variable=var).pack(side="left", padx=4)
        self.v_mail = tk.BooleanVar(value=True)
        ttk.Checkbutton(inner, text="🎯 Chế độ Mail (chấm cho login Outlook)", variable=self.v_mail).pack(side="left", padx=(16, 0))
        self.v_auto = tk.BooleanVar(value=True)
        ttk.Checkbutton(inner, text="Tự chấm sau khi tìm", variable=self.v_auto).pack(side="left", padx=(12, 0))
        self.v_onlygood = tk.BooleanVar(value=False)
        ttk.Checkbutton(inner, text="📋 Copy/Lưu chỉ ✅ Tốt", variable=self.v_onlygood).pack(side="left", padx=(12, 0))

        # ── table ──
        wrap = tk.Frame(self.parent, bg=BG); wrap.pack(fill="both", expand=True, pady=6, **pad)
        self.tree = ttk.Treeview(wrap, columns=[c[0] for c in COLS], show="headings", selectmode="extended")
        for name, w in COLS:
            self.tree.heading(name, text=name)
            self.tree.column(name, width=w, anchor=("center" if name in ("#", "Loại", "ms", "443", "MS") else "w"),
                             stretch=(name in ("ISP", "Đánh giá")))
        vs = ttk.Scrollbar(wrap, orient="vertical", command=self.tree.yview)
        self.tree.configure(yscrollcommand=vs.set)
        self.tree.pack(side="left", fill="both", expand=True); vs.pack(side="right", fill="y")
        self.tree.tag_configure("tot", foreground=GREEN)
        self.tree.tag_configure("ruiro", foreground=ORANGE)
        self.tree.tag_configure("loai", foreground=MUT)
        self.tree.tag_configure("odd", background="#191d28")

        # ── progress + status ──
        bot = tk.Frame(self.parent, bg=BG); bot.pack(fill="x", **pad)
        self.pb = ttk.Progressbar(bot, style="gold.Horizontal.TProgressbar", mode="determinate")
        self.pb.pack(fill="x", pady=(2, 4))
        self.v_status = tk.StringVar(value="Sẵn sàng. Bấm 🔎 Tìm proxy free để bắt đầu.")
        tk.Label(bot, textvariable=self.v_status, bg=BG, fg=TXT, font=("Segoe UI", 9), anchor="w").pack(fill="x")
        legend = ("✅ Tốt = residential, vào được Microsoft   "
                  "⚠️ Rủi ro = datacenter/IP gắn cờ/latency cao   "
                  "❌ Loại = chết / không HTTPS / SOCKS-auth")
        tk.Label(bot, text=legend, bg=BG, fg=MUT, font=("Segoe UI", 8), anchor="w").pack(fill="x", pady=(0, 8))

    # ───────── helpers ─────────
    def log(self, s):
        self.q.put(("status", s))

    def _set_busy(self, busy):
        self.running = busy
        st = ["disabled"] if busy else ["!disabled"]
        for b in (self.b_find, self.b_imp, self.b_run, self.b_copy, self.b_save):
            b.state(st)
        self.b_stop.state(["!disabled"] if busy else ["disabled"])

    # ───────── actions ─────────
    def on_find(self):
        if self.running: return
        types = [t for t, v in (("http", self.v_http), ("socks4", self.v_s4), ("socks5", self.v_s5)) if v.get()]
        if not types:
            messagebox.showwarning("Nguồn", "Chọn ít nhất 1 nguồn (HTTP/SOCKS4/SOCKS5)."); return
        self._clear()
        self._set_busy(True)
        self.v_status.set("Đang tìm proxy free…")
        threading.Thread(target=self._find_worker, args=(types,), daemon=True).start()

    def _find_worker(self, types):
        got = fetch_free(types, log=self.log)
        self.input = got
        self.q.put(("found", len(got)))
        if self.v_auto.get() and got and not self.stop.is_set():
            self._check_worker(got)
        else:
            self.q.put(("done", None))

    def on_import(self):
        if self.running: return
        path = filedialog.askopenfilename(title="Chọn file proxy",
                                          filetypes=[("Text", "*.txt"), ("All", "*.*")])
        if not path: return
        try:
            data = open(path, encoding="utf-8", errors="ignore").read().splitlines()
        except Exception as e:
            messagebox.showerror("Lỗi", str(e)); return
        self.input = [l for l in data if l.strip() and not l.strip().startswith("#")]
        self.v_status.set("Đã nạp %d proxy từ file. Bấm ▶ để kiểm tra." % len(self.input))

    def on_run(self):
        if self.running: return
        if not self.input:
            messagebox.showinfo("Chưa có proxy", "Bấm 🔎 Tìm proxy free hoặc 📥 Nhập file trước."); return
        self._clear()
        self._set_busy(True)
        threading.Thread(target=self._check_worker, args=(list(self.input),), daemon=True).start()

    def _check_worker(self, items):
        self.stop.clear()
        to = max(3, self.v_to.get()); th = max(10, self.v_threads.get())
        mail = self.v_mail.get()
        total = len(items); done = 0
        self.q.put(("begin", total))
        with ThreadPoolExecutor(max_workers=th) as ex:
            futs = [ex.submit(basic_check, it, to, mail) for it in items]
            for f in futs:
                if self.stop.is_set():
                    break
                try: r = f.result()
                except Exception: continue
                done += 1
                self.q.put(("row", (done, r)))
        self.q.put(("done", None))

    def on_stop(self):
        self.stop.set(); self.v_status.set("Đang dừng…")

    def _picked(self):
        """Danh sach proxy chon de copy/luu theo toggle 'chi ✅ Tot'."""
        keep = ("tot",) if self.v_onlygood.get() else ("tot", "ruiro")
        return [r for r in self.rows if r.get("verdict") in keep], keep

    def on_copy(self):
        good, keep = self._picked()
        if not good:
            tip = "Chưa có con ✅ Tốt nào." if keep == ("tot",) else "Chưa có proxy dùng được."
            messagebox.showinfo("Chưa có", tip + " (bỏ tick “chỉ ✅ Tốt” để lấy cả ⚠️ Rủi ro)"); return
        text = "\n".join("%s://%s" % (r["type"], r["raw"]) for r in good)
        self.root.clipboard_clear(); self.root.clipboard_append(text)
        lbl = "✅ Tốt" if keep == ("tot",) else "dùng được (✅+⚠️)"
        self.v_status.set("📋 Đã copy %d proxy %s vào clipboard." % (len(good), lbl))

    def on_save(self):
        good, keep = self._picked()
        if not good:
            tip = "Chưa có con ✅ Tốt nào." if keep == ("tot",) else "Chưa có proxy dùng được."
            messagebox.showinfo("Chưa có", tip); return
        name = "proxy_tot.txt" if keep == ("tot",) else "proxy_dungduoc.txt"
        path = filedialog.asksaveasfilename(defaultextension=".txt", initialfile=name,
                                            filetypes=[("Text", "*.txt")])
        if not path: return
        with open(path, "w", encoding="utf-8") as f:
            for r in sorted(good, key=lambda x: (x["verdict"] != "tot", x["ms"])):
                f.write("%s://%s\n" % (r["type"], r["raw"]))
        self.v_status.set("💾 Đã lưu %d proxy vào %s" % (len(good), path))

    def _clear(self):
        self.tree.delete(*self.tree.get_children())
        self.rows = []
        self.pb["value"] = 0

    # ───────── UI pump (thread-safe) ─────────
    def _pump(self):
        try:
            while True:
                kind, data = self.q.get_nowait()
                if kind == "status":
                    self.v_status.set(data)
                elif kind == "found":
                    self.v_status.set("Đã tìm %d proxy. %s" % (
                        data, "Đang chấm điểm…" if self.v_auto.get() else "Bấm ▶ để kiểm tra."))
                elif kind == "begin":
                    self.pb["maximum"] = data; self.pb["value"] = 0
                    self._n_alive = self._n_good = self._n_risk = self._n_bad = 0
                elif kind == "row":
                    self._add_row(*data)
                elif kind == "done":
                    self._set_busy(False)
                    self._summary()
        except queue.Empty:
            pass
        self.root.after(80, self._pump)

    def _add_row(self, idx, r):
        self.pb["value"] = idx
        v = r.get("verdict", "loai")
        ico = {"tot": "✅", "ruiro": "⚠️", "loai": "❌"}.get(v, "❌")
        if r.get("ok"):
            self._n_alive += 1
            if v == "tot": self._n_good += 1
            elif v == "ruiro": self._n_risk += 1
            else: self._n_bad += 1
            self.rows.append(r)
            vals = (idx, r["raw"], r["type"], r["ip"], "%s %s" % (r["cc"], r["country"]),
                    r["isp"], r["ms"], "✓" if r["https"] else "✗", "✓" if r["ms_ok"] else "✗",
                    r["iptype"], "%s %s" % (ico, r["reason"]))
        else:
            self._n_bad += 1
            vals = (idx, r.get("raw", "")[:30], "-", "-", "-", "-", r.get("ms", ""),
                    "✗", "✗", "-", "❌ %s" % r.get("reason", ""))
        tags = [v]
        if idx % 2 == 0: tags.append("odd")
        self.tree.insert("", "end", values=vals, tags=tuple(tags))
        if idx % 7 == 0:
            self.v_status.set("Đang quét %d/%d · sống %d · ✅%d ⚠️%d ❌%d"
                              % (idx, self.pb["maximum"], self._n_alive,
                                 self._n_good, self._n_risk, self._n_bad))

    def _summary(self):
        tot = int(self.pb["maximum"]) if self.pb["maximum"] else len(self.rows)
        a = getattr(self, "_n_alive", 0); g = getattr(self, "_n_good", 0)
        rk = getattr(self, "_n_risk", 0); b = getattr(self, "_n_bad", 0)
        self.v_status.set("✔ Xong %d proxy · Sống %d · ✅ Tốt %d · ⚠️ Rủi ro %d · ❌ Loại %d  "
                          "→ dùng được (✅+⚠️): %d" % (tot, a, g, rk, b, g + rk))


def main():
    if not HAVE_TK:
        print("Khong co tkinter — chay engine headless. Cai Python ban du (python.org) co tkinter de mo GUI.")
        return
    root = tk.Tk()
    App(root)
    root.mainloop()


if __name__ == "__main__":
    main()