api/routes/services.py

"""
============================================
RUHI-CORE - Service Management Routes
============================================
"""

from typing import Optional
from fastapi import APIRouter, HTTPException, Depends, Request
from pydantic import BaseModel
from loguru import logger

from core.auth import get_current_user
from core.process_manager import process_manager
from core.port_manager import port_manager

router = APIRouter(prefix="/api/services", tags=["Services"])


class CreateServiceRequest(BaseModel):
    name: str
    type: str = "web"  # web, worker, bot, cron
    language: str = "python"  # python, node, shell
    entry_file: str = "main.py"
    command: Optional[str] = ""
    auto_restart: bool = True
    env_vars: dict = {}
    description: str = ""
    max_memory_mb: int = 512
    port: Optional[int] = None


class UpdateServiceRequest(BaseModel):
    name: Optional[str] = None
    entry_file: Optional[str] = None
    command: Optional[str] = None
    auto_restart: Optional[bool] = None
    env_vars: Optional[dict] = None
    description: Optional[str] = None
    max_memory_mb: Optional[int] = None


@router.get("/")
async def list_services(user=Depends(get_current_user)):
    """List all services"""
    return {
        "services": process_manager.get_all_services(),
        "stats": process_manager.get_stats()
    }


@router.post("/")
async def create_service(req: CreateServiceRequest, user=Depends(get_current_user)):
    """Create a new service"""
    try:
        service = await process_manager.create_service(
            name=req.name,
            type=req.type,
            language=req.language,
            entry_file=req.entry_file,
            command=req.command,
            auto_restart=req.auto_restart,
            env_vars=req.env_vars,
            description=req.description,
            max_memory_mb=req.max_memory_mb,
            port=req.port
        )
        return {
            "message": f"Service '{req.name}' created successfully",
            "service": service.get_info()
        }
    except ValueError as e:
        raise HTTPException(status_code=400, detail=str(e))


@router.get("/{service_id}")
async def get_service(service_id: str, user=Depends(get_current_user)):
    """Get service details"""
    service = process_manager.get_service(service_id)
    if not service:
        raise HTTPException(status_code=404, detail="Service not found")
    return {"service": service.get_info()}


@router.delete("/{service_id}")
async def delete_service(service_id: str, user=Depends(get_current_user)):
    """Delete a service"""
    try:
        await process_manager.delete_service(service_id)
        return {"message": "Service deleted successfully"}
    except ValueError as e:
        raise HTTPException(status_code=404, detail=str(e))


@router.post("/{service_id}/start")
async def start_service(service_id: str, user=Depends(get_current_user)):
    """Start a service"""
    try:
        success = await process_manager.start_service(service_id)
        service = process_manager.get_service(service_id)
        return {
            "message": f"Service start {'successful' if success else 'failed'}",
            "success": success,
            "service": service.get_info() if service else None
        }
    except ValueError as e:
        raise HTTPException(status_code=404, detail=str(e))


@router.post("/{service_id}/stop")
async def stop_service(service_id: str, user=Depends(get_current_user)):
    """Stop a service"""
    try:
        success = await process_manager.stop_service(service_id)
        service = process_manager.get_service(service_id)
        return {
            "message": f"Service stop {'successful' if success else 'failed'}",
            "success": success,
            "service": service.get_info() if service else None
        }
    except ValueError as e:
        raise HTTPException(status_code=404, detail=str(e))


@router.post("/{service_id}/restart")
async def restart_service(service_id: str, user=Depends(get_current_user)):
    """Restart a service"""
    try:
        success = await process_manager.restart_service(service_id)
        service = process_manager.get_service(service_id)
        return {
            "message": f"Service restart {'successful' if success else 'failed'}",
            "success": success,
            "service": service.get_info() if service else None
        }
    except ValueError as e:
        raise HTTPException(status_code=404, detail=str(e))


@router.get("/{service_id}/logs")
async def get_service_logs(
    service_id: str, 
    lines: int = 100,
    user=Depends(get_current_user)
):
    """Get recent logs for a service"""
    service = process_manager.get_service(service_id)
    if not service:
        raise HTTPException(status_code=404, detail="Service not found")
    
    logs = list(service.log_buffer)[-lines:]
    return {
        "service_id": service_id,
        "service_name": service.name,
        "total_lines": len(service.log_buffer),
        "returned_lines": len(logs),
        "logs": logs
    }


@router.put("/{service_id}")
async def update_service(
    service_id: str,
    req: UpdateServiceRequest,
    user=Depends(get_current_user)
):
    """Update service configuration"""
    service = process_manager.get_service(service_id)
    if not service:
        raise HTTPException(status_code=404, detail="Service not found")
    
    if req.name is not None:
        service.name = req.name
    if req.entry_file is not None:
        service.entry_file = req.entry_file
    if req.command is not None:
        service.command = req.command
    if req.auto_restart is not None:
        service.auto_restart = req.auto_restart
    if req.env_vars is not None:
        service.env_vars = req.env_vars
    if req.description is not None:
        service.description = req.description
    if req.max_memory_mb is not None:
        service.max_memory_mb = req.max_memory_mb
    
    await service._save_to_db()
    
    return {
        "message": "Service updated successfully",
        "service": service.get_info()
    }


@router.post("/start-all")
async def start_all_services(user=Depends(get_current_user)):
    """Start all services"""
    await process_manager.start_all()
    return {"message": "All services starting..."}


@router.post("/stop-all")
async def stop_all_services(user=Depends(get_current_user)):
    """Stop all services"""
    await process_manager.stop_all()
    return {"message": "All services stopped"}