from fastapi import APIRouter, HTTPException, Header, Response
from typing import Optional, List, Literal, Union, Annotated
from urllib.parse import unquote
from app.config import API_KEY
from app.database import get_cached_data, save_to_cache
from pydantic import BaseModel, Field
from app.services.browser import (
    visit_url_service,
    screenshot_url_service,
    interactions_service,
    extract_seo_service,
    extract_meta_tags_service,
    capture_outgoing_calls_service,
    get_resulting_url_service
)

router = APIRouter(tags=["Browser"])

class ClickInteraction(BaseModel):
    action: Literal["click"]
    selector: Optional[str] = None
    x: Optional[int] = None
    y: Optional[int] = None


class TypeInteraction(BaseModel):
    action: Literal["type"]
    selector: Optional[str] = None
    text: str
    x: Optional[int] = None
    y: Optional[int] = None


Interaction = Annotated[
    Union[ClickInteraction, TypeInteraction],
    Field(discriminator="action"),
]


class Viewport(BaseModel):
    width: int
    height: int


class InteractionsRequest(BaseModel):
    url: str = Field(..., description="Target URL (will be URL-decoded server-side).")
    returnType: Optional[Literal["screenshot", "html", "resulting_url"]] = Field(
        "screenshot",
        description="Return a PNG screenshot, HTML content, or the resulting URL after interactions.",
    )
    viewport: Optional[Viewport] = None
    scrollX: Optional[int] = None
    scrollY: Optional[int] = None
    interactions: List[Interaction]

@router.get(
    "/",
    summary="Visit URL",
    description="Navigate to `url` and return HTML content (cached unless `skipCache=true`).",
)
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(
    "/screenshot",
    summary="Capture screenshot",
    description="Capture a PNG screenshot for `url`.",
    responses={
        200: {"content": {"image/png": {}}},
        401: {"description": "Invalid API key"},
        500: {"description": "Screenshot capture failed"},
    },
)
async def screenshot_url(url: str, fullPage: bool = True, x_api_key: Optional[str] = Header(None)):
    """Capture a screenshot of a website and return it as PNG"""
    if not x_api_key or x_api_key != API_KEY:
        raise HTTPException(status_code=401, detail="Invalid API key")

    decoded_url = unquote(url)

    try:
        result = await screenshot_url_service(decoded_url, fullPage)

        if isinstance(result, dict) and result.get("status") == "error":
            raise HTTPException(status_code=500, detail=result.get("error", "Screenshot capture failed"))

        if not isinstance(result, (bytes, bytearray)):
            raise HTTPException(status_code=500, detail="Unexpected screenshot response")

        return Response(content=result, media_type="image/png")
    except HTTPException:
        raise
    except Exception as e:
        print(f"Error taking screenshot for URL {decoded_url}: {e}")
        raise HTTPException(status_code=500, detail=str(e))

@router.post(
    "/interactions",
    summary="Run interactions",
    description=(
        "Run a sequence of interactions (click/type) on a page.\n\n"
        "- `returnType=screenshot` returns `image/png`\n"
        "- `returnType=html` returns `text/html`\n"
        "- `returnType=resulting_url` returns `application/json` with the final URL"
    ),
    responses={
        200: {
            "content": {
                "image/png": {},
                "text/html": {},
                "application/json": {},
            }
        },
        401: {"description": "Invalid API key"},
        500: {"description": "Interaction failed"},
    },
)
async def run_interactions(payload: InteractionsRequest, x_api_key: Optional[str] = Header(None)):
    if not x_api_key or x_api_key != API_KEY:
        raise HTTPException(status_code=401, detail="Invalid API key")

    decoded_url = unquote(payload.url)
    return_type = (payload.returnType or "screenshot").lower()

    try:
        result = await interactions_service(
            decoded_url,
            payload.interactions,
            return_type,
            viewport=payload.viewport,
            scroll_x=payload.scrollX,
            scroll_y=payload.scrollY,
        )

        if isinstance(result, dict) and result.get("status") == "error":
            raise HTTPException(status_code=500, detail=result.get("error", "Interaction failed"))

        if return_type == "resulting_url":
            if not isinstance(result, dict):
                raise HTTPException(status_code=500, detail="Unexpected resulting_url response")
            return result

        if return_type == "html":
            if not isinstance(result, str):
                raise HTTPException(status_code=500, detail="Unexpected HTML response")
            return Response(content=result, media_type="text/html; charset=utf-8")

        if not isinstance(result, (bytes, bytearray)):
            raise HTTPException(status_code=500, detail="Unexpected screenshot response")
        return Response(content=result, media_type="image/png")
    except HTTPException:
        raise
    except Exception as e:
        print(f"Error running interactions on URL {decoded_url}: {e}")
        raise HTTPException(status_code=500, detail=str(e))

@router.get(
    "/seo",
    summary="Extract SEO information",
    description="Extract SEO information from `url` (cached unless `skipCache=true`).",
)
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",
    summary="Extract meta tags",
    description="Extract meta tags / Open Graph / Twitter card data from `url` (cached unless `skipCache=true`).",
)
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",
    summary="Capture outgoing calls",
    description="Capture outgoing API calls from `url` (cached unless `skipCache=true`).",
)
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",
    summary="Get resulting URL",
    description="Get the final URL after navigation/redirects for `url` (cached unless `skipCache=true`).",
)
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))