ayson_v1_1.py

#!/usr/bin/env python3
"""
ayson V1.1: single-file Termux resolver for ay.live/aylink/cpmlink and ouo.io links.

Supported chains:
1) ay.live / aylink.co / cpmlink.pro
   - GET the short-link page
   - extract _a, _t, _d, alias, csrf
   - POST /get/tk
   - POST /links/go2
   - if the returned URL uses bildirim.online / bildirim.vip, extract the embedded final URL
2) bildirim.online / bildirim.vip direct intermediate pages
   - extract the URL hidden behind the alert/notification page
3) ouo.io / ouo.press
   - submit the site forms normally
   - follow /go/<id> and /xreallcygo/<id> hops
   - return the Location header or final external URL

It does not solve CAPTCHA / Turnstile / reCAPTCHA challenges.
"""

from __future__ import annotations

import argparse
import gzip
import html as html_lib
import http.cookiejar
import json
import os
import re
import shutil
import stat
import ssl
import sys
import time
import urllib.error
import urllib.parse
import urllib.request
import zlib
from dataclasses import dataclass
from typing import Dict, Iterable, List, Optional, Tuple
from urllib.parse import urlparse

APP_NAME = "ayson"
VERSION = "V1.1"
TRLINK_HOSTS = {"aylink.co", "cpmlink.pro", "ay.live"}
OUO_HOSTS = {"ouo.io", "ouo.press"}
SUPPORTED_HOSTS = TRLINK_HOSTS | OUO_HOSTS
BILDIRIM_HOSTS = {"bildirim.online", "bildirim.vip"}
DEFAULT_TIMEOUT = 30
MAX_HTML_BYTES = 4 * 1024 * 1024

# Exit Codes
EXIT_SUCCESS = 0
EXIT_ERROR = 1
EXIT_UNSUPPORTED = 2
EXIT_NETWORK = 3
EXIT_INVALID_URL = 4
EXIT_RESOLVE_FAILED = 5
EXIT_INTERRUPTED = 130


UA = (
    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
    "AppleWebKit/537.36 (KHTML, like Gecko) "
    "Chrome/122.0.0.0 Safari/537.36"
)

COMMON_HEADERS = {
    "User-Agent": UA,
    "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
    "Accept-Language": "tr-TR,tr;q=0.9,en-US;q=0.8,en;q=0.7",
    "Connection": "close",
}

AJAX_HEADERS_BASE = {
    "Accept": "application/json, text/javascript, */*; q=0.01",
    "Accept-Language": "tr-TR,tr;q=0.9,en-US;q=0.8,en;q=0.7",
    "Content-Type": "application/x-www-form-urlencoded; charset=UTF-8",
    "X-Requested-With": "XMLHttpRequest",
    "User-Agent": UA,
    "Connection": "close",
}

CAPTCHA_MARKERS = (
    "cf-turnstile",
    "turnstile-form",
    "g-recaptcha",
    "recaptcha-form",
    "google.com/recaptcha",
    "hcaptcha.com",
)

TARGET_QUERY_KEYS = (
    "url",
    "u",
    "to",
    "target",
    "dest",
    "destination",
    "redirect",
    "redirect_url",
    "redirect_uri",
    "r",
)

class Colors:
    HEADER = '\033[95m'
    BLUE = '\033[94m'
    GREEN = '\033[92m'
    YELLOW = '\033[93m'
    RED = '\033[91m'
    BOLD = '\033[1m'
    END = '\033[0m'



class ResolveError(Exception):
    pass


class CaptchaRequired(ResolveError):
    pass


class NoRedirectHandler(urllib.request.HTTPRedirectHandler):
    def redirect_request(self, req, fp, code, msg, headers, newurl):  # type: ignore[override]
        return None


@dataclass
class HtmlForm:
    action: str
    method: str
    inputs: Dict[str, str]
    attrs: Dict[str, str]
    score: int = 0


@dataclass
class FetchResult:
    url: str
    final_url: str
    status: int
    headers: object
    text: str
    raw: bytes


