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.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()

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)],
    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)], 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