from fastapi import APIRouter, Depends, HTTPException, Query
from typing import List, Optional, Dict, Any
import logging
from datetime import datetime, timedelta
from pydantic import BaseModel, Field
from playhouse.shortcuts import model_to_dict
from peewee import fn

from ..dependencies import oauth2_scheme, valid_token, PRIVATE_IN_SCHEMA, handle_db_errors
from ..db_engine import db, HelpCommand

logger = logging.getLogger('database_api')

router = APIRouter(
    prefix='/api/v3/help_commands',
    tags=['help_commands']
)


# Pydantic Models for API
class HelpCommandModel(BaseModel):
    id: Optional[int] = None
    name: str = Field(..., min_length=2, max_length=32)
    title: str = Field(..., min_length=1, max_length=200)
    content: str = Field(..., min_length=1, max_length=4000)
    category: Optional[str] = Field(None, max_length=50)
    created_by_discord_id: str  # Text to safely store Discord snowflake IDs
    created_at: Optional[str] = None
    updated_at: Optional[str] = None
    last_modified_by: Optional[str] = None  # Text to safely store Discord snowflake IDs
    is_active: bool = True
    view_count: int = 0
    display_order: int = 0


class HelpCommandListResponse(BaseModel):
    help_commands: List[HelpCommandModel]
    total_count: int
    page: int
    page_size: int
    total_pages: int
    has_more: bool


class HelpCommandStatsResponse(BaseModel):
    total_commands: int
    active_commands: int
    total_views: int
    most_viewed_command: Optional[Dict[str, Any]] = None
    recent_commands_count: int = 0


# API Endpoints

@router.get('')
@handle_db_errors
async def get_help_commands(
    name: Optional[str] = None,
    category: Optional[str] = None,
    is_active: Optional[bool] = True,
    sort: Optional[str] = 'name',
    page: int = Query(1, ge=1),
    page_size: int = Query(25, ge=1, le=100)
):
    """Get help commands with filtering and pagination"""
    try:
        # Build query
        query = HelpCommand.select()

        # Apply filters
        if name is not None:
            query = query.where(fn.Lower(HelpCommand.name).contains(name.lower()))

        if category is not None:
            query = query.where(fn.Lower(HelpCommand.category) == category.lower())

        if is_active is not None:
            query = query.where(HelpCommand.is_active == is_active)

        # Get total count before pagination
        total_count = query.count()

        # Apply sorting
        sort_mapping = {
            'name': HelpCommand.name,
            'title': HelpCommand.title,
            'category': HelpCommand.category,
            'created_at': HelpCommand.created_at,
            'updated_at': HelpCommand.updated_at,
            'view_count': HelpCommand.view_count,
            'display_order': HelpCommand.display_order
        }

        if sort.startswith('-'):
            sort_field = sort[1:]
            order_by = sort_mapping.get(sort_field, HelpCommand.name).desc()
        else:
            order_by = sort_mapping.get(sort, HelpCommand.name).asc()

        query = query.order_by(order_by)

        # Calculate pagination
        offset = (page - 1) * page_size
        total_pages = (total_count + page_size - 1) // page_size

        # Apply pagination
        query = query.limit(page_size).offset(offset)

        # Convert to dictionaries
        commands = []
        for help_cmd in query:
            cmd_dict = model_to_dict(help_cmd)
            # Convert datetime objects to ISO strings
            if cmd_dict.get('created_at'):
                cmd_dict['created_at'] = cmd_dict['created_at'].isoformat()
            if cmd_dict.get('updated_at'):
                cmd_dict['updated_at'] = cmd_dict['updated_at'].isoformat()

            try:
                command_model = HelpCommandModel(**cmd_dict)
                commands.append(command_model)
            except Exception as e:
                logger.error(f"Error creating HelpCommandModel: {e}, data: {cmd_dict}")
                continue

        return HelpCommandListResponse(
            help_commands=commands,
            total_count=total_count,
            page=page,
            page_size=page_size,
            total_pages=total_pages,
            has_more=page < total_pages
        )

    except Exception as e:
        logger.error(f"Error getting help commands: {e}")
        raise HTTPException(status_code=500, detail=str(e))
    finally:
        db.close()