class Resolver:
    def __init__(self, timeout: int = DEFAULT_TIMEOUT, verbose: bool = False, sleep_seconds: float = 0.0):
        self.timeout = timeout
        self.verbose = verbose
        self.sleep_seconds = sleep_seconds
        self.cookiejar = http.cookiejar.CookieJar()
        context = ssl.create_default_context()
        self.opener = urllib.request.build_opener(
            urllib.request.HTTPCookieProcessor(self.cookiejar),
            urllib.request.HTTPSHandler(context=context),
            urllib.request.HTTPHandler(),
        )
        self.no_redirect_opener = urllib.request.build_opener(
            urllib.request.HTTPCookieProcessor(self.cookiejar),
            urllib.request.HTTPSHandler(context=context),
            urllib.request.HTTPHandler(),
            NoRedirectHandler(),
        )

    def log(self, msg: str) -> None:
        if self.verbose:
            print(f"[{APP_NAME}] {msg}", file=sys.stderr)

    def fetch(
        self,
        url: str,
        method: str = "GET",
        data: Optional[Dict[str, str]] = None,
        headers: Optional[Dict[str, str]] = None,
        max_bytes: int = MAX_HTML_BYTES,
        read_body: bool = True,
        allow_redirects: bool = True,
    ) -> FetchResult:
        hdrs = dict(COMMON_HEADERS)
        if headers:
            hdrs.update(headers)

        body = None
        if data is not None:
            body = urllib.parse.urlencode(data).encode("utf-8")

        req = urllib.request.Request(url, data=body, headers=hdrs, method=method.upper())
        self.log(f"{method.upper()} {url}")

        try:
            opener = self.opener if allow_redirects else self.no_redirect_opener
            with opener.open(req, timeout=self.timeout) as resp:
                raw = b""
                if read_body:
                    raw = resp.read(max_bytes + 1)
                    if len(raw) > max_bytes:
                        raw = raw[:max_bytes]
                status = getattr(resp, "status", resp.getcode())
                final_url = resp.geturl()
                headers_obj = resp.headers
        except urllib.error.HTTPError as e:
            raw = b""
            if read_body:
                try:
                    raw = e.read(max_bytes + 1)
                    if len(raw) > max_bytes:
                        raw = raw[:max_bytes]
                except Exception:
                    raw = b""
            status = e.code
            final_url = e.geturl() if hasattr(e, "geturl") else url
            headers_obj = e.headers
        except urllib.error.URLError as e:
            raise ResolveError(f"Network error: {e}") from e

        text = decode_body(raw, headers_obj)
        if self.sleep_seconds > 0:
            time.sleep(self.sleep_seconds)
        return FetchResult(url=url, final_url=final_url, status=status, headers=headers_obj, text=text, raw=raw)

    def resolve(self, input_url: str, follow_final: bool = True) -> Tuple[str, Dict[str, str]]:
        start_url = normalize_url(input_url)
        info: Dict[str, str] = {"input": input_url, "normalized": start_url, "method": "unknown"}

        query_target = extract_target_from_query(start_url)
        if query_target:
            info["method"] = "query-param"
            final = self.final_follow(query_target) if follow_final else query_target
            info["result_before_final_follow"] = query_target
            return final, info

        if is_bildirim_host(start_url):
            info["method"] = "bildirim-intermediate"
            target = self.resolve_bildirim_url(start_url)
            info["result_before_final_follow"] = target
            final = self.final_follow(target) if follow_final else target
            return final, info

        if is_ouo_host(start_url):
            info["method"] = "ouo-flow"
            target = self.resolve_ouo_url(start_url)
            info["result_before_final_follow"] = target
            final = self.final_follow(target) if follow_final else target
            return final, info

        page = self.fetch(start_url, "GET")
        current_url = page.final_url
        current_host = host_of(current_url)
        info["landing_url"] = current_url
        info["landing_status"] = str(page.status)

        if current_host in BILDIRIM_HOSTS:
            info["method"] = "bildirim-intermediate"
            target = self.resolve_bildirim_url(current_url, page=page)
            info["result_before_final_follow"] = target
            final = self.final_follow(target) if follow_final else target
            return final, info

        if current_host in OUO_HOSTS or looks_like_ouo_page(page.text):
            info["method"] = "ouo-flow"
            target = self.resolve_ouo_url(current_url, page=page)
            info["result_before_final_follow"] = target
            final = self.final_follow(target) if follow_final else target
            return final, info

        if current_host not in SUPPORTED_HOSTS and current_url != start_url:
            info["method"] = "http-redirect"
            final = self.final_follow(current_url) if follow_final else current_url
            return final, info

        if current_host in TRLINK_HOSTS or looks_like_trlink_page(page.text):
            try:
                final_candidate = self.resolve_trlink_page(page)
                info["method"] = "trlink-flow"
                info["result_before_final_follow"] = final_candidate
                final = self.final_follow(final_candidate) if follow_final else final_candidate
                return final, info
            except CaptchaRequired:
                raise
            except ResolveError as e:
                self.log(f"TRLink flow failed: {e}")
                info["trlink_error"] = str(e)

        html_target = extract_redirect_from_html(page.text, current_url)
        if html_target:
            info["method"] = "html-redirect"
            info["result_before_final_follow"] = html_target
            final = self.final_follow(html_target) if follow_final else html_target
            return final, info

        info["method"] = "fallback-final-url"
        final = self.final_follow(current_url) if follow_final else current_url
        return final, info

    def resolve_trlink_page(self, page: FetchResult) -> str:
        html = page.text
        if has_captcha(html):
            raise CaptchaRequired(
                "This page contains CAPTCHA/Turnstile/reCAPTCHA. CLI mode will not solve it. "
                "Open the link in a browser, pass verification, then try again if the site allows it."
            )

        current_url = page.final_url
        parsed = urllib.parse.urlparse(current_url)
        host = (parsed.hostname or "").lower().removeprefix("www.")
        netloc = parsed.netloc
        if not host or not netloc:
            raise ResolveError("Could not detect host.")
        base = f"{parsed.scheme or 'https'}://{netloc}"

        a, t, d = extract_atd(html)
        alias = extract_input_value(html, "alias")
        csrf = extract_input_value(html, "csrf")

        self.log(f"extracted alias={alias!r}; csrf length={len(csrf)}")

        ajax_headers = dict(AJAX_HEADERS_BASE)
        ajax_headers["Referer"] = current_url
        ajax_headers["Origin"] = base
        ajax_headers["Sec-Fetch-Dest"] = "empty"
        ajax_headers["Sec-Fetch-Mode"] = "cors"
        ajax_headers["Sec-Fetch-Site"] = "same-origin"

        tk_resp = self.fetch(
            f"{base}/get/tk",
            "POST",
            data={"_a": a, "_t": t, "_d": d},
            headers=ajax_headers,
        )
        tk_data = parse_json_object(tk_resp.text, "token response")
        if not bool(tk_data.get("status")):
            raise ResolveError(f"Token request failed: {tk_data}")
        tkn = str(tk_data.get("th") or tk_data.get("tkn") or tk_data.get("token") or "")
        if not tkn:
            raise ResolveError(f"Token was not found in response: {tk_data}")

        go_payload = {"alias": alias, "csrf": csrf, "tkn": tkn}
        visitor_token = extract_visitor_token(html)
        if visitor_token:
            go_payload["visitor_token"] = visitor_token
        go_payload["signal"] = build_browser_signal()

        go_resp = self.fetch(
            f"{base}/links/go2",
            "POST",
            data=go_payload,
            headers=ajax_headers,
        )
        go_data = parse_json_object(go_resp.text, "go2 response")
        url = str(go_data.get("url") or "").strip()
        if not url:
            url = first_url_in_text(go_resp.text) or ""
        if not url:
            raise ResolveError(f"No URL returned by /links/go2: {go_data}")
        url = absolutize(url, current_url)
        url = html_lib.unescape(url)

        if is_bildirim_host(url):
            self.log(f"resolving bildirim intermediate URL: {host_of(url)}")
            return self.resolve_bildirim_url(url, referer=current_url)

        return url

    def resolve_bildirim_url(self, url: str, referer: Optional[str] = None, page: Optional[FetchResult] = None) -> str:
        url = normalize_url(url)
        if page is None:
            headers = {
                "Referer": referer or "https://aylink.co/",
                "Sec-Fetch-Dest": "document",
                "Sec-Fetch-Mode": "navigate",
                "Sec-Fetch-Site": "cross-site",
                "Upgrade-Insecure-Requests": "1",
            }
            page = self.fetch(url, "GET", headers=headers)

        if has_captcha(page.text):
            raise CaptchaRequired(
                "bildirim ara sayfasında CAPTCHA/Turnstile/reCAPTCHA görünüyor. "
                "Bu CLI aracı doğrulama çözmez."
            )

        target = extract_bildirim_url(page.text, page.final_url)
        if not target:
            target = extract_redirect_from_html(page.text, page.final_url)

        if target:
            target = html_lib.unescape(target).strip()
            if target and not is_bildirim_host(target):
                return target
            if target and target != url:
                return target

        if page.final_url and page.final_url != url and not is_bildirim_host(page.final_url):
            return page.final_url

        path_target = extract_bildirim_encoded_target(url)
        if path_target:
            return path_target

        snippet = strip_html(page.text)[:220].replace("\n", " ").strip()
        raise ResolveError(
            "bildirim.online/vip ara sayfasından gerçek URL çıkarılamadı. "
            f"HTTP status={page.status}; final_url={page.final_url}; body={snippet!r}"
        )

    def resolve_ouo_url(self, url: str, page: Optional[FetchResult] = None, referer: Optional[str] = None) -> str:
        """Resolve ouo.io/ouo.press by following its normal form and redirect hops.

        This routine intentionally does not attempt to solve CAPTCHA challenges.
        It submits only fields already present in the HTML and follows HTTP redirects.
        """
        start_url = normalize_url(url)
        if page is None:
            page = self.fetch(
                start_url,
                "GET",
                headers={
                    "Referer": referer or "https://www.google.com/",
                    "Sec-Fetch-Dest": "document",
                    "Sec-Fetch-Mode": "navigate",
                    "Sec-Fetch-Site": "cross-site",
                    "Upgrade-Insecure-Requests": "1",
                },
                allow_redirects=True,
            )

        if page.final_url and not is_ouo_host(page.final_url):
            return page.final_url

        current = page
        current_url = current.final_url or start_url
        slug = extract_ouo_slug(current_url) or extract_ouo_slug(start_url)
        seen: set[str] = set()

        for step in range(10):
            current_url = current.final_url or current_url
            if current_url in seen:
                break
            seen.add(current_url)
            self.log(f"ouo step {step + 1}: {current_url} status={current.status}")

            if current_url and not is_ouo_host(current_url):
                return current_url

            loc_target = header_location(current.headers, current_url)
            if loc_target:
                if not is_ouo_host(loc_target):
                    return loc_target
                current = self.fetch(
                    loc_target,
                    "GET",
                    headers={"Referer": current_url},
                    allow_redirects=False,
                )
                continue

            query_target = extract_target_from_query(current_url)
            if query_target and not is_ouo_host(query_target):
                return query_target

            html_target = extract_redirect_from_html(current.text, current_url)
            if html_target:
                if not is_ouo_host(html_target):
                    return html_target
                current = self.fetch(
                    html_target,
                    "GET",
                    headers={"Referer": current_url},
                    allow_redirects=False,
                )
                continue

            forms = extract_forms(current.text, current_url)
            forms = sorted(forms, key=lambda f: f.score, reverse=True)
            useful_forms = [f for f in forms if is_ouo_form(f) or f.score > 0]
            if useful_forms:
                form = useful_forms[0]
                self.log(f"ouo submit {form.method} {form.action} fields={list(form.inputs.keys())}")
                submitted = self.submit_form(form, referer=current_url)
                loc = header_location(submitted.headers, form.action)
                if loc:
                    if not is_ouo_host(loc):
                        return loc
                    current = self.fetch(
                        loc,
                        "GET",
                        headers={"Referer": current_url},
                        allow_redirects=False,
                    )
                    continue
                if submitted.final_url and not is_ouo_host(submitted.final_url):
                    return submitted.final_url
                current = submitted
                current_url = submitted.final_url or form.action
                continue

            next_links = extract_ouo_next_links(current.text, current_url)
            if slug:
                base = ouo_base_url(current_url)
                for suffix in (f"/go/{slug}", f"/xreallcygo/{slug}"):
                    candidate = urllib.parse.urljoin(base, suffix)
                    if candidate not in next_links:
                        next_links.append(candidate)

            advanced = False
            for next_url in next_links:
                if not next_url or next_url in seen:
                    continue
                self.log(f"ouo next {next_url}")
                next_page = self.fetch(
                    next_url,
                    "GET",
                    headers={"Referer": current_url},
                    allow_redirects=False,
                )
                loc = header_location(next_page.headers, next_url)
                if loc:
                    if not is_ouo_host(loc):
                        return loc
                    next_page = self.fetch(
                        loc,
                        "GET",
                        headers={"Referer": next_url},
                        allow_redirects=False,
                    )
                if next_page.final_url and not is_ouo_host(next_page.final_url):
                    return next_page.final_url
                current = next_page
                current_url = next_page.final_url or next_url
                advanced = True
                break
            if advanced:
                continue

            # Only now report CAPTCHA. Some ouo pages include CAPTCHA-related strings
            # even when a normal redirect form is still available, so we avoid failing early.
            if has_captcha(current.text):
                raise CaptchaRequired(
                    "ouo.io/ouo.press sayfasında CAPTCHA/Turnstile/reCAPTCHA gerekiyor gibi görünüyor. "
                    "Bu CLI aracı doğrulama çözmez."
                )
            break

        snippet = strip_html(current.text)[:220].replace("\n", " ").strip()
        raise ResolveError(
            "ouo.io/ouo.press akışından gerçek URL çıkarılamadı. "
            f"final_url={current.final_url}; status={current.status}; body={snippet!r}"
        )

    def submit_form(self, form: HtmlForm, referer: str) -> FetchResult:
        headers = dict(COMMON_HEADERS)
        headers.update(
            {
                "Referer": referer,
                "Origin": origin_of(form.action) or origin_of(referer),
                "Sec-Fetch-Dest": "document",
                "Sec-Fetch-Mode": "navigate",
                "Sec-Fetch-Site": "same-origin" if same_site(form.action, referer) else "cross-site",
                "Upgrade-Insecure-Requests": "1",
            }
        )
        method = (form.method or "GET").upper()
        if method == "POST":
            headers["Content-Type"] = "application/x-www-form-urlencoded"
            return self.fetch(
                form.action,
                "POST",
                data=form.inputs,
                headers=headers,
                allow_redirects=False,
            )

        target = form.action
        if form.inputs:
            sep = "&" if urllib.parse.urlparse(target).query else "?"
            target = target + sep + urllib.parse.urlencode(form.inputs)
        return self.fetch(target, "GET", headers=headers, allow_redirects=False)

    def final_follow(self, url: str) -> str:
        url = normalize_url(url)
        query_target = extract_target_from_query(url)
        if query_target:
            url = query_target

        if is_bildirim_host(url):
            try:
                target = self.resolve_bildirim_url(url)
                if target and target != url:
                    url = target
                else:
                    return url
            except ResolveError as e:
                self.log(f"bildirim final-follow failed: {e}")
                return url

        if is_ouo_host(url):
            try:
                target = self.resolve_ouo_url(url)
                if target and target != url:
                    url = target
                else:
                    return url
            except ResolveError as e:
                self.log(f"ouo final-follow failed: {e}")
                return url

        # HEAD is cheap when accepted.
        try:
            r = self.fetch(url, "HEAD", read_body=False)
            if r.final_url:
                return r.final_url
        except ResolveError as e:
            self.log(f"HEAD final-follow failed: {e}")

        # GET with Range usually avoids downloading a full body. Some servers ignore Range,
        # but this function reads at most 64 KiB.
        try:
            hdrs = {"Range": "bytes=0-65535"}
            r = self.fetch(url, "GET", headers=hdrs, max_bytes=65536, read_body=True)
            html_target = extract_bildirim_url(r.text, r.final_url) or extract_redirect_from_html(r.text, r.final_url)
            return html_target or r.final_url or url
        except ResolveError as e:
            self.log(f"GET final-follow failed: {e}")
            return url

