import logging
from datetime import datetime
from typing import Annotated, Optional

from fastapi import APIRouter, Depends, Query
from sqlalchemy.orm import aliased
from starlette import status

from common import auth
from common.common import configure_logging
from common.exceptions import LogNotFoundException
from components.dbo.models.feedback import Feedback
from components.dbo.models.log import Log
from schemas.log import LogCreate
import common.dependencies as DI
from sqlalchemy.orm import sessionmaker

router = APIRouter(tags=['Logs'])

logger = logging.getLogger(__name__)
configure_logging()


@router.get('/logs', status_code=status.HTTP_200_OK)
async def get_all_logs(
    db: Annotated[sessionmaker, Depends(DI.get_db)], 
    current_user: Annotated[any, Depends(auth.get_current_user)],
    date_start: Optional[datetime] = Query(None, alias="date_start"),
    date_end: Optional[datetime] = Query(None, alias="date_end")
):
    logger.info(f'GET /logs: start')
    logger.info(f'GET /logs: start_date={date_start}, end_date={date_end}')
    feedback_alias = aliased(Feedback)

    query = db.query(Log)

    if date_start and date_end:
        query = query.filter(Log.dateCreated.between(date_start, date_end))
    elif date_start:
        query = query.filter(Log.dateCreated >= date_start)
    elif date_end:
        query = query.filter(Log.dateCreated <= date_end)

    query = query.outerjoin(feedback_alias, Log.id == feedback_alias.log_id)

    logs_with_feedback = query.all()

    combined_logs = []
    for log in logs_with_feedback:
        if log.feedback:
            for feedback in log.feedback:
                combined_logs.append(
                    {
                        "log_id": log.id,
                        "llmPrompt": log.llmPrompt,
                        "llmResponse": log.llmResponse,
                        "llm_classifier": log.llm_classifier,
                        "dateCreated": log.dateCreated,
                        "userRequest": log.userRequest,
                        "userName": log.userName,
                        "query_type": log.query_type,
                        "feedback_id": feedback.feedback_id,
                        "userComment": feedback.userComment,
                        "userScore": feedback.userScore,
                        "manualEstimate": feedback.manualEstimate,
                        "llmEstimate": feedback.llmEstimate,
                    }
                )
        else:
            combined_logs.append(
                {
                    "log_id": log.id,
                    "llmPrompt": log.llmPrompt,
                    "llmResponse": log.llmResponse,
                    "llm_classifier": log.llm_classifier,
                    "dateCreated": log.dateCreated,
                    "userRequest": log.userRequest,
                    "userName": log.userName,
                    "query_type": log.query_type,
                    "feedback_id": None,
                    "userComment": None,
                    "userScore": None,
                    "manualEstimate": None,
                    "llmEstimate": None,
                }
            )
    return combined_logs


@router.get('/log/{log_id}', status_code=status.HTTP_200_OK)
async def get_log(db: Annotated[sessionmaker, Depends(DI.get_db)], 
    current_user: Annotated[any, Depends(auth.get_current_user)], log_id):
    log = db.query(Log).filter(Log.id == log_id).first()
    if log is None:
        raise LogNotFoundException(log_id)
    return log


@router.post('/log', status_code=status.HTTP_201_CREATED)
async def create_log(log: LogCreate, db: Annotated[sessionmaker, Depends(DI.get_db)]):
    logger.info("Handling POST request to /log")
    try:
        new_log = Log(
            llmPrompt=log.llmPrompt,
            llmResponse=log.llmResponse,
            llm_classifier=log.llm_classifier,
            userRequest=log.userRequest,
            userName=log.userName,
        )

        db.add(new_log)
        db.commit()
        db.refresh(new_log)

        logger.info(f"Successfully created log with ID: {new_log.id}")
        return new_log
    except Exception as e:
        logger.error(f"Error creating log: {str(e)}")
        raise e