TIP/app/routers/messages.py

"""
Messages.py
    Contiene los endpoints de CRUD de mensajes.
"""

import re

from fastapi import APIRouter, Depends, HTTPException, Request, status
from sqlalchemy.orm import Session
from database import get_db
import models
import schemas
from typing import List, Optional
from datetime import datetime
from auth import get_current_user
from audit import log_action

router = APIRouter()


@router.post("/messages/", response_model=schemas.MessageResponse, tags=['Messages'])
def create_message(
    message:      schemas.MessageCreate,
    request:      Request,
    db:           Session = Depends(get_db),
    current_user: int = Depends(get_current_user)
):
    existing = db.query(models.Message).filter(
        models.Message.id_mess_g == message.id_mess_g,
        models.Message.group_id == message.group_id
    ).first()
    if existing:
        raise HTTPException(
            status_code=status.HTTP_400_BAD_REQUEST,
            detail=f"Message in Group ID {message.group_id} with Message ID {message.id_mess_g} already exists"
        )

    db_message = models.Message(**message.model_dump())
    db.add(db_message)
    db.flush()

    log_action(
        db=db, entity_type='message',
        entity_id=f"{db_message.id_mess_g}_{db_message.group_id}",
        action='create', user_id=current_user,
        after={'id_mess_g': db_message.id_mess_g, 'group_id': db_message.group_id,
               'sender_id': db_message.sender_id, 'date': str(db_message.date)},
        ip_address=request.client.host
    )

    rules = db.query(models.Rule).filter(models.Rule.is_active == True).all()
    alerts = []
    for rule in rules:
        try:
            if re.search(rule.regex, db_message.content, re.IGNORECASE):
                new_alert = models.Alert(
                    message_id=db_message.id_mess_g,
                    group_id=db_message.group_id,
                    rule_id=rule.id,
                    status="open",
                    notes=f"Detected pattern: {rule.regex}",
                    created_at=datetime.utcnow()
                )
                db.add(new_alert)
                alerts.append(new_alert)
        except re.error:
            print(f"[WARN] Regex inválida en regla {rule.id}: {rule.regex}")
            continue

    db.commit()
    db.refresh(db_message)
    return db_message


@router.get("/messages/", response_model=List[schemas.MessageResponse], tags=['Messages'])
def read_messages(
    skip:         int = 0,
    limit:        int = 100,
    db:           Session = Depends(get_db),
    current_user: int = Depends(get_current_user)
):
    return db.query(models.Message).offset(skip).limit(limit).all()


@router.get("/messages/search/", response_model=List[schemas.MessageResponse], tags=['Messages'])
def search_messages(
    q:            str = "",
    group_id:     int = None,
    date_from:    Optional[datetime] = None,
    date_to:      Optional[datetime] = None,
    skip:         int = 0,
    limit:        int = 100,
    db:           Session = Depends(get_db),
    current_user: int = Depends(get_current_user)
):
    query = db.query(models.Message)
    if q:
        query = query.filter(models.Message.content.ilike(f"%{q}%"))
    if group_id:
        query = query.filter(models.Message.group_id == group_id)
    if date_from:
        query = query.filter(models.Message.date >= date_from)
    if date_to:
        query = query.filter(models.Message.date <= date_to)
    return query.offset(skip).limit(limit).all()


@router.get("/groups/{group_id}/messages/", response_model=List[schemas.MessageResponse], tags=['Messages'])
def read_messages_by_group(
    group_id:     int,
    skip:         int = 0,
    limit:        int = 100,
    db:           Session = Depends(get_db),
    current_user: int = Depends(get_current_user)
):
    db_group = db.query(models.Group).filter(
        models.Group.id_telegram == group_id
    ).first()
    if not db_group:
        raise HTTPException(status_code=404, detail="Group not found")
    return db.query(models.Message).filter(
        models.Message.group_id == group_id
    ).offset(skip).limit(limit).all()


@router.get("/senders/{sender_id}/messages/", response_model=List[schemas.MessageResponse], tags=['Messages'])
def read_messages_by_sender(
    sender_id:    int,
    skip:         int = 0,
    limit:        int = 100,
    db:           Session = Depends(get_db),
    current_user: int = Depends(get_current_user)
):
    db_sender = db.query(models.Sender).filter(
        models.Sender.id_telegram == sender_id
    ).first()
    if not db_sender:
        raise HTTPException(status_code=404, detail="Sender not found")
    return db.query(models.Message).filter(
        models.Message.sender_id == sender_id
    ).offset(skip).limit(limit).all()


@router.get("/groups/{group_id}/messages/{message_id}", response_model=schemas.MessageResponse, tags=['Messages'])
def read_message(
    group_id:     int,
    message_id:   int,
    db:           Session = Depends(get_db),
    current_user: int = Depends(get_current_user)
):
    db_message = db.query(models.Message).filter(
        models.Message.id_mess_g == message_id,
        models.Message.group_id == group_id
    ).first()
    if not db_message:
        raise HTTPException(
            status_code=404,
            detail=f"Message with ID {message_id} in group {group_id} not found"
        )
    return db_message


@router.delete("/groups/{group_id}/messages/{message_id}", tags=['Messages'])
def delete_message(
    group_id:     int,
    message_id:   int,
    request:      Request,
    db:           Session = Depends(get_db),
    current_user: int = Depends(get_current_user)
):
    db_message = db.query(models.Message).filter(
        models.Message.id_mess_g == message_id,
        models.Message.group_id == group_id
    ).first()
    if not db_message:
        raise HTTPException(
            status_code=404,
            detail=f"Message with ID {message_id} in group {group_id} not found"
        )

    log_action(
        db=db, entity_type='message',
        entity_id=f"{message_id}_{group_id}",
        action='delete', user_id=current_user,
        before={'id_mess_g': message_id, 'group_id': group_id},
        ip_address=request.client.host
    )

    db.delete(db_message)
    db.commit()
    return {"message": "Message deleted successfully"}