def run_doctor():
    print(f"{Colors.GREEN}--- Ayson Doctor Kontrolü ---{Colors.END}")
    
    # 1. Python Sürümü
    print(f"✓ Python sürümü: {sys.version.split()[0]}")
    
    # 2. İnternet Kontrolü
    import socket
    try:
        socket.create_connection(("8.8.8.8", 53), timeout=3)
        print(f"✓ İnternet bağlantısı: {Colors.GREEN}OK{Colors.END}")
    except:
        print(f"✗ İnternet bağlantısı: {Colors.RED}BAĞLANTI YOK{Colors.END}")
        
    # 3. Kütüphane Kontrolü
    try:
        import requests
        print(f"✓ Gerekli modüller: {Colors.GREEN}Kurulu{Colors.END}")
    except:
        print(f"✗ Gerekli modüller: {Colors.RED}Eksik (pip install requests){Colors.END}")

    # 4. Servis Sayısı (Burayı değiştiriyoruz)
    # Eğer değişkenin adı SERVICES değilse, senin kodundaki listenin adını yazmalısın.
    # Eğer kodunda bu liste 'SUPPORTED_SERVICES' ise aşağıda onu kullan.
    try:
        # Kodundaki gerçek değişken adı neyse onu buraya yaz, örneğin:
        print(f"✓ Desteklenen servisler: {len(SUPPORTED_HOSTS)} adet aktif.") 
    except NameError:
        print(f"⚠ Servis listesi bilgisi alınamadı (Değişken tanımlı değil).")



