import argparse
import os
import random
from pathlib import Path
from urllib.parse import urlparse
from dotenv import load_dotenv
from camoufox.sync_api import Camoufox

BASE_DIR = Path(__file__).resolve().parent
ENVIRONMENT = os.getenv("ENVIRONMENT", "develop")
ENV_FILE = BASE_DIR / f".env.{ENVIRONMENT}"

if ENV_FILE.exists():
    load_dotenv(dotenv_path=ENV_FILE)
else:
    load_dotenv()


def _load_rotating_proxy_list() -> list[str]:
    raw = os.getenv("ROTATING_PROXY_LIST", "")
    if not raw:
        return []
    return [proxy.strip() for proxy in raw.split(",") if proxy.strip()]


ROTATING_PROXY_LIST = _load_rotating_proxy_list()
DEFAULT_URL = "https://example.com"


def make_proxy_config(proxy: str) -> dict:
    proxy_url = urlparse(f"http://{proxy}")
    return {
        "server": f"http://{proxy_url.hostname}:{proxy_url.port}",
    }


def get_screenshot_filename(url: str) -> str:
    domain = urlparse(url).netloc
    if domain.startswith("www."):
        domain = domain[4:]
    if not domain:
        domain = "screenshot"
    return f"{domain}.png"


def try_visit(url: str, proxy: str | None = None) -> None:
    kwargs = {
        "headless": True,
    }
    if proxy:
        print(f"Usando proxy: {proxy}")
        kwargs["proxy"] = make_proxy_config(proxy)
        kwargs["geoip"] = True
    else:
        print("No se usará proxy")

    screenshot_path = get_screenshot_filename(url)

    with Camoufox(**kwargs) as browser:
        page = browser.new_page()
        page.goto(url, timeout=120000)
        page.wait_for_load_state("networkidle", timeout=120000)
        page.screenshot(path=screenshot_path)
        print(f"Screenshot guardado como {screenshot_path}")


def main() -> None:
    parser = argparse.ArgumentParser(description="Visita una URL con Camoufox")
    parser.add_argument(
        "url",
        nargs="?",
        default=DEFAULT_URL,
        help="URL a visitar (por defecto: página de Mercado Libre)",
    )
    parser.add_argument(
        "--use-proxy",
        action="store_true",
        help="Usar un proxy aleatorio de ROTATING_PROXY_LIST",
    )
    args = parser.parse_args()

    if args.use_proxy:
        max_attempts = 5
        for attempt in range(1, max_attempts + 1):
            proxy = random.choice(ROTATING_PROXY_LIST)
            try:
                try_visit(args.url, proxy=proxy)
                break
            except Exception as exc:
                print(f"Intento {attempt} falló: {exc}")
                if attempt == max_attempts:
                    raise
    else:
        try_visit(args.url)


if __name__ == "__main__":
    main()