@router.post('', include_in_schema=PRIVATE_IN_SCHEMA)
@handle_db_errors
async def create_help_command_endpoint(
    command: HelpCommandModel,
    token: str = Depends(oauth2_scheme)
):
    """Create a new help command"""
    if not valid_token(token):
        logger.warning(f'create_help_command - Bad Token: {token}')
        raise HTTPException(status_code=401, detail='Unauthorized')

    try:
        # Check if command name already exists
        existing = HelpCommand.get_by_name(command.name)
        if existing:
            raise HTTPException(status_code=409, detail=f"Help topic '{command.name}' already exists")

        # Create the command
        help_cmd = HelpCommand.create(
            name=command.name.lower(),
            title=command.title,
            content=command.content,
            category=command.category.lower() if command.category else None,
            created_by_discord_id=command.created_by_discord_id,
            created_at=datetime.now(),
            is_active=True,
            view_count=0,
            display_order=command.display_order
        )

        # Return the created command
        result = model_to_dict(help_cmd)
        if result.get('created_at'):
            result['created_at'] = result['created_at'].isoformat()
        if result.get('updated_at'):
            result['updated_at'] = result['updated_at'].isoformat()

        return result

    except HTTPException:
        raise
    except Exception as e:
        logger.error(f"Error creating help command: {e}")
        raise HTTPException(status_code=500, detail=str(e))
    finally:
        db.close()


@router.put('/{command_id}', include_in_schema=PRIVATE_IN_SCHEMA)
@handle_db_errors
async def update_help_command_endpoint(
    command_id: int,
    command: HelpCommandModel,
    token: str = Depends(oauth2_scheme)
):
    """Update an existing help command"""
    if not valid_token(token):
        logger.warning(f'update_help_command - Bad Token: {token}')
        raise HTTPException(status_code=401, detail='Unauthorized')

    try:
        # Get the command
        help_cmd = HelpCommand.get_or_none(HelpCommand.id == command_id)
        if not help_cmd:
            raise HTTPException(status_code=404, detail=f"Help command {command_id} not found")

        # Update fields
        if command.title:
            help_cmd.title = command.title
        if command.content:
            help_cmd.content = command.content
        if command.category is not None:
            help_cmd.category = command.category.lower() if command.category else None
        if command.last_modified_by:
            help_cmd.last_modified_by = command.last_modified_by
        if command.display_order is not None:
            help_cmd.display_order = command.display_order

        help_cmd.updated_at = datetime.now()
        help_cmd.save()

        # Return updated command
        result = model_to_dict(help_cmd)
        if result.get('created_at'):
            result['created_at'] = result['created_at'].isoformat()
        if result.get('updated_at'):
            result['updated_at'] = result['updated_at'].isoformat()

        return result

    except HTTPException:
        raise
    except Exception as e:
        logger.error(f"Error updating help command {command_id}: {e}")
        raise HTTPException(status_code=500, detail=str(e))
    finally:
        db.close()


@router.patch('/{command_id}/restore', include_in_schema=PRIVATE_IN_SCHEMA)
@handle_db_errors
async def restore_help_command_endpoint(
    command_id: int,
    token: str = Depends(oauth2_scheme)
):
    """Restore a soft-deleted help command"""
    if not valid_token(token):
        logger.warning(f'restore_help_command - Bad Token: {token}')
        raise HTTPException(status_code=401, detail='Unauthorized')

    try:
        # Get the command
        help_cmd = HelpCommand.get_or_none(HelpCommand.id == command_id)
        if not help_cmd:
            raise HTTPException(status_code=404, detail=f"Help command {command_id} not found")

        # Restore the command
        help_cmd.restore()

        # Return restored command
        result = model_to_dict(help_cmd)
        if result.get('created_at'):
            result['created_at'] = result['created_at'].isoformat()
        if result.get('updated_at'):
            result['updated_at'] = result['updated_at'].isoformat()

        return result

    except HTTPException:
        raise
    except Exception as e:
        logger.error(f"Error restoring help command {command_id}: {e}")
        raise HTTPException(status_code=500, detail=str(e))
    finally:
        db.close()


@router.delete('/{command_id}', include_in_schema=PRIVATE_IN_SCHEMA)
@handle_db_errors
async def delete_help_command_endpoint(
    command_id: int,
    token: str = Depends(oauth2_scheme)
):
    """Soft delete a help command"""
    if not valid_token(token):
        logger.warning(f'delete_help_command - Bad Token: {token}')
        raise HTTPException(status_code=401, detail='Unauthorized')

    try:
        # Get the command
        help_cmd = HelpCommand.get_or_none(HelpCommand.id == command_id)
        if not help_cmd:
            raise HTTPException(status_code=404, detail=f"Help command {command_id} not found")

        # Soft delete the command
        help_cmd.soft_delete()

        return {"message": f"Help command {command_id} deleted successfully"}

    except HTTPException:
        raise
    except Exception as e:
        logger.error(f"Error deleting help command {command_id}: {e}")
        raise HTTPException(status_code=500, detail=str(e))
    finally:
        db.close()


