"""
Configuration and global variables for Web Parser MCP
"""

import logging

import requests

# Configure logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

# Import structured logging
try:
    from .utils.logging import get_structured_logger

    structured_logger = get_structured_logger()
except ImportError:
    structured_logger = None

# Global requests session (kept for backward compatibility)
session = requests.Session()
session.headers.update(
    {
        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36"
    }
)

# Global Playwright variables for unified browser session
playwright_instance = None
browser_instance = None
context_instance = None
page_instance = None

# Global cache variables
memory_cache = {}
cache_timestamps = {}

# Global session state management - для sharing сессии между инструментами
authenticated_session = {
    "active": False,
    "login_url": None,
    "login_timestamp": None,
    "cookies_count": 0,
    "browser_cookies": [],
    "headers": {},
    "user_agent": None,
    "last_activity": None,
    "auth_tokens": {},
    "session_data": {},
}

# Anti-detection headers
ANTI_DETECTION_HEADERS = [
    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36",
    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36",
    "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36",
    "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:124.0) Gecko/20100101 Firefox/124.0",
    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:124.0) Gecko/20100101 Firefox/124.0",
]


async def ensure_browser_session(stealth: bool = False):
    """Ensure unified browser session is initialized."""
    global playwright_instance, browser_instance, context_instance, page_instance

    if not PLAYWRIGHT_AVAILABLE:
        raise RuntimeError("Playwright not available. Install with: pip install playwright")

    if not playwright_instance:
        from playwright.async_api import async_playwright

        playwright_instance = await async_playwright().start()

        # Enhanced browser launch with stealth options
        browser_args = ["--no-sandbox", "--disable-dev-shm-usage"]

        if stealth:
            # Add stealth arguments for anti-detection
            browser_args.extend(
                [
                    "--disable-blink-features=AutomationControlled",
                    "--disable-web-security",
                    "--disable-features=VizDisplayCompositor",
                    "--disable-extensions",
                    "--disable-plugins",
                    "--disable-default-apps",
                    "--disable-background-timer-throttling",
                    "--disable-backgrounding-occluded-windows",
                    "--disable-renderer-backgrounding",
                ]
            )

        browser_instance = await playwright_instance.chromium.launch(
            headless=False,
            args=browser_args,  # Show browser for debugging
        )

    if not context_instance:
        context_args = {
            "viewport": {"width": 1920, "height": 1080},
            "user_agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36",
        }

        if stealth:
            # Add stealth context options
            context_args.update(
                {
                    "locale": "en-US",
                    "timezone_id": "America/New_York",
                    "geolocation": {
                        "latitude": 40.7128,
                        "longitude": -74.0060,
                    },  # New York
                    "permissions": ["geolocation"],
                }
            )

        context_instance = await browser_instance.new_context(**context_args)

    if not page_instance:
        page_instance = await context_instance.new_page()

        if stealth:
            # Apply JavaScript stealth techniques
            await page_instance.add_init_script(
                """
                // Remove webdriver property
                Object.defineProperty(navigator, 'webdriver', {
                    get: () => undefined,
                });

                // Override permissions
                const originalQuery = window.navigator.permissions.query;
                window.navigator.permissions.query = (parameters) => (
                    parameters.name === 'notifications' ?
                    Promise.resolve({ state: Notification.permission }) :
                    originalQuery(parameters)
                );

                // Override plugins
                Object.defineProperty(navigator, 'plugins', {
                    get: () => [1, 2, 3, 4, 5].map(() => ({})),
                });

                // Override languages
                Object.defineProperty(navigator, 'languages', {
                    get: () => ['en-US', 'en'],
                });
            """
            )

    return page_instance


async def cleanup_browser_session():
    """Clean up browser session."""
    global playwright_instance, browser_instance, context_instance, page_instance

    if page_instance:
        try:
            await page_instance.close()
        except:
            pass
        page_instance = None

    if context_instance:
        try:
            await context_instance.close()
        except:
            pass
        context_instance = None

    if browser_instance:
        try:
            await browser_instance.close()
        except:
            pass
        browser_instance = None

    if playwright_instance:
        try:
            await playwright_instance.stop()
        except:
            pass
        playwright_instance = None


# Check for optional dependencies
try:
    from playwright.async_api import Browser, BrowserContext, Page, async_playwright

    PLAYWRIGHT_AVAILABLE = True
except ImportError:
    PLAYWRIGHT_AVAILABLE = False

try:
    import browser_cookie3

    BROWSER_COOKIE3_AVAILABLE = True
except ImportError:
    BROWSER_COOKIE3_AVAILABLE = False