import json
import logging
import os
import time
from typing import Dict, List, Optional
from urllib.parse import urlencode, quote

import aiohttp
from dotenv import load_dotenv
from fastapi import FastAPI, HTTPException, Request
from fastapi.responses import JSONResponse, Response
from pydantic import BaseModel

load_dotenv()

# Configure logging
logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s - %(levelname)s - %(message)s",
    datefmt="%Y-%m-%d %H:%M:%S",
)
logger = logging.getLogger(__name__)

app = FastAPI()

logger.info("FastAPI Proxy Server initialized")

SCRAPINGBEE_API_KEY = os.getenv("SCRAPINGBEE_API_KEY")
if not SCRAPINGBEE_API_KEY:
    raise ValueError("SCRAPINGBEE_API_KEY is not set")


CONSTANTS = {
    "SESSION_KEY_NAME": "SID",
    "SESSION_EXPIRE_TIME_MS": 6 * 60 * 60 * 1000,
    "POST_SESSION_KEY": "postsession",
    "LAST_FETCHED_KEY": "LAST_FETCHED",
    "SCRAP_API_URL": "https://gamebooking24.com/lottery-api",
    "SCRAP_API_SESSION_KEY": "SRAJWT",
    "SCRAPINGBEE_BASE_URL": "https://app.scrapingbee.com/api/v1",
    "SCRAP_API_BASE_HEADERS": {
        "Host": "gamebooking24.com",
        "Sec-Ch-Ua": '"Not/A)Brand";v="8", "Chromium";v="126"',
        "Sec-Ch-Ua-Mobile": "?0",
        "Sec-Fetch-Site": "cross-site",
        "Sec-Fetch-Mode": "no-cors",
        "Sec-Fetch-Dest": "image",
        "Accept-Encoding": "gzip, deflate",
        "Accept-Language": "en-US,en;q=0.9",
        "Access-Control-Allow-Origin": "*",
        "Accept": "application/json, text/plain, */*",
        "Origin": "https://gamebooking24.com",
        "Referer": "https://gamebooking24.com/",
        "Priority": "u=1, i",
    },
}


# Middleware for logging all requests
@app.middleware("http")
async def log_requests(request: Request, call_next):
    start_time = time.time()

    # Log incoming request
    logger.info(f"→ {request.method} {request.url.path}")
    if request.query_params:
        logger.debug(f"  Query params: {dict(request.query_params)}")

    # Process request
    response = await call_next(request)

    # Log response
    duration = (time.time() - start_time) * 1000
    logger.info(
        f"← {request.method} {request.url.path} [{response.status_code}] ({duration:.2f}ms)"
    )

    return response


def build_headers(
    authorization: Optional[str] = None, extra_headers: Optional[Dict[str, str]] = None
) -> Dict[str, str]:
    """Build headers dict for requests"""
    headers = CONSTANTS["SCRAP_API_BASE_HEADERS"].copy()

    if authorization:
        headers["Authorization"] = authorization

    if extra_headers:
        headers.update(extra_headers)

    return headers


async def make_get_request(
    url: str, params: Optional[Dict] = None, headers: Optional[Dict] = None
):
    """Make a GET request using ScrapingBee"""
    # Add query params to the target URL if provided
    if params:
        url_with_params = f"{url}?{urlencode(params)}"
    else:
        url_with_params = url

    logger.debug(f"[ScrapingBee GET] Target URL: {url_with_params}")

    # Build the ScrapingBee request params
    # Note: aiohttp will automatically URL-encode the params, including the 'url' value
    scrapingbee_params = {
        "api_key": SCRAPINGBEE_API_KEY,
        "url": url_with_params,
        "render_js": "true",
        "block_resources": "false",
        "transparent_status_code": "true",  # Pass through the actual status code from target site
    }
    
    # Forward headers to target site if provided (for Authorization, etc.)
    if headers and "Authorization" in headers:
        scrapingbee_params["forward_headers"] = "true"

    # Make the request to ScrapingBee using aiohttp
    # Note: Don't pass custom headers to ScrapingBee - they're for the target site
    # If needed, use ScrapingBee's forward_headers parameter instead
    async with aiohttp.ClientSession() as session:
        async with session.get(
            CONSTANTS["SCRAPINGBEE_BASE_URL"],
            params=scrapingbee_params,
            timeout=aiohttp.ClientTimeout(total=60),
        ) as response:
            # Read content before context manager exits
            content = await response.read()
            
            # Log error responses for debugging
            if response.status != 200:
                try:
                    error_text = content.decode('utf-8')[:500]
                    logger.error(f"[ScrapingBee GET] Status {response.status}, Response: {error_text}")
                except:
                    logger.error(f"[ScrapingBee GET] Status {response.status}, Response (non-text): {len(content)} bytes")
            
            # Create a simple response object with the data
            class SimpleResponse:
                def __init__(self, status, headers, content_bytes):
                    self.status_code = status
                    self.headers = headers
                    self._content = content_bytes
                    self._text = None
                    self._json = None

                async def text(self):
                    if self._text is None:
                        self._text = self._content.decode('utf-8')
                    return self._text

                async def json(self):
                    if self._json is None:
                        self._json = json.loads(await self.text())
                    return self._json

                async def content(self):
                    return self._content

            return SimpleResponse(response.status, response.headers, content)


