from fastapi import APIRouter, Depends, HTTPException
from sqlalchemy.orm import Session
from sqlalchemy.sql import func
from database import get_db
from models import NewsItem
from pydantic import BaseModel
from datetime import datetime
import logging

# Configuración del logging
LOG_FILE = "app.log"
logging.basicConfig(
    filename=LOG_FILE,  # Archivo de logs
    level=logging.INFO,  # Nivel de logging (DEBUG, INFO, WARNING, ERROR, CRITICAL)
    format="%(asctime)s - %(levelname)s - %(message)s",  # Formato de los logs
)

router = APIRouter()

# Modelo de datos de entrada
class NewsItemCreate(BaseModel):
    titulo: str
    contenido: str
    autor: str | None = None
    fuente: str | None = None
    fecha: datetime | None = None
    link: str
    critico:bool
    favorable:bool
    keyword: str | None = None

@router.post("/news/")
def create_news_item(item: NewsItemCreate, db: Session = Depends(get_db)):
    # Verificar si el título ya existe
    existing_item = db.query(NewsItem).filter(NewsItem.titulo == item.titulo).first()
    if existing_item:
        logging.info("Título ya en la base de datos")

    # Crear nuevo objeto
    new_item = NewsItem(
        titulo=item.titulo,
        contenido=item.contenido,
        autor=item.autor,
        fuente=item.fuente,
        fecha=item.fecha or datetime.utcnow(),
        link=item.link,
        critico=item.critico,
        favorable=item.favorable,
        keyword=item.keyword
    )

    db.add(new_item)
    db.commit()
    db.refresh(new_item)

    return {"message": "Noticia creada con éxito", "id": new_item.id, "titulo": new_item.titulo}

@router.get("/news/count/by-source/date-range")
def count_news_by_source_in_range(
    fecha_inicio: datetime, fecha_fin: datetime, db: Session = Depends(get_db)
):
    results = (
        db.query(NewsItem.fuente, func.count(NewsItem.id))
        .filter(NewsItem.fecha >= fecha_inicio, NewsItem.fecha <= fecha_fin)
        .group_by(NewsItem.fuente)
        .all()
    )
    return {"count_by_source_in_range": results}


@router.get("/news/count/by-author/date-range")
def count_news_by_author_in_range(
    fecha_inicio: datetime, fecha_fin: datetime, db: Session = Depends(get_db)
):
    results = (
        db.query(NewsItem.autor, func.count(NewsItem.id))
        .filter(NewsItem.fecha >= fecha_inicio, NewsItem.fecha <= fecha_fin)
        .group_by(NewsItem.autor)
        .all()
    )
    return {"count_by_author_in_range": results}


@router.get("/news/count/favorable/by-author/date-range")
def count_favorable_news_by_author_in_range(
    fecha_inicio: datetime, fecha_fin: datetime, db: Session = Depends(get_db)
):
    results = (
        db.query(NewsItem.autor, func.count(NewsItem.id))
        .filter(
            NewsItem.favorable == True,
            NewsItem.fecha >= fecha_inicio,
            NewsItem.fecha <= fecha_fin,
        )
        .group_by(NewsItem.autor)
        .all()
    )
    return {"favorable_count_by_author_in_range": results}


@router.get("/news/count/unfavorable/by-author/date-range")
def count_unfavorable_news_by_author_in_range(
    fecha_inicio: datetime, fecha_fin: datetime, db: Session = Depends(get_db)
):
    results = (
        db.query(NewsItem.autor, func.count(NewsItem.id))
        .filter(
            NewsItem.critico == True,
            NewsItem.fecha >= fecha_inicio,
            NewsItem.fecha <= fecha_fin,
        )
        .group_by(NewsItem.autor)
        .all()
    )
    return {"unfavorable_count_by_author_in_range": results}

@router.get("/news/count/favorable/by-source/date-range")
def count_favorable_news_by_source_in_range(
    fecha_inicio: datetime, fecha_fin: datetime, db: Session = Depends(get_db)
):
    results = (
        db.query(NewsItem.fuente, func.count(NewsItem.id))
        .filter(
            NewsItem.favorable == True,
            NewsItem.fecha >= fecha_inicio,
            NewsItem.fecha <= fecha_fin,
        )
        .group_by(NewsItem.fuente)
        .all()
    )
    return {"favorable_count_by_source_in_range": results}