def decode_body(raw: bytes, headers_obj: object) -> str:
    if not raw:
        return ""
    encoding = ""
    try:
        encoding = (headers_obj.get("Content-Encoding") or "").lower()
    except Exception:
        encoding = ""
    try:
        if encoding == "gzip":
            raw = gzip.decompress(raw)
        elif encoding == "deflate":
            try:
                raw = zlib.decompress(raw)
            except zlib.error:
                raw = zlib.decompress(raw, -zlib.MAX_WBITS)
    except Exception:
        pass

    charset = None
    try:
        charset = headers_obj.get_content_charset()
    except Exception:
        charset = None
    if not charset:
        m = re.search(br"<meta[^>]+charset=[\"']?([A-Za-z0-9._-]+)", raw[:4096], re.I)
        if m:
            charset = m.group(1).decode("ascii", "ignore")
    if not charset:
        charset = "utf-8"
    return raw.decode(charset, "replace")


def normalize_url(value: str) -> str:
    u = value.strip().strip("'\"")
    replacements = {
        "hxxps://": "https://",
        "hxxp://": "http://",
        "(dot)": ".",
        "[dot]": ".",
        "{dot}": ".",
        "(nokta)": ".",
        "[nokta]": ".",
        "{nokta}": ".",
    }
    low = u.lower()
    for old, new in replacements.items():
        if old in low:
            u = re.sub(re.escape(old), new, u, flags=re.I)
            low = u.lower()
    u = re.sub(r"\s+", "", u)
    if not re.match(r"^[a-zA-Z][a-zA-Z0-9+.-]*://", u):
        u = "https://" + u
    return u


def host_of(url: str) -> str:
    try:
        return (urllib.parse.urlparse(url).hostname or "").lower().removeprefix("www.")
    except Exception:
        return ""


def is_bildirim_host(url_or_host: str) -> bool:
    value = url_or_host.strip().lower()
    if "://" in value:
        value = host_of(value)
    else:
        value = value.removeprefix("www.")
    return value in BILDIRIM_HOSTS


def is_ouo_host(url_or_host: str) -> bool:
    value = url_or_host.strip().lower()
    if "://" in value:
        value = host_of(value)
    else:
        value = value.removeprefix("www.")
    return value in OUO_HOSTS


def looks_like_ouo_page(text: str) -> bool:
    low = (text or "").lower()
    return (
        "ouo.io" in low
        or "ouo.press" in low
        or "/xreallcygo/" in low
        or "/go/" in low and ("form" in low or "csrf" in low or "token" in low)
    )


def extract_ouo_slug(url: str) -> str:
    parsed = urllib.parse.urlparse(url)
    parts = [urllib.parse.unquote(p) for p in parsed.path.split("/") if p]
    if not parts:
        return ""
    if parts[0].lower() in {"go", "xreallcygo", "s", "qs"} and len(parts) >= 2:
        return parts[1]
    return parts[-1]


def ouo_base_url(url: str) -> str:
    parsed = urllib.parse.urlparse(url)
    if not parsed.scheme or not parsed.netloc:
        return "https://ouo.io/"
    return f"{parsed.scheme}://{parsed.netloc}/"