@router.get('/stats')
@handle_db_errors
async def get_help_command_stats():
    """Get comprehensive statistics about help commands"""
    try:
        # Get basic counts
        total_commands = HelpCommand.select().count()
        active_commands = HelpCommand.select().where(HelpCommand.is_active == True).count()

        # Get total views
        total_views = HelpCommand.select(fn.SUM(HelpCommand.view_count)).where(
            HelpCommand.is_active == True
        ).scalar() or 0

        # Get most viewed command
        most_viewed = HelpCommand.get_most_viewed(limit=1).first()
        most_viewed_command = None
        if most_viewed:
            most_viewed_dict = model_to_dict(most_viewed)
            if most_viewed_dict.get('created_at'):
                most_viewed_dict['created_at'] = most_viewed_dict['created_at'].isoformat()
            if most_viewed_dict.get('updated_at'):
                most_viewed_dict['updated_at'] = most_viewed_dict['updated_at'].isoformat()
            most_viewed_command = most_viewed_dict

        # Get recent commands count (last 7 days)
        week_ago = datetime.now() - timedelta(days=7)
        recent_count = HelpCommand.select().where(
            (HelpCommand.created_at >= week_ago) &
            (HelpCommand.is_active == True)
        ).count()

        return HelpCommandStatsResponse(
            total_commands=total_commands,
            active_commands=active_commands,
            total_views=int(total_views),
            most_viewed_command=most_viewed_command,
            recent_commands_count=recent_count
        )

    except Exception as e:
        logger.error(f"Error getting help command stats: {e}")
        raise HTTPException(status_code=500, detail=str(e))
    finally:
        db.close()


# Special endpoints for Discord bot integration
@router.get('/by_name/{command_name}')
@handle_db_errors
async def get_help_command_by_name_endpoint(
    command_name: str,
    include_inactive: bool = Query(False)
):
    """Get a help command by name (for Discord bot)"""
    try:
        help_cmd = HelpCommand.get_by_name(command_name, include_inactive=include_inactive)

        if not help_cmd:
            raise HTTPException(status_code=404, detail=f"Help topic '{command_name}' not found")

        result = model_to_dict(help_cmd)
        if result.get('created_at'):
            result['created_at'] = result['created_at'].isoformat()
        if result.get('updated_at'):
            result['updated_at'] = result['updated_at'].isoformat()

        return result

    except HTTPException:
        raise
    except Exception as e:
        logger.error(f"Error getting help command by name '{command_name}': {e}")
        raise HTTPException(status_code=500, detail=str(e))
    finally:
        db.close()


@router.patch('/by_name/{command_name}/view', include_in_schema=PRIVATE_IN_SCHEMA)
@handle_db_errors
async def increment_view_count(
    command_name: str,
    token: str = Depends(oauth2_scheme)
):
    """Increment view count for a help command"""
    if not valid_token(token):
        logger.warning(f'increment_view_count - Bad Token: {token}')
        raise HTTPException(status_code=401, detail='Unauthorized')

    try:
        help_cmd = HelpCommand.get_by_name(command_name)

        if not help_cmd:
            raise HTTPException(status_code=404, detail=f"Help topic '{command_name}' not found")

        # Increment view count
        help_cmd.increment_view_count()

        # Return updated command
        result = model_to_dict(help_cmd)
        if result.get('created_at'):
            result['created_at'] = result['created_at'].isoformat()
        if result.get('updated_at'):
            result['updated_at'] = result['updated_at'].isoformat()

        return result

    except HTTPException:
        raise
    except Exception as e:
        logger.error(f"Error incrementing view count for '{command_name}': {e}")
        raise HTTPException(status_code=500, detail=str(e))
    finally:
        db.close()


@router.get('/autocomplete')
@handle_db_errors
async def get_help_names_for_autocomplete(
    q: str = Query(""),
    limit: int = Query(25, ge=1, le=100)
):
    """Get help command names for Discord autocomplete"""
    try:
        if q:
            results = HelpCommand.search_by_name(q, limit=limit)
        else:
            results = HelpCommand.get_all_active().limit(limit)

        # Return list of dictionaries with name, title, category
        return {
            'results': [
                {
                    'name': help_cmd.name,
                    'title': help_cmd.title,
                    'category': help_cmd.category
                }
                for help_cmd in results
            ]
        }

    except Exception as e:
        logger.error(f"Error getting help names for autocomplete: {e}")
        raise HTTPException(status_code=500, detail=str(e))
    finally:
        db.close()


@router.get('/{command_id}')
@handle_db_errors
async def get_help_command(command_id: int):
    """Get a single help command by ID"""
    try:
        help_cmd = HelpCommand.get_or_none(HelpCommand.id == command_id)

        if not help_cmd:
            raise HTTPException(status_code=404, detail=f"Help command {command_id} not found")

        result = model_to_dict(help_cmd)
        if result.get('created_at'):
            result['created_at'] = result['created_at'].isoformat()
        if result.get('updated_at'):
            result['updated_at'] = result['updated_at'].isoformat()

        return result

    except HTTPException:
        raise
    except Exception as e:
        logger.error(f"Error getting help command {command_id}: {e}")
        raise HTTPException(status_code=500, detail=str(e))
    finally:
        db.close()