@router.get("/news/count/unfavorable/by-source/date-range")
def count_unfavorable_news_by_source_in_range(
    fecha_inicio: datetime, fecha_fin: datetime, db: Session = Depends(get_db)
):
    results = (
        db.query(NewsItem.fuente, func.count(NewsItem.id))
        .filter(
            NewsItem.critico == True,
            NewsItem.fecha >= fecha_inicio,
            NewsItem.fecha <= fecha_fin,
        )
        .group_by(NewsItem.fuente)
        .all()
    )
    return {"unfavorable_count_by_source_in_range": results}

@router.get("/news/neutral/date-range")
def get_neutral_news_in_range(
    fecha_inicio: datetime, fecha_fin: datetime, db: Session = Depends(get_db)
):
    results = (
        db.query(NewsItem)
        .filter(
            NewsItem.favorable == False,
            NewsItem.critico == False,
            NewsItem.fecha >= fecha_inicio,
            NewsItem.fecha <= fecha_fin,
        )
        .all()
    )
    return results


@router.get("/news/mixed/date-range")
def get_mixed_news_in_range(
    fecha_inicio: datetime, fecha_fin: datetime, db: Session = Depends(get_db)
):
    results = (
        db.query(NewsItem)
        .filter(
            NewsItem.favorable == True,
            NewsItem.critico == True,
            NewsItem.fecha >= fecha_inicio,
            NewsItem.fecha <= fecha_fin,
        )
        .all()
    )
    return results

@router.get("/news/count/by-source")
def count_news_by_source(db: Session = Depends(get_db)):
    results = db.query(NewsItem.fuente, func.count(NewsItem.id)).group_by(NewsItem.fuente).all()
    return {"count_by_source": results}

@router.get("/news/count/by-author")
def count_news_by_author(db: Session = Depends(get_db)):
    results = db.query(NewsItem.autor, func.count(NewsItem.id)).group_by(NewsItem.autor).all()
    return {"count_by_author": results}

@router.get("/news/count/favorable/by-author")
def count_favorable_news_by_author(db: Session = Depends(get_db)):
    results = (
        db.query(NewsItem.autor, func.count(NewsItem.id))
        .filter(NewsItem.favorable == True)
        .group_by(NewsItem.autor)
        .all()
    )
    return {"favorable_count_by_author": results}

@router.get("/news/count/unfavorable/by-author")
def count_unfavorable_news_by_author(db: Session = Depends(get_db)):
    results = (
        db.query(NewsItem.autor, func.count(NewsItem.id))
        .filter(NewsItem.critico == True)
        .group_by(NewsItem.autor)
        .all()
    )
    return {"unfavorable_count_by_author": results}

@router.get("/news/count/favorable/by-source")
def count_favorable_news_by_source(db: Session = Depends(get_db)):
    results = (
        db.query(NewsItem.fuente, func.count(NewsItem.id))
        .filter(NewsItem.favorable == True)
        .group_by(NewsItem.fuente)
        .all()
    )
    return {"favorable_count_by_source": results}

@router.get("/news/count/unfavorable/by-source")
def count_unfavorable_news_by_source(db: Session = Depends(get_db)):
    results = (
        db.query(NewsItem.fuente, func.count(NewsItem.id))
        .filter(NewsItem.critico == True)
        .group_by(NewsItem.fuente)
        .all()
    )
    return {"unfavorable_count_by_source": results}

@router.get("/news/neutral")
def get_neutral_news(db: Session = Depends(get_db)):
    results = (
        db.query(NewsItem)
        .filter(NewsItem.favorable == False, NewsItem.critico == False)
        .all()
    )
    return results


@router.get("/news/mixed")
def get_mixed_news(db: Session = Depends(get_db)):
    results = (
        db.query(NewsItem)
        .filter(NewsItem.favorable == True, NewsItem.critico == True)
        .all()
    )
    return results