import json
import logging
import math
import traceback
from typing import Optional, Dict, Any, List

from fastapi import APIRouter, Depends, Request
from pydantic import BaseModel, ValidationError
from sqlalchemy import and_, or_, select, func
from sqlalchemy.ext.asyncio import AsyncSession

from app.db.session import get_db
from app.models.category import Category
from app.models.generated_tattoo_history import GeneratedTattooHistory
from app.core.security import validate_token
from app.api.v1.crypto_api import decrypt_data
from app.utils.responses import custom_response
from app.core.logging import logger
from app.models.tattoo_style import TattooStyle
from app.models.category import Category
router = APIRouter()

# ---------- Get Dashboard Data (GET with query params and Bearer Token) ----------
@router.get("/category_icon")
async def get_category_icon(
    request: Request,
    db: AsyncSession = Depends(get_db),
    token_data: dict = Depends(validate_token)
):
    """
    Get dashboard data (categories and optionally user history) based on the token.
    Uses default pagination and extracts user info from the token.
    """
    logger.info("Received request for /dashboard endpoint.")
    try:
        # Step 1: Authorization check
        if token_data.get('code') != 200:
            logger.warning(f"Unauthorized access attempt to /dashboard. Message: {token_data.get('message', 'N/A')}")
            return custom_response(code=token_data.get('code', 500), message=token_data.get('message', 'Unauthorized'))

        # Get user info from the token data
        user_id = token_data.get('user_id')
        user_device_id = token_data.get('user_device_id')
        
        logger.info(f"Processing dashboard data request for user_id: {user_id}, user_device_id: {user_device_id}")
        
        dashboard_data: Dict[str, List[Dict[str, Any]]] = {}
        
        # Step 2: Fetch category data
        logger.info("Fetching category data for the dashboard.")
        category_conditions = [
            Category.is_active.is_(True)
        ]

        category_stmt = (
            select(Category)
            .where(and_(*category_conditions))
            .order_by(Category.name.asc())
        )
        
        category_result = await db.execute(category_stmt)
        category_rows = category_result.scalars().all()
        
        categories_list = [
            {
                "category_id": c.category_id,
                "name": c.name,
                "description": c.description,
                "icon_url": c.icon_url,
                "thumbnail_url": c.thumbnail_url,
                "is_active": c.is_active,
                "sort_order": c.sort_order
            }
            for c in category_rows
        ]

        dashboard_data["categories"] = categories_list
        return custom_response(200, data=dashboard_data, message="Success")

    except Exception as e:
        logger.error(f"Internal server error in /dashboard: {str(e)}", exc_info=True)
        return custom_response(code=500, message=f"Internal server error: {str(e)}")