"""
TSCM Schedule Routes

Handles /schedules/* endpoints for automated sweep scheduling.
"""

from __future__ import annotations

import logging
from datetime import datetime, timezone
from typing import Any

from flask import jsonify, request

from routes.tscm import (
    _get_schedule_timezone,
    _next_run_from_cron,
    _start_sweep_internal,
    tscm_bp,
)
from utils.database import (
    create_tscm_schedule,
    delete_tscm_schedule,
    get_all_tscm_schedules,
    get_tscm_schedule,
    update_tscm_schedule,
)

logger = logging.getLogger('intercept.tscm')


@tscm_bp.route('/schedules', methods=['GET'])
def list_schedules():
    """List all TSCM sweep schedules."""
    enabled_param = request.args.get('enabled')
    enabled = None
    if enabled_param is not None:
        enabled = enabled_param.lower() in ('1', 'true', 'yes')

    schedules = get_all_tscm_schedules(enabled=enabled, limit=200)
    return jsonify({
        'status': 'success',
        'count': len(schedules),
        'schedules': schedules,
    })


@tscm_bp.route('/schedules', methods=['POST'])
def create_schedule():
    """Create a new sweep schedule."""
    data = request.get_json() or {}
    name = (data.get('name') or '').strip()
    cron_expression = (data.get('cron_expression') or '').strip()
    sweep_type = data.get('sweep_type', 'standard')
    baseline_id = data.get('baseline_id')
    zone_name = data.get('zone_name')
    enabled = bool(data.get('enabled', True))
    notify_on_threat = bool(data.get('notify_on_threat', True))
    notify_email = data.get('notify_email')

    if not name:
        return jsonify({'status': 'error', 'message': 'Schedule name required'}), 400
    if not cron_expression:
        return jsonify({'status': 'error', 'message': 'cron_expression required'}), 400

    next_run = None
    if enabled:
        try:
            tz = _get_schedule_timezone(zone_name)
            next_local = _next_run_from_cron(cron_expression, datetime.now(tz))
            next_run = next_local.astimezone(timezone.utc).isoformat() if next_local else None
        except Exception as e:
            return jsonify({'status': 'error', 'message': f'Invalid cron: {e}'}), 400

    schedule_id = create_tscm_schedule(
        name=name,
        cron_expression=cron_expression,
        sweep_type=sweep_type,
        baseline_id=baseline_id,
        zone_name=zone_name,
        enabled=enabled,
        notify_on_threat=notify_on_threat,
        notify_email=notify_email,
        next_run=next_run,
    )
    schedule = get_tscm_schedule(schedule_id)
    return jsonify({
        'status': 'success',
        'message': 'Schedule created',
        'schedule': schedule
    })


@tscm_bp.route('/schedules/<int:schedule_id>', methods=['PUT', 'PATCH'])
def update_schedule(schedule_id: int):
    """Update a sweep schedule."""
    schedule = get_tscm_schedule(schedule_id)
    if not schedule:
        return jsonify({'status': 'error', 'message': 'Schedule not found'}), 404

    data = request.get_json() or {}
    updates: dict[str, Any] = {}

    for key in ('name', 'cron_expression', 'sweep_type', 'baseline_id', 'zone_name', 'notify_email'):
        if key in data:
            updates[key] = data[key]

    if 'baseline_id' in updates and updates['baseline_id'] in ('', None):
        updates['baseline_id'] = None

    if 'enabled' in data:
        updates['enabled'] = 1 if data['enabled'] else 0
    if 'notify_on_threat' in data:
        updates['notify_on_threat'] = 1 if data['notify_on_threat'] else 0

    # Recalculate next_run when cron/zone/enabled changes
    if any(k in updates for k in ('cron_expression', 'zone_name', 'enabled')):
        if updates.get('enabled', schedule.get('enabled', 1)):
            cron_expr = updates.get('cron_expression', schedule.get('cron_expression', ''))
            zone_name = updates.get('zone_name', schedule.get('zone_name'))
            try:
                tz = _get_schedule_timezone(zone_name)
                next_local = _next_run_from_cron(cron_expr, datetime.now(tz))
                updates['next_run'] = next_local.astimezone(timezone.utc).isoformat() if next_local else None
            except Exception as e:
                return jsonify({'status': 'error', 'message': f'Invalid cron: {e}'}), 400
        else:
            updates['next_run'] = None

    if not updates:
        return jsonify({'status': 'error', 'message': 'No updates provided'}), 400

    update_tscm_schedule(schedule_id, **updates)
    schedule = get_tscm_schedule(schedule_id)
    return jsonify({'status': 'success', 'schedule': schedule})


@tscm_bp.route('/schedules/<int:schedule_id>', methods=['DELETE'])
def delete_schedule(schedule_id: int):
    """Delete a sweep schedule."""
    success = delete_tscm_schedule(schedule_id)
    if not success:
        return jsonify({'status': 'error', 'message': 'Schedule not found'}), 404
    return jsonify({'status': 'success', 'message': 'Schedule deleted'})


@tscm_bp.route('/schedules/<int:schedule_id>/run', methods=['POST'])
def run_schedule_now(schedule_id: int):
    """Trigger a scheduled sweep immediately."""
    schedule = get_tscm_schedule(schedule_id)
    if not schedule:
        return jsonify({'status': 'error', 'message': 'Schedule not found'}), 404

    result = _start_sweep_internal(
        sweep_type=schedule.get('sweep_type') or 'standard',
        baseline_id=schedule.get('baseline_id'),
        wifi_enabled=True,
        bt_enabled=True,
        rf_enabled=True,
        wifi_interface='',
        bt_interface='',
        sdr_device=None,
        verbose_results=False,
    )

    if result.get('status') != 'success':
        status_code = result.pop('http_status', 400)
        return jsonify(result), status_code

    # Update schedule run timestamps
    cron_expr = schedule.get('cron_expression') or ''
    tz = _get_schedule_timezone(schedule.get('zone_name'))
    now_utc = datetime.now(timezone.utc)
    try:
        next_local = _next_run_from_cron(cron_expr, datetime.now(tz))
    except Exception:
        next_local = None

    update_tscm_schedule(
        schedule_id,
        last_run=now_utc.isoformat(),
        next_run=next_local.astimezone(timezone.utc).isoformat() if next_local else None,
    )

    return jsonify(result)