async def make_post_request(url: str, data: dict, headers: Optional[Dict] = None):
    """Make a POST request using ScrapingBee"""

    # Build the ScrapingBee request params
    scrapingbee_params = {
        "api_key": SCRAPINGBEE_API_KEY,
        "url": url,
        "render_js": "true",
        "block_resources": "false",
    }

    # ScrapingBee POST requests: pass JSON body as a parameter
    scrapingbee_params["body"] = json.dumps(data)
    
    # Forward headers to target site if provided
    # Note: ScrapingBee's forward_headers forwards common headers automatically
    # For custom headers like Authorization, we may need to use cookies parameter
    if headers and "Authorization" in headers:
        scrapingbee_params["forward_headers"] = "true"
        # TODO: May need to pass Authorization via cookies if forward_headers doesn't work
    
    # Make the POST request to ScrapingBee using aiohttp
    # ScrapingBee HTML API uses GET even for POST requests - the body is passed as a param
    async with aiohttp.ClientSession() as session:
        async with session.get(
            CONSTANTS["SCRAPINGBEE_BASE_URL"],
            params=scrapingbee_params,
            timeout=aiohttp.ClientTimeout(total=60),
        ) as response:
            # Read content before context manager exits
            content = await response.read()
            
            # Create a simple response object with the data
            class SimpleResponse:
                def __init__(self, status, headers, content_bytes):
                    self.status_code = status
                    self.headers = headers
                    self._content = content_bytes
                    self._text = None
                    self._json = None

                async def text(self):
                    if self._text is None:
                        self._text = self._content.decode('utf-8')
                    return self._text

                async def json(self):
                    if self._json is None:
                        self._json = json.loads(await self.text())
                    return self._json

                async def content(self):
                    return self._content

            return SimpleResponse(response.status, response.headers, content)


# Pydantic models for request bodies
class LoginPayload(BaseModel):
    userId: str
    password: str
    verifyToken: str
    code: str
    userType: int


class DealerListPayload(BaseModel):
    page: int
    pageSize: int
    parentDistributor: int


class DistributorListPayload(BaseModel):
    page: int
    pageSize: int
    parentDistributor: int


class BookListPayload(BaseModel):
    userType: int
    userIds: List[int]
    drawId: int
    startDate: str
    endDate: str
    beAdmin: bool
    containImported: bool
    keyword: str


class AddMultiplePayload(BaseModel):
    dealerId: int
    drawId: int
    closeTime: str
    date: str
    changedBalance: int
    insertData: str


class DeleteMultiplePayload(BaseModel):
    bookIds: List[str]
    closeTime: str
    dealerId: int
    drawId: int


@app.get("/ping")
def ping():
    logger.info("Ping request received")
    return {"status": "pong"}


@app.get("/v1/user/get-balance")
async def get_balance(userId: int, authorization: str):
    logger.info(f"[GET /v1/user/get-balance] userId={userId}")
    try:
        headers = build_headers(authorization=authorization)
        response = await make_get_request(
            f"{CONSTANTS['SCRAP_API_URL']}/v1/user/get-balance",
            params={"userId": userId},
            headers=headers,
        )
        logger.info(f"[GET /v1/user/get-balance] Response: {response.status_code}")
        return JSONResponse(
            content=await response.json(), status_code=response.status_code
        )
    except Exception as e:
        logger.error(f"[GET /v1/user/get-balance] Error: {str(e)}")
        raise HTTPException(status_code=500, detail=str(e))


