leggen/leggend/api/routes/sync.py

from typing import Optional
from fastapi import APIRouter, HTTPException, BackgroundTasks
from loguru import logger

from leggend.api.models.common import APIResponse
from leggend.api.models.sync import SyncRequest, SyncStatus, SyncResult, SchedulerConfig
from leggend.services.sync_service import SyncService
from leggend.background.scheduler import scheduler
from leggend.config import config

router = APIRouter()
sync_service = SyncService()


@router.get("/sync/status", response_model=APIResponse)
async def get_sync_status() -> APIResponse:
    """Get current sync status"""
    try:
        status = await sync_service.get_sync_status()
        
        # Add scheduler information
        next_sync_time = scheduler.get_next_sync_time()
        if next_sync_time:
            status.next_sync = next_sync_time
        
        return APIResponse(
            success=True,
            data=status,
            message="Sync status retrieved successfully"
        )
        
    except Exception as e:
        logger.error(f"Failed to get sync status: {e}")
        raise HTTPException(status_code=500, detail=f"Failed to get sync status: {str(e)}")


@router.post("/sync", response_model=APIResponse)
async def trigger_sync(
    background_tasks: BackgroundTasks,
    sync_request: Optional[SyncRequest] = None
) -> APIResponse:
    """Trigger a manual sync operation"""
    try:
        # Check if sync is already running
        status = await sync_service.get_sync_status()
        if status.is_running and not (sync_request and sync_request.force):
            return APIResponse(
                success=False,
                message="Sync is already running. Use 'force: true' to override."
            )
        
        # Determine what to sync
        if sync_request and sync_request.account_ids:
            # Sync specific accounts in background
            background_tasks.add_task(
                sync_service.sync_specific_accounts, 
                sync_request.account_ids, 
                sync_request.force if sync_request else False
            )
            message = f"Started sync for {len(sync_request.account_ids)} specific accounts"
        else:
            # Sync all accounts in background
            background_tasks.add_task(
                sync_service.sync_all_accounts, 
                sync_request.force if sync_request else False
            )
            message = "Started sync for all accounts"
        
        return APIResponse(
            success=True,
            data={"sync_started": True, "force": sync_request.force if sync_request else False},
            message=message
        )
        
    except Exception as e:
        logger.error(f"Failed to trigger sync: {e}")
        raise HTTPException(status_code=500, detail=f"Failed to trigger sync: {str(e)}")


@router.post("/sync/now", response_model=APIResponse)
async def sync_now(sync_request: Optional[SyncRequest] = None) -> APIResponse:
    """Run sync synchronously and return results (slower, for testing)"""
    try:
        if sync_request and sync_request.account_ids:
            result = await sync_service.sync_specific_accounts(
                sync_request.account_ids, 
                sync_request.force
            )
        else:
            result = await sync_service.sync_all_accounts(
                sync_request.force if sync_request else False
            )
        
        return APIResponse(
            success=result.success,
            data=result,
            message="Sync completed" if result.success else f"Sync failed with {len(result.errors)} errors"
        )
        
    except Exception as e:
        logger.error(f"Failed to run sync: {e}")
        raise HTTPException(status_code=500, detail=f"Failed to run sync: {str(e)}")


@router.get("/sync/scheduler", response_model=APIResponse)
async def get_scheduler_config() -> APIResponse:
    """Get current scheduler configuration"""
    try:
        scheduler_config = config.scheduler_config
        next_sync_time = scheduler.get_next_sync_time()
        
        response_data = {
            **scheduler_config,
            "next_scheduled_sync": next_sync_time.isoformat() if next_sync_time else None,
            "is_running": scheduler.scheduler.running if hasattr(scheduler, 'scheduler') else False
        }
        
        return APIResponse(
            success=True,
            data=response_data,
            message="Scheduler configuration retrieved successfully"
        )
        
    except Exception as e:
        logger.error(f"Failed to get scheduler config: {e}")
        raise HTTPException(status_code=500, detail=f"Failed to get scheduler config: {str(e)}")


@router.put("/sync/scheduler", response_model=APIResponse)
async def update_scheduler_config(scheduler_config: SchedulerConfig) -> APIResponse:
    """Update scheduler configuration"""
    try:
        # Validate cron expression if provided
        if scheduler_config.cron:
            try:
                cron_parts = scheduler_config.cron.split()
                if len(cron_parts) != 5:
                    raise ValueError("Cron expression must have 5 parts: minute hour day month day_of_week")
            except Exception as e:
                raise HTTPException(status_code=400, detail=f"Invalid cron expression: {str(e)}")
        
        # Update configuration
        schedule_data = scheduler_config.dict(exclude_none=True)
        config.update_section("scheduler", {"sync": schedule_data})
        
        # Reschedule the job
        scheduler.reschedule_sync(schedule_data)
        
        return APIResponse(
            success=True,
            data=schedule_data,
            message="Scheduler configuration updated successfully"
        )
        
    except Exception as e:
        logger.error(f"Failed to update scheduler config: {e}")
        raise HTTPException(status_code=500, detail=f"Failed to update scheduler config: {str(e)}")


@router.post("/sync/scheduler/start", response_model=APIResponse)
async def start_scheduler() -> APIResponse:
    """Start the background scheduler"""
    try:
        if not scheduler.scheduler.running:
            scheduler.start()
            return APIResponse(
                success=True,
                message="Scheduler started successfully"
            )
        else:
            return APIResponse(
                success=True,
                message="Scheduler is already running"
            )
        
    except Exception as e:
        logger.error(f"Failed to start scheduler: {e}")
        raise HTTPException(status_code=500, detail=f"Failed to start scheduler: {str(e)}")


@router.post("/sync/scheduler/stop", response_model=APIResponse) 
async def stop_scheduler() -> APIResponse:
    """Stop the background scheduler"""
    try:
        if scheduler.scheduler.running:
            scheduler.shutdown()
            return APIResponse(
                success=True,
                message="Scheduler stopped successfully"
            )
        else:
            return APIResponse(
                success=True,
                message="Scheduler is already stopped"
            )
        
    except Exception as e:
        logger.error(f"Failed to stop scheduler: {e}")
        raise HTTPException(status_code=500, detail=f"Failed to stop scheduler: {str(e)}")