def header_location(headers_obj: object, base: str) -> Optional[str]:
    loc = None
    try:
        loc = headers_obj.get("Location")
    except Exception:
        loc = None
    if not loc:
        return None
    return absolutize(str(loc), base)


def origin_of(url: str) -> str:
    parsed = urllib.parse.urlparse(url)
    if not parsed.scheme or not parsed.netloc:
        return ""
    return f"{parsed.scheme}://{parsed.netloc}"


def same_site(a: str, b: str) -> bool:
    return host_of(a) == host_of(b) and bool(host_of(a))


def parse_tag_attrs(attr_text: str) -> Dict[str, str]:
    attrs: Dict[str, str] = {}
    attr_re = re.compile(
        r"([A-Za-z_:][-A-Za-z0-9_:.]*)"
        r'(?:\s*=\s*(?:"([^"]*)"|\'([^\']*)\'|([^\s"\'>`]+)))?',
        re.S,
    )
    for m in attr_re.finditer(attr_text or ""):
        key = m.group(1).lower()
        val = m.group(2) if m.group(2) is not None else m.group(3) if m.group(3) is not None else m.group(4)
        attrs[key] = html_lib.unescape(val or "")
    return attrs


def extract_forms(text: str, base: str) -> List[HtmlForm]:
    forms: List[HtmlForm] = []
    for m in re.finditer(r"<form\b([^>]*)>(.*?)</form>", text or "", re.I | re.S):
        attrs = parse_tag_attrs(m.group(1))
        body = m.group(2)
        action = attrs.get("action") or base
        action = absolutize(action, base)
        method = (attrs.get("method") or "GET").upper()
        inputs: Dict[str, str] = {}
        for tag in re.findall(r"<(?:input|button|textarea)\b[^>]*>", body, re.I | re.S):
            iattrs = parse_tag_attrs(tag)
            name = iattrs.get("name")
            if not name:
                continue
            value = iattrs.get("value", "")
            typ = iattrs.get("type", "").lower()
            if typ in {"submit", "button", "image", "reset"}:
                # Submit buttons are not necessary for the normal hidden-token flow.
                continue
            inputs[name] = value
        score = score_ouo_form(action, method, inputs, body, attrs)
        forms.append(HtmlForm(action=action, method=method, inputs=inputs, attrs=attrs, score=score))
    return forms


def score_ouo_form(action: str, method: str, inputs: Dict[str, str], body: str, attrs: Dict[str, str]) -> int:
    hay = " ".join([action, method, body, " ".join(inputs.keys()), " ".join(attrs.values())]).lower()
    score = 0
    if is_ouo_host(action):
        score += 5
    if "/go/" in hay:
        score += 20
    if "/xreallcygo/" in hay:
        score += 25
    if "_token" in inputs or "csrf" in inputs or any("token" in k.lower() for k in inputs):
        score += 10
    if method.upper() == "POST":
        score += 4
    if "captcha" in hay or "recaptcha" in hay:
        score -= 3
    return score


def is_ouo_form(form: HtmlForm) -> bool:
    if is_ouo_host(form.action):
        return True
    hay = " ".join([form.action, " ".join(form.inputs.keys())]).lower()
    return "/go/" in hay or "/xreallcygo/" in hay


def extract_ouo_next_links(text: str, base: str) -> List[str]:
    out: List[str] = []
    seen: set[str] = set()
    patterns = [
        r'\b(?:href|action)\s*=\s*([\'"])(.*?)\1',
        r'location\.(?:href|assign|replace)\s*(?:=|\()\s*([\'"])(.*?)\1',
        r'window\.open\(\s*([\'"])(.*?)\1',
        r'https?://[^\s\'"<>\)]+',
    ]
    for pat in patterns:
        for m in re.finditer(pat, text or "", re.I | re.S):
            raw = m.group(2) if m.lastindex and m.lastindex >= 2 else m.group(0)
            candidate = normalize_candidate_url(raw, base, allow_assets=False)
            if not candidate:
                continue
            if is_ouo_host(candidate) and candidate not in seen:
                seen.add(candidate)
                out.append(candidate)
    out.sort(key=lambda u: (0 if "/xreallcygo/" in u else 1 if "/go/" in u else 2, u))
    return out


def absolutize(url: str, base: str) -> str:
    url = html_lib.unescape(url.strip())
    return urllib.parse.urljoin(base, url)


def has_captcha(text: str) -> bool:
    low = text.lower()
    return any(marker in low for marker in CAPTCHA_MARKERS)


def looks_like_trlink_page(text: str) -> bool:
    low = text.lower()
    return (
        "/get/tk" in low
        or "/links/go2" in low
        or "name=\"alias\"" in low
        or "name='alias'" in low
        or ("_a" in low and "_t" in low and "_d" in low)
    )


def extract_atd(text: str) -> Tuple[str, str, str]:
    patterns = [
        r"_a\s*=\s*['\"]([^'\"]+)['\"]\s*,\s*_t\s*=\s*['\"]([^'\"]+)['\"]\s*,\s*_d\s*=\s*['\"]([^'\"]+)['\"]",
        r"var\s+_a\s*=\s*['\"]([^'\"]+)['\"];?\s*var\s+_t\s*=\s*['\"]([^'\"]+)['\"];?\s*var\s+_d\s*=\s*['\"]([^'\"]+)['\"]",
        r"let\s+_a\s*=\s*['\"]([^'\"]+)['\"];?\s*let\s+_t\s*=\s*['\"]([^'\"]+)['\"];?\s*let\s+_d\s*=\s*['\"]([^'\"]+)['\"]",
        r"const\s+_a\s*=\s*['\"]([^'\"]+)['\"];?\s*const\s+_t\s*=\s*['\"]([^'\"]+)['\"];?\s*const\s+_d\s*=\s*['\"]([^'\"]+)['\"]",
    ]
    for pat in patterns:
        m = re.search(pat, text, re.I | re.S)
        if m:
            return tuple(html_lib.unescape(x) for x in m.groups())  # type: ignore[return-value]
    # More tolerant fallback: find each variable separately.
    vals = []
    for name in ("_a", "_t", "_d"):
        m = re.search(rf"\b{name}\s*=\s*['\"]([^'\"]+)['\"]", text, re.I)
        if not m:
            raise ResolveError("Could not extract _a/_t/_d values from the page.")
        vals.append(html_lib.unescape(m.group(1)))
    return vals[0], vals[1], vals[2]