@app.post("/v1/auth/login")
async def login(payload: LoginPayload):
    logger.info(f"[POST /v1/auth/login] - payload={payload.model_dump()}")
    try:
        headers = build_headers(extra_headers={"Content-Type": "application/json"})
        response = await make_post_request(
            f"{CONSTANTS['SCRAP_API_URL']}/v1/auth/login",
            data=payload.model_dump(),
            headers=headers,
        )
        logger.info(f"[POST /v1/auth/login] Response: {response.status_code}")

        # Handle non-JSON responses (e.g., 403 HTML pages)
        if response.status_code == 403:
            response_text = await response.text()
            logger.error(
                f"[POST /v1/auth/login] 403 Forbidden - Response: {response_text[:500]}"
            )
            raise HTTPException(status_code=403, detail="Request blocked")

        # Try to parse as JSON
        try:
            response_json = await response.json()
        except Exception as json_error:
            response_text = await response.text()
            logger.error(
                f"[POST /v1/auth/login] Failed to parse JSON response: {json_error}"
            )
            logger.error(f"[POST /v1/auth/login] Response text: {response_text[:500]}")
            raise HTTPException(
                status_code=500, detail=f"Invalid JSON response: {str(json_error)}"
            )

        return JSONResponse(content=response_json, status_code=response.status_code)
    except HTTPException:
        raise
    except Exception as e:
        logger.error(f"[POST /v1/auth/login] Error: {str(e)}")
        raise HTTPException(status_code=500, detail=str(e))


@app.get("/verify/image")
async def get_captcha(uuid: str):
    logger.info(f"[GET /verify/image] uuid={uuid}")
    try:
        headers = build_headers(
            extra_headers={
                "Accept": "image/avif,image/webp,image/apng,image/svg+xml,image/*,*/*;q=0.8"
            }
        )
        response = await make_get_request(
            f"{CONSTANTS['SCRAP_API_URL']}/verify/image",
            params={"uuid": uuid},
            headers=headers,
        )

        if response.status_code == 403:
            logger.error("[GET /verify/image] 403 Forbidden - Request blocked")
            logger.error(
                f"[GET /verify/image] Response headers: {dict(response.headers)}"
            )
            response_text = await response.text()
            logger.error(f"[GET /verify/image] Response text: {response_text[:500]}")

        content = await response.content()
        logger.info(
            f"[GET /verify/image] Response: {response.status_code}, size={len(content)} bytes"
        )
        return Response(
            content=content,
            media_type="image/png",
            status_code=response.status_code,
        )
    except Exception as e:
        logger.error(f"[GET /verify/image] Error: {str(e)}")
        raise HTTPException(status_code=500, detail=str(e))


@app.post("/v1/user/dealer-list")
async def dealer_list(payload: DealerListPayload, authorization: str):
    logger.info(
        f"[POST /v1/user/dealer-list] parentDistributor={payload.parentDistributor}, page={payload.page}, pageSize={payload.pageSize}"
    )
    try:
        headers = build_headers(
            authorization=authorization,
            extra_headers={"Content-Type": "application/json"},
        )
        response = await make_post_request(
            f"{CONSTANTS['SCRAP_API_URL']}/v1/user/dealer-list",
            data=payload.model_dump(),
            headers=headers,
        )
        logger.info(f"[POST /v1/user/dealer-list] Response: {response.status_code}")
        return JSONResponse(
            content=await response.json(), status_code=response.status_code
        )
    except Exception as e:
        logger.error(f"[POST /v1/user/dealer-list] Error: {str(e)}")
        raise HTTPException(status_code=500, detail=str(e))


