import sys
sys.path.insert(0, "/var/www/html/metafoliadorv2")

from fastapi import APIRouter, Depends, HTTPException, Query, Path
from sqlalchemy.orm import Session
from pydantic import BaseModel, Field
from typing import Optional

from app.models.main_database import get_main_db
from app.models.main_user import MainUser
from app.api.main.auth import get_main_current_user
from app.services.main_auth_service import main_hash_password
from app.services.timezone import iso

router = APIRouter(prefix="/main/api/users", tags=["main-users"])


class CreateMainUserRequest(BaseModel):
    email: str = Field(..., description="Correo electrónico del usuario")
    password: str = Field(..., description="Contraseña del usuario")
    name: str = Field("", description="Nombre completo")


class UpdateMainUserRequest(BaseModel):
    name: Optional[str] = Field(None, description="Nombre completo")
    email: Optional[str] = Field(None, description="Correo electrónico")
    password: Optional[str] = Field(None, description="Nueva contraseña")
    active: Optional[bool] = Field(None, description="Estado activo/inactivo")


def _main_user_to_dict(u: MainUser) -> dict:
    return {
        "id": u.id,
        "name": u.name,
        "email": u.email,
        "active": u.active,
        "created_at": iso(u.created_at),
    }


@router.get("", summary="Listar usuarios principales")
async def list_main_users(
    search: str = Query(None, description="Buscar por email o nombre"),
    db: Session = Depends(get_main_db),
    current_user: MainUser = Depends(get_main_current_user),
):
    q = db.query(MainUser)
    if search:
        q = q.filter(MainUser.email.ilike(f"%{search}%") | MainUser.name.ilike(f"%{search}%"))
    users = q.order_by(MainUser.name).all()
    return [_main_user_to_dict(u) for u in users]


@router.get("/{user_id}", summary="Obtener usuario principal")
async def get_main_user(
    user_id: int = Path(..., description="ID del usuario"),
    db: Session = Depends(get_main_db),
    current_user: MainUser = Depends(get_main_current_user),
):
    u = db.query(MainUser).filter(MainUser.id == user_id).first()
    if not u:
        raise HTTPException(status_code=404, detail="Usuario no encontrado")
    return _main_user_to_dict(u)


@router.post("", status_code=201, summary="Crear usuario principal")
async def create_main_user(
    body: CreateMainUserRequest,
    db: Session = Depends(get_main_db),
    current_user: MainUser = Depends(get_main_current_user),
):
    if not body.email or not body.password:
        raise HTTPException(status_code=400, detail="email y password son requeridos")
    existing = db.query(MainUser).filter(MainUser.email == body.email).first()
    if existing:
        raise HTTPException(status_code=409, detail="El email ya existe")
    u = MainUser(
        name=body.name or "",
        email=body.email,
        password_hash=main_hash_password(body.password),
        active=True,
    )
    db.add(u)
    db.commit()
    db.refresh(u)
    return _main_user_to_dict(u)


@router.put("/{user_id}", summary="Actualizar usuario principal")
async def update_main_user(
    user_id: int = Path(..., description="ID del usuario"),
    body: UpdateMainUserRequest = None,
    db: Session = Depends(get_main_db),
    current_user: MainUser = Depends(get_main_current_user),
):
    u = db.query(MainUser).filter(MainUser.id == user_id).first()
    if not u:
        raise HTTPException(status_code=404, detail="Usuario no encontrado")
    if body.name is not None:
        u.name = body.name
    if body.email:
        existing = db.query(MainUser).filter(MainUser.email == body.email, MainUser.id != user_id).first()
        if existing:
            raise HTTPException(status_code=409, detail="El email ya existe")
        u.email = body.email
    if body.password:
        u.password_hash = main_hash_password(body.password)
    if body.active is not None:
        u.active = body.active
    db.commit()
    return {"ok": True}


@router.delete("/{user_id}", summary="Eliminar usuario principal")
async def delete_main_user(
    user_id: int = Path(..., description="ID del usuario a eliminar"),
    db: Session = Depends(get_main_db),
    current_user: MainUser = Depends(get_main_current_user),
):
    u = db.query(MainUser).filter(MainUser.id == user_id).first()
    if not u:
        raise HTTPException(status_code=404, detail="Usuario no encontrado")
    if u.id == current_user.id:
        raise HTTPException(status_code=400, detail="No puedes eliminarte a ti mismo")
    db.delete(u)
    db.commit()
    return {"ok": True}