from fastapi import APIRouter, HTTPException, Header
from typing import Optional
from urllib.parse import unquote
from app.config import API_KEY
from app.database import get_cached_data, save_to_cache
from app.services.browser import (
    visit_url_service,
    extract_seo_service,
    extract_meta_tags_service,
    capture_outgoing_calls_service,
    get_resulting_url_service
)

router = APIRouter()

@router.get("/")
async def visit_url(url: str, skipCache: bool = False, x_api_key: Optional[str] = Header(None)):
    # Validate API key
    if not x_api_key or x_api_key != API_KEY:
        raise HTTPException(status_code=401, detail="Invalid API key")

    # Decode URL if it's encoded
    decoded_url = unquote(url)

    # Check cache first (unless skipCache is True)
    if not skipCache:
        cached_result = get_cached_data(decoded_url, "visit")
        if cached_result:
            return cached_result

    try:
        # Call the service function
        result = await visit_url_service(decoded_url)

        if(result["status"] == "success"):
            # Save to cache (even if we skipped reading from it)
            save_to_cache(decoded_url, "visit", result)

        return result
    except Exception as e:
        print(f"Error visiting URL {decoded_url}: {e}")
        raise HTTPException(status_code=500, detail=str(e))

@router.get("/seo")
async def extract_seo(url: str, skipCache: bool = False, x_api_key: Optional[str] = Header(None)):
    """Extract SEO information from a website"""
    # Validate API key
    if not x_api_key or x_api_key != API_KEY:
        raise HTTPException(status_code=401, detail="Invalid API key")

    # Decode URL if it's encoded
    decoded_url = unquote(url)

    # Check cache first (unless skipCache is True)
    if not skipCache:
        cached_result = get_cached_data(decoded_url, "seo")
        if cached_result:
            return cached_result

    try:
        # Call the service function
        result = await extract_seo_service(decoded_url)

        # Save to cache
        if(result["status"] == "success"):
            save_to_cache(decoded_url, "seo", result)

        return result
    except Exception as e:
        raise HTTPException(status_code=500, detail=str(e))

@router.get("/meta")
async def extract_meta_tags(url: str, skipCache: bool = False, x_api_key: Optional[str] = Header(None)):
    """Extract meta tags from a website"""
    # Validate API key
    if not x_api_key or x_api_key != API_KEY:
        raise HTTPException(status_code=401, detail="Invalid API key")

    # Decode URL if it's encoded
    decoded_url = unquote(url)

    # Check cache first (unless skipCache is True)
    if not skipCache:
        cached_result = get_cached_data(decoded_url, "meta")
        if cached_result:
            return cached_result

    try:
        # Call the service function
        result = await extract_meta_tags_service(decoded_url)

        # Save to cache
        if(result["status"] == "success"):
            save_to_cache(decoded_url, "meta", result)

        return result
    except Exception as e:
        raise HTTPException(status_code=500, detail=str(e))


@router.get("/outgoing-calls")
async def capture_outgoing_calls(url: str, skipCache: bool = False, x_api_key: Optional[str] = Header(None)):
    """Capture outgoing API calls from a website"""
    # Validate API key
    if not x_api_key or x_api_key != API_KEY:
        raise HTTPException(status_code=401, detail="Invalid API key")

    # Decode URL if it's encoded
    decoded_url = unquote(url)

    # Check cache first (unless skipCache is True)
    if not skipCache:
        cached_result = get_cached_data(decoded_url, "outgoing_calls")
        if cached_result:
            return cached_result

    try:
        # Call the service function
        result = await capture_outgoing_calls_service(decoded_url)

        # Save to cache
        if(result["status"] == "success"):
            save_to_cache(decoded_url, "outgoing_calls", result)

        return result
    except Exception as e:
        print(f"Error capturing outgoing calls for URL {decoded_url}: {e}")
        raise HTTPException(status_code=500, detail=str(e))


@router.get("/resulting-url")
async def get_resulting_url(url: str, skipCache: bool = False, x_api_key: Optional[str] = Header(None)):
    """Get the resulting URL after navigation (handles redirects)"""
    # Validate API key
    if not x_api_key or x_api_key != API_KEY:
        raise HTTPException(status_code=401, detail="Invalid API key")

    # Decode URL if it's encoded
    decoded_url = unquote(url)

    # Check cache first (unless skipCache is True)
    if not skipCache:
        cached_result = get_cached_data(decoded_url, "resulting_url")
        if cached_result:
            return cached_result

    try:
        # Call the service function
        result = await get_resulting_url_service(decoded_url)

        # Save to cache
        if(result["status"] == "success"):
            save_to_cache(decoded_url, "resulting_url", result)

        return result
    except Exception as e:
        print(f"Error getting resulting URL for {decoded_url}: {e}")
        raise HTTPException(status_code=500, detail=str(e))