@app.post("/v1/user/distributor-list")
async def distributor_list(payload: DistributorListPayload, authorization: str):
    logger.info(
        f"[POST /v1/user/distributor-list] parentDistributor={payload.parentDistributor}, page={payload.page}, pageSize={payload.pageSize}"
    )
    try:
        headers = build_headers(
            authorization=authorization,
            extra_headers={"Content-Type": "application/json"},
        )
        response = await make_post_request(
            f"{CONSTANTS['SCRAP_API_URL']}/v1/user/distributor-list",
            data=payload.model_dump(),
            headers=headers,
        )
        logger.info(
            f"[POST /v1/user/distributor-list] Response: {response.status_code}"
        )
        return JSONResponse(
            content=await response.json(), status_code=response.status_code
        )
    except Exception as e:
        logger.error(f"[POST /v1/user/distributor-list] Error: {str(e)}")
        raise HTTPException(status_code=500, detail=str(e))


@app.get("/v1/draw/list-my")
async def list_draws(userId: int, authorization: str):
    logger.info(f"[GET /v1/draw/list-my] userId={userId}")
    try:
        headers = build_headers(
            authorization=authorization,
            extra_headers={"Content-Type": "application/json"},
        )
        response = await make_get_request(
            f"{CONSTANTS['SCRAP_API_URL']}/v1/draw/list-my",
            params={"userId": userId},
            headers=headers,
        )
        logger.info(f"[GET /v1/draw/list-my] Response: {response.status_code}")
        return JSONResponse(
            content=await response.json(), status_code=response.status_code
        )
    except Exception as e:
        logger.error(f"[GET /v1/draw/list-my] Error: {str(e)}")
        raise HTTPException(status_code=500, detail=str(e))


@app.post("/v1/book/list2")
async def book_list(payload: BookListPayload, authorization: str):
    logger.info(
        f"[POST /v1/book/list2] drawId={payload.drawId}, userIds={len(payload.userIds)}, date={payload.startDate}"
    )
    try:
        headers = build_headers(
            authorization=authorization,
            extra_headers={"Content-Type": "application/json"},
        )
        response = await make_post_request(
            f"{CONSTANTS['SCRAP_API_URL']}/v1/book/list2",
            data=payload.model_dump(),
            headers=headers,
        )
        logger.info(f"[POST /v1/book/list2] Response: {response.status_code}")
        return JSONResponse(
            content=await response.json(), status_code=response.status_code
        )
    except Exception as e:
        logger.error(f"[POST /v1/book/list2] Error: {str(e)}")
        raise HTTPException(status_code=500, detail=str(e))


@app.post("/v1/book/add-multiple")
async def add_multiple(payload: AddMultiplePayload, authorization: str):
    entries_count = len(payload.insertData.split(";")) if payload.insertData else 0
    logger.info(
        f"[POST /v1/book/add-multiple] dealerId={payload.dealerId}, drawId={payload.drawId}, entries={entries_count}, balance={payload.changedBalance}"
    )
    try:
        headers = build_headers(
            authorization=authorization,
            extra_headers={"Content-Type": "application/json;charset=UTF-8"},
        )
        response = await make_post_request(
            f"{CONSTANTS['SCRAP_API_URL']}/v1/book/add-multiple",
            data=payload.model_dump(),
            headers=headers,
        )
        logger.info(f"[POST /v1/book/add-multiple] Response: {response.status_code}")
        return JSONResponse(
            content=await response.json(), status_code=response.status_code
        )
    except Exception as e:
        logger.error(f"[POST /v1/book/add-multiple] Error: {str(e)}")
        raise HTTPException(status_code=500, detail=str(e))


@app.post("/v1/book/delete-multiple")
async def delete_multiple(payload: DeleteMultiplePayload, authorization: str):
    logger.info(
        f"[POST /v1/book/delete-multiple] dealerId={payload.dealerId}, drawId={payload.drawId}, bookIds={len(payload.bookIds)}"
    )
    try:
        headers = build_headers(
            authorization=authorization,
            extra_headers={"Content-Type": "application/json;charset=UTF-8"},
        )
        response = await make_post_request(
            f"{CONSTANTS['SCRAP_API_URL']}/v1/book/delete-multiple",
            data=payload.model_dump(),
            headers=headers,
        )
        logger.info(f"[POST /v1/book/delete-multiple] Response: {response.status_code}")
        return JSONResponse(
            content=await response.json(), status_code=response.status_code
        )
    except Exception as e:
        logger.error(f"[POST /v1/book/delete-multiple] Error: {str(e)}")
        raise HTTPException(status_code=500, detail=str(e))