TIP/app/routers/groups.py

"""
groups.py
    Contiene los endpoints de CRUD de Grupos.
"""

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
from auth import get_current_user
from audit import log_action

router = APIRouter()

@router.post("/groups/", response_model=schemas.GroupResponse, tags=['Groups'])
def create_group(
    group:        schemas.GroupCreate,
    request:      Request,
    db:           Session = Depends(get_db),
    current_user: int = Depends(get_current_user)
):
    existing = db.query(models.Group).filter(
        models.Group.id_telegram == group.id_telegram
    ).first()
    if existing:
        raise HTTPException(
            status_code=status.HTTP_400_BAD_REQUEST,
            detail=f"Group with Telegram ID {group.id_telegram} already exists"
        )

    db_group = models.Group(**group.model_dump())
    db.add(db_group)
    db.flush()

    log_action(
        db=db, entity_type='group', entity_id=db_group.id_telegram,
        action='create', user_id=current_user,
        after=db_group, ip_address=request.client.host
    )

    db.commit()
    db.refresh(db_group)
    return db_group


@router.get("/groups/", response_model=List[schemas.GroupResponse], tags=['Groups'])
def read_groups(
    skip:         int = 0,
    limit:        int = 100,
    db:           Session = Depends(get_db),
    current_user: int = Depends(get_current_user)
):
    return db.query(models.Group).filter(
        models.Group.type != 'P'
    ).offset(skip).limit(limit).all()

@router.get("/groups/{group_id}", response_model=schemas.GroupResponse, tags=['Groups'])
def read_group(
    group_id:     int,
    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_group

@router.get("/groups/telegram/{id_telegram}", response_model=schemas.GroupResponse, tags=['Groups'])
def read_group_telegram(id_telegram: int, db: Session = Depends(get_db)):
    db_group = db.query(models.Group).filter(
        models.Group.id_telegram == id_telegram
    ).first()
    if not db_group:
        raise HTTPException(status_code=404, detail="Group not found")
    return db_group

@router.patch("/groups/{group_id}/update-position", response_model=schemas.GroupResponse, tags=['Groups'])
def update_group_message_position(
    group_id:     int,
    update_data:  schemas.GroupUpdatePosition,
    request:      Request,
    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=f"Group with ID {group_id} not found")

    before_pos = db_group.message_position
    db_group.message_position = update_data.message_position

    log_action(
        db=db, entity_type='group', entity_id=group_id,
        action='update', user_id=current_user,
        before={'message_position': before_pos},
        after={'message_position': update_data.message_position},
        ip_address=request.client.host
    )

    db.commit()
    db.refresh(db_group)
    return db_group

@router.patch("/groups/{group_id}", response_model=schemas.GroupResponse, tags=['Groups'])
def update_group(
    group_id:     int,
    update_data:  schemas.GroupUpdate,
    request:      Request,
    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=f"Group with ID {group_id} not found")

    before_snapshot = {
        'name': db_group.name,
        'description': db_group.description,
        'type': db_group.type,
    }

    db_group.name = update_data.name
    db_group.description = update_data.description
    db_group.type = update_data.type

    log_action(
        db=db, entity_type='group', entity_id=group_id,
        action='update', user_id=current_user,
        before=before_snapshot, after=update_data.model_dump(),
        ip_address=request.client.host
    )

    db.commit()
    db.refresh(db_group)
    return db_group

@router.delete("/groups/{group_id}", tags=['Groups'])
def delete_group(
    group_id:     int,
    request:      Request,
    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")

    log_action(
        db=db, entity_type='group', entity_id=group_id,
        action='delete', user_id=current_user,
        before=db_group, ip_address=request.client.host
    )

    db.delete(db_group)
    db.commit()
    return {"message": "Group deleted successfully"}