"""
Calendar Sync API Step

HTTP API endpoint for manual calendar sync triggering.
Supports syncing a single employee or all employees.
"""
import sys
from pathlib import Path
sys.path.insert(0, str(Path(__file__).parent))
from calendar_sync_utils import get_redis_client, set_employee_lock, get_logger

from motia import http, ApiRequest, ApiResponse, FlowContext


config = {
    'name': 'Calendar Sync API Trigger',
    'description': 'API endpoint for manual calendar sync triggering',
    'flows': ['advoware-calendar-sync'],
    'triggers': [
        http('POST', '/advoware/calendar/sync')
    ],
    'enqueues': ['calendar_sync_employee', 'calendar_sync_all']
}


async def handler(request: ApiRequest, ctx: FlowContext) -> ApiResponse:
    """
    HTTP handler for manual calendar sync triggering.
    
    Request body:
        {
            "kuerzel": "SB"  // or "ALL" for all employees
        }
    """
    try:
        # Get kuerzel from request body
        body = request.body
        kuerzel = body.get('kuerzel')
        if not kuerzel:
            return ApiResponse(
                status_code=400,
                body={
                    'error': 'kuerzel required',
                    'message': 'Please provide kuerzel in body'
                }
            )

        kuerzel_upper = kuerzel.upper()

        if kuerzel_upper == 'ALL':
            # Emit sync-all event
            ctx.logger.info("Calendar Sync API: Emitting sync-all event")
            await ctx.enqueue({
                "topic": "calendar_sync_all",
                "data": {
                    "triggered_by": "api"
                }
            })
            return ApiResponse(
                status_code=200,
                body={
                    'status': 'triggered',
                    'message': 'Calendar sync triggered for all employees',
                    'triggered_by': 'api'
                }
            )
        else:
            # Single employee sync
            redis_client = get_redis_client(ctx)
            
            if not set_employee_lock(redis_client, kuerzel_upper, 'api', ctx):
                ctx.logger.info(f"Calendar Sync API: Sync already active for {kuerzel_upper}, skipping")
                return ApiResponse(
                    status_code=409,
                    body={
                        'status': 'conflict',
                        'message': f'Calendar sync already active for {kuerzel_upper}',
                        'kuerzel': kuerzel_upper,
                        'triggered_by': 'api'
                    }
                )

            ctx.logger.info(f"Calendar Sync API called for {kuerzel_upper}")
            
            # Lock successfully set, now emit event
            await ctx.enqueue({
                "topic": "calendar_sync_employee",
                "data": {
                    "kuerzel": kuerzel_upper,
                    "triggered_by": "api"
                }
            })

            return ApiResponse(
                status_code=200,
                body={
                    'status': 'triggered',
                    'message': f'Calendar sync triggered for {kuerzel_upper}',
                    'kuerzel': kuerzel_upper,
                    'triggered_by': 'api'
                }
            )

    except Exception as e:
        ctx.logger.error(f"Error in API trigger: {e}")
        return ApiResponse(
            status_code=500,
            body={
                'error': 'Internal server error',
                'details': str(e)
            }
        )