def extract_input_value(text: str, name: str) -> str:
    # Match an input tag containing name=... and value=... in any attribute order.
    input_tags = re.findall(r"<input\b[^>]*>", text, re.I | re.S)
    for tag in input_tags:
        nm = re.search(r"\bname\s*=\s*(['\"])(.*?)\1", tag, re.I | re.S)
        if not nm or nm.group(2) != name:
            continue
        val = re.search(r"\bvalue\s*=\s*(['\"])(.*?)\1", tag, re.I | re.S)
        if val:
            return html_lib.unescape(val.group(2))
    # Fallback for source that places alias/csrf in JS.
    js_patterns = [
        rf"\b{name}\b\s*[:=]\s*['\"]([^'\"]+)['\"]",
        rf"app\[['\"]{re.escape(name)}['\"]\]\s*=\s*['\"]([^'\"]+)['\"]",
    ]
    for pat in js_patterns:
        m = re.search(pat, text, re.I)
        if m:
            return html_lib.unescape(m.group(1))
    raise ResolveError(f"Could not extract input value: {name}")


def extract_visitor_token(text: str) -> str:
    try:
        return extract_input_value(text, "visitor_token")
    except ResolveError:
        pass
    patterns = [
        r"app\[['\"]token['\"]\]\s*=\s*['\"]([^'\"]+)['\"]",
        r"\bvisitor_token\b\s*[:=]\s*['\"]([^'\"]+)['\"]",
        r"\btoken\b\s*[:=]\s*['\"]([^'\"]{12,})['\"]",
    ]
    for pat in patterns:
        m = re.search(pat, text, re.I)
        if m:
            return html_lib.unescape(m.group(1))
    return ""


def build_browser_signal() -> str:
    return json.dumps(
        {
            "t": int(time.time()),
            "d": 5,
            "m": {"move": 5, "click": 1, "scroll": 1, "key": 0, "touch": 0, "focus": 1},
            "f": {"webdriver": False, "headless": False, "noPlugins": False, "mobile": False},
        },
        separators=(",", ":"),
    )


def parse_json_object(text: str, label: str) -> Dict[str, object]:
    cleaned = text.strip()
    try:
        data = json.loads(cleaned)
        if isinstance(data, dict):
            return data
        raise ValueError("JSON is not an object")
    except Exception:
        m = re.search(r"\{.*\}", cleaned, re.S)
        if m:
            try:
                data = json.loads(m.group(0))
                if isinstance(data, dict):
                    return data
            except Exception:
                pass
    raise ResolveError(f"Could not parse {label} as JSON: {cleaned[:300]!r}")


def extract_bildirim_url(text: str, base: str) -> Optional[str]:
    # bildirim.online/vip usually displays an alert/notification prompt and keeps
    # the actual destination in a JavaScript variable such as: var url = 'https://...';
    text = html_lib.unescape(text or "")
    assignment_patterns = [
        r"\b(?:var|let|const)?\s*(?:url|uri|uri_full|go_url|target|destination|redirect|redirect_url)\s*[:=]\s*(['\"])(.*?)\1",
        r"(['\"])(?:url|uri|uri_full|go_url|target|destination|redirect|redirect_url)\1\s*:\s*(['\"])(.*?)\2",
        r"(?:window\.)?open\(\s*(['\"])(.*?)\1",
        r"\b(?:data-url|data-href|data-target)\s*=\s*(['\"])(.*?)\1",
    ]
    for pat in assignment_patterns:
        for m in re.finditer(pat, text, re.I | re.S):
            raw = m.group(m.lastindex or 1)
            # JSON style pattern has three groups: quote,keyquote,value.
            if m.lastindex and m.lastindex >= 3:
                raw = m.group(3)
            candidate = normalize_candidate_url(raw, base)
            if candidate:
                return candidate

    # A common JS form: location.href = decodeURIComponent('https%3A%2F%2F...')
    for pat in [
        r"decodeURIComponent\(\s*(['\"])(.*?)\1\s*\)",
        r"unescape\(\s*(['\"])(.*?)\1\s*\)",
    ]:
        for m in re.finditer(pat, text, re.I | re.S):
            candidate = normalize_candidate_url(m.group(2), base)
            if candidate:
                return candidate

    # Some pages hide the URL in atob('base64...').
    for m in re.finditer(r"atob\(\s*(['\"])([A-Za-z0-9+/_=-]{16,})\1\s*\)", text, re.I | re.S):
        decoded = decode_base64_urlish(m.group(2))
        candidate = normalize_candidate_url(decoded or "", base)
        if candidate:
            return candidate

    # Last cautious fallback: only use literal URLs that do not look like page assets.
    for m in re.finditer(r"https?://[^\s'\"<>\\)]+", text, re.I):
        candidate = normalize_candidate_url(m.group(0), base, allow_assets=False)
        if candidate and not is_bildirim_host(candidate):
            return candidate
    return None


def normalize_candidate_url(value: str, base: str, allow_assets: bool = True) -> Optional[str]:
    if not value:
        return None
    candidate = html_lib.unescape(value).strip().strip("`'\"")
    candidate = candidate.replace("\\/", "/")
    try:
        candidate = bytes(candidate, "utf-8").decode("unicode_escape")
    except Exception:
        pass
    candidate = candidate.strip()
    if not re.match(r"^https?://", candidate, re.I) and "%" in candidate:
        candidate = urllib.parse.unquote(candidate).strip()
    if not candidate or candidate.startswith(("#", "javascript:", "mailto:", "tel:")):
        return None
    if candidate.startswith("//"):
        parsed = urllib.parse.urlparse(base)
        candidate = f"{parsed.scheme or 'https'}:{candidate}"
    candidate = absolutize(candidate, base)
    if not re.match(r"^https?://", candidate, re.I):
        return None
    if not allow_assets and looks_like_asset_url(candidate):
        return None
    return candidate


def looks_like_asset_url(url: str) -> bool:
    path = urllib.parse.urlparse(url).path.lower()
    return bool(re.search(r"\.(?:js|css|png|jpg|jpeg|gif|webp|svg|ico|woff2?|ttf|eot|mp4|webm|mp3|wav)(?:$|[?#])", path))


