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

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")

SCRAPERAPI_API_KEY = os.getenv("SCRAPERAPI_API_KEY")
if not SCRAPERAPI_API_KEY:
    raise ValueError("SCRAPERAPI_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",
    "SCRAPERAPI_BASE_URL": "http://api.scraperapi.com",
    "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 ScraperAPI"""
    if SCRAPERAPI_API_KEY == "<TODO: get and put the key in here>":
        raise HTTPException(status_code=500, detail="ScraperAPI API key not configured")

    # Build the ScraperAPI request params
    scraperapi_params = {
        "api_key": SCRAPERAPI_API_KEY,
        "url": url,
        "render": "true",
    }

    # Add query params to the target URL if provided
    if params:
        url_with_params = f"{url}?{urlencode(params)}"
        scraperapi_params["url"] = url_with_params

    # Make the request to ScraperAPI using aiohttp
    async with aiohttp.ClientSession() as session:
        async with session.get(
            CONSTANTS["SCRAPERAPI_BASE_URL"],
            params=scraperapi_params,
            headers=headers,
            timeout=aiohttp.ClientTimeout(total=60),
        ) as response:
            # Create a simple response-like object
            class AsyncResponse:
                def __init__(self, aiohttp_response):
                    self._response = aiohttp_response
                    self.status_code = aiohttp_response.status
                    self.headers = aiohttp_response.headers
                    self._text = None
                    self._json = None
                    self._content = None

                async def text(self):
                    if self._text is None:
                        self._text = await self._response.text()
                    return self._text

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

                async def content(self):
                    if self._content is None:
                        self._content = await self._response.read()
                    return self._content

            return AsyncResponse(response)


async def make_post_request(url: str, data: dict, headers: Optional[Dict] = None):
    """Make a POST request using ScraperAPI"""
    if SCRAPERAPI_API_KEY == "<TODO: get and put the key in here>":
        raise HTTPException(status_code=500, detail="ScraperAPI API key not configured")

    # Build the ScraperAPI request params
    scraperapi_params = {
        "api_key": SCRAPERAPI_API_KEY,
        "url": url,
        "render": "true",
    }

    # Make the POST request to ScraperAPI using aiohttp
    async with aiohttp.ClientSession() as session:
        async with session.post(
            CONSTANTS["SCRAPERAPI_BASE_URL"],
            params=scraperapi_params,
            json=data,  # Use json= for JSON payloads (sets Content-Type automatically)
            headers=headers,
            timeout=aiohttp.ClientTimeout(total=60),
        ) as response:
            # Create a simple response-like object
            class AsyncResponse:
                def __init__(self, aiohttp_response):
                    self._response = aiohttp_response
                    self.status_code = aiohttp_response.status
                    self.headers = aiohttp_response.headers
                    self._text = None
                    self._json = None
                    self._content = None

                async def text(self):
                    if self._text is None:
                        self._text = await self._response.text()
                    return self._text

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

                async def content(self):
                    if self._content is None:
                        self._content = await self._response.read()
                    return self._content

            return AsyncResponse(response)


# 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))