def decode_base64_urlish(value: str) -> Optional[str]:
    try:
        s = value.strip().replace("-", "+").replace("_", "/")
        s += "=" * ((4 - len(s) % 4) % 4)
        return base64_bdecode_to_text(s)
    except Exception:
        return None


def base64_bdecode_to_text(value: str) -> str:
    import base64
    return base64.b64decode(value).decode("utf-8", "replace")


def extract_bildirim_encoded_target(url: str) -> Optional[str]:
    # The /ph/<token> segment is often encrypted, not plain base64. Still, handle
    # the simple base64 cases so direct bildirim links can resolve when possible.
    parsed = urllib.parse.urlparse(url)
    parts = [p for p in parsed.path.split("/") if p]
    for part in reversed(parts):
        decoded = decode_base64_urlish(part)
        candidate = normalize_candidate_url(decoded or "", url)
        if candidate:
            return candidate
    return None


def strip_html(text: str) -> str:
    text = re.sub(r"<script\b.*?</script>", " ", text or "", flags=re.I | re.S)
    text = re.sub(r"<style\b.*?</style>", " ", text, flags=re.I | re.S)
    text = re.sub(r"<[^>]+>", " ", text)
    text = html_lib.unescape(text)
    return re.sub(r"\s+", " ", text).strip()


def extract_redirect_from_html(text: str, base: str) -> Optional[str]:
    patterns = [
        r"<meta[^>]+http-equiv\s*=\s*['\"]?refresh['\"]?[^>]+content\s*=\s*['\"][^'\"]*?url\s*=\s*([^'\";>\s]+)",
        r"window\.location\.href\s*=\s*['\"]([^'\"]+)['\"]",
        r"window\.location\s*=\s*['\"]([^'\"]+)['\"]",
        r"document\.location\s*=\s*['\"]([^'\"]+)['\"]",
        r"location\.href\s*=\s*['\"]([^'\"]+)['\"]",
        r"location\.replace\(\s*['\"]([^'\"]+)['\"]\s*\)",
        r"location\.assign\(\s*['\"]([^'\"]+)['\"]\s*\)",
        r"window\.open\(\s*['\"]([^'\"]+)['\"]",
    ]
    for pat in patterns:
        m = re.search(pat, text, re.I | re.S)
        if m:
            candidate = html_lib.unescape(m.group(1).strip())
            if candidate:
                return absolutize(candidate, base)
    return None


def first_url_in_text(text: str) -> Optional[str]:
    m = re.search(r"https?://[^\s'\"<>\\)]+", text)
    if not m:
        return None
    return html_lib.unescape(m.group(0).rstrip(".,;"))


def extract_target_from_query(url: str) -> Optional[str]:
    parsed = urllib.parse.urlparse(url)
    qs = urllib.parse.parse_qs(parsed.query)
    for key in TARGET_QUERY_KEYS:
        if key in qs and qs[key]:
            val = qs[key][0].strip()
            val = html_lib.unescape(urllib.parse.unquote(val))
            if val.startswith("http://") or val.startswith("https://"):
                return val
    return None


def install_self(command_name: str = APP_NAME) -> int:
    """Install this single Python file as a Termux command."""
    src_path = os.path.realpath(__file__)
    prefix = os.environ.get("PREFIX") or os.path.join(os.path.expanduser("~"), ".local")
    bin_dir = os.path.join(prefix, "bin")
    dst_path = os.path.join(bin_dir, command_name)

    if not os.path.exists(src_path):
        print("ERROR: Bu dosyanin yolu bulunamadi; once dosyayi Termux'a kaydet.", file=sys.stderr)
        return EXIT_ERROR

    try:
        os.makedirs(bin_dir, exist_ok=True)
        shutil.copyfile(src_path, dst_path)
        current_mode = os.stat(dst_path).st_mode
        os.chmod(dst_path, current_mode | stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH)
    except PermissionError as e:
        print(f"ERROR: Kurulum icin izin yok: {e}", file=sys.stderr)
        return EXIT_ERROR
    except OSError as e:
        print(f"ERROR: Kurulum basarisiz: {e}", file=sys.stderr)
        return EXIT_ERROR

    print(f"Kuruldu: {dst_path}")
    print(f"Kullanim: {command_name} 'https://ay.live/xxxxx'")
    print(f"OUO:     {command_name} 'https://ouo.io/xxxxx'")
    return EXIT_SUCCESS


def uninstall_cli(
    install_name: str = "ayson",
    force: bool = False
) -> int:
    """
    $PREFIX/bin altindaki kurulu komutu siler.
    """
    target = os.path.join(os.environ.get("PREFIX", "/data/data/com.termux/files/usr"), "bin", install_name)

    if not os.path.exists(target):
        print(f"[!] '{install_name}' kurulu degil.")
        return EXIT_ERROR

    try:
        if not force:
            print(f"This will remove '{install_name}' from:")
            print(target)
            print()
        
            answer = input("Continue? [y/N]: ").strip().lower()
        
            if answer not in ("y", "yes"):
                print("Cancelled.")
                return EXIT_SUCCESS
                
        os.remove(target)
        print(f"[+] Kaldirildi: {target}")
        return EXIT_SUCCESS
        
    except Exception as e:
        print(f"[!] Kaldirilamadi: {e}")
        return EXIT_ERROR

def is_valid_url(url: str) -> bool:
    """
    URL'nin temel geçerliliğini kontrol eder.
    """
    parsed = urlparse(url)

    return (
        parsed.scheme in ("http", "https")
        and bool(parsed.netloc)
    )
            

def build_arg_parser() -> argparse.ArgumentParser:
    p = argparse.ArgumentParser(
        prog=APP_NAME,
        formatter_class=argparse.RawTextHelpFormatter,
        description=(
            f"{APP_NAME} {VERSION}\n"
            "Built by BlackCorpDev\n\n"
            "Resolve supported short-link services directly from your terminal."
        ),
        epilog=(
            "Examples:\n"
            f"  {APP_NAME} https://ay.live/xxxx\n"
            f"  {APP_NAME} -v https://ouo.io/xxxx\n"
            f"  echo \"https://ay.live/xxxx\" | {APP_NAME}\n"
            f"  {APP_NAME} --list-services\n"
        ),
    )
    p.add_argument("url", nargs="?", help="Cozulecek kisa URL. Bos birakilirsa stdin okunur.")
    p.add_argument("-v", "--verbose", action="store_true", help="Adimlari stderr'e yazdir.")
    p.add_argument("--json", action="store_true", help="Sadece URL yerine JSON cikti ver.")
    p.add_argument("--no-follow-final", action="store_true", help="Bulunan son URL uzerinde ekstra HEAD/GET takip yapma.")
    p.add_argument("--timeout", type=int, default=DEFAULT_TIMEOUT, help="Ag zaman asimi, saniye.")
    p.add_argument("--sleep", type=float, default=0.0, help="Istekler arasinda istege bagli bekleme, saniye.")
    p.add_argument("--install", action="store_true", help="Bu tek dosyayi Termux komutu olarak $PREFIX/bin/ayson konumuna kur.")
    p.add_argument("--install-name", default=APP_NAME, help="--install icin komut adi. Varsayilan: ayson")
    p.add_argument("-V", "--version", action="store_true", help="Surum bilgisini yazdir.")
    p.add_argument("--list-services", action="store_true", help="Desteklenen servisleri listele ve çık.")
    p.add_argument("--uninstall", action="store_true", help="Kurulu Ayson komutunu kaldır.")
    p.add_argument("--force", action="store_true", help="Onay istemeden işlem yap.")
    p.add_argument("-o", "--output", metavar="DOSYA", help="Sonuclari kaydetmek icin dosya yolu.")
    p.add_argument("--doctor", action="store_true", help="Sistem kontrolü yap ve sorunlari tespit et.")

    return p


def main(argv: Optional[Iterable[str]] = None) -> int:
    args = build_arg_parser().parse_args(argv)

    # Argumentlerin alındığı yerin hemen altına
    if args.doctor:
        run_doctor() # (Bunu bir fonksiyon olarak tanımlayacağız)
        sys.exit(0)  # Doktor bittikten sonra program devam etmesin

    if args.list_services:
        print(f"{APP_NAME} {VERSION}")
        print()
        print("Supported Services")
        print("-" * 24)
    
        services = sorted(SUPPORTED_HOSTS)
    
        for host in services:
            print(f"✓ {host}")
    
        print("-" * 24)
        print(f"Total: {len(services)} services")
        sys.exit(EXIT_SUCCESS)

    if args.version:
        print(f"{APP_NAME} {VERSION}\n" "Build By BlackCorpDev")
        return EXIT_SUCCESS

    if args.install:
        return install_self(args.install_name)

    if args.uninstall:
        sys.exit(
            uninstall_cli(
                install_name=args.install_name,
                force=args.force
            )
        )
    
    url = args.url
    # URL girişi bir dosya yolu ise onu oku
    if url and os.path.isfile(url):
        with open(url, "r", encoding="utf-8") as f:
            # Hem boş satırları hem de # ile başlayan yorumları temizle
            urls = [
                line.strip()
                for line in f
                if line.strip() and not line.strip().startswith("#")
            ]
    else:
        # Tek bir URL ise listeye al
        urls = [url]

    resolver = Resolver(
        timeout=args.timeout,
        verbose=args.verbose,
        sleep_seconds=args.sleep,
    )

    exit_code = EXIT_SUCCESS
            
    # Çıktı dosyası tanımlandıysa aç (append modunda)
    out_f = open(args.output, "a", encoding="utf-8") if args.output else None
    if args.output:
        print(f"{Colors.BOLD}[*]{Colors.END} İşlem başladı... Sonuçlar '{Colors.GREEN}{args.output}{Colors.END}' dosyasına yazılıyor.")
    
        
    count = 0
    for item in urls:
        try:
            final, info = resolver.resolve(
                item,
                follow_final=not args.no_follow_final,
            )

            if args.json:
                out = dict(info)
                out["version"] = VERSION
                out["final_url"] = final
                res_str = json.dumps(out, ensure_ascii=False)
            else:
                res_str = final

            if out_f:
                out_f.write(res_str + "\n")
            else:
                print(res_str)
            count += 1
            
        except Exception as e:
            print(f"{Colors.RED}[!] ERROR:{Colors.END} {item}: {e}", file=sys.stderr)
            exit_code = EXIT_ERROR
        

                
    # Dosyayı güvenli bir şekilde kapat
    if out_f:
        out_f.close()
        print(f"{Colors.GREEN}[+]{Colors.END} Başarılı! {Colors.BOLD}{count}{Colors.END} adet link çözüldü ve '{Colors.GREEN}{args.output}{Colors.END}' dosyasına yazıldı.")
    
    return exit_code
        
    if not url:
        data = sys.stdin.read().strip()
        if data:
            url = data.splitlines()[0].strip()
    if not url:
        print("Kullanim: ayson 'https://ay.live/xxxxx'", file=sys.stderr)
        print("OUO:     ayson 'https://ouo.io/xxxxx'", file=sys.stderr)
        print("Kurulum: python ayson_v1.py --install", file=sys.stderr)
        return EXIT_INVALID_URL

    if not is_valid_url(url):
        print(
            "ERROR: Invalid URL. Expected http:// or https://",
            file=sys.stderr,
        )
        return EXIT_INVALID_URL

    resolver = Resolver(timeout=args.timeout, verbose=args.verbose, sleep_seconds=args.sleep)
    try:
        final, info = resolver.resolve(url, follow_final=not args.no_follow_final)
        if args.json:
            out = dict(info)
            out["version"] = VERSION
            out["final_url"] = final
            print(json.dumps(out, ensure_ascii=False, indent=2))
        else:
            print(final)
        return EXIT_SUCCESS
    except CaptchaRequired as e:
        if args.json:
            print(json.dumps({"error": "captcha_required", "message": str(e)}, ensure_ascii=False, indent=2))
        else:
            print(f"ERROR: {e}", file=sys.stderr)
        return EXIT_ERROR
    except ResolveError as e:
        if args.json:
            print(json.dumps({"error": "resolve_error", "message": str(e)}, ensure_ascii=False, indent=2))
        else:
            print(f"ERROR: {e}", file=sys.stderr)
        return EXIT_RESOLVE_FAILED
    except KeyboardInterrupt:
        print("Interrupted.", file=sys.stderr)
        return EXIT_INTERRUPTED


if __name__ == "__main__":
    raise SystemExit(main())