<?php
/**
 * ================================================
 * PARANDATUD MEELDETULETUSTE API - TÄPSE KELLAAJA TUGI
 * ================================================
 * 
 * PARANDUSED:
 * - Parandatud exact_time käsitlemine
 * - Õige validatsioon exact_time vs minutes_before jaoks
 * - Täiustatud debug loogika
 * 
 * ================================================
 */

header('Content-Type: application/json; charset=utf-8');
header('Access-Control-Allow-Origin: *');
header('Access-Control-Allow-Methods: GET, POST, PUT, DELETE, OPTIONS');
header('Access-Control-Allow-Headers: Content-Type, Authorization');

// Handle preflight OPTIONS request
if ($_SERVER['REQUEST_METHOD'] === 'OPTIONS') {
    exit(0);
}

// Põhiseadistused
require_once __DIR__ . '/../../config/config.php';
require_once __DIR__ . '/../../config/database.php';
require_once __DIR__ . '/../../includes/functions.php';

session_start();

// Debug logging function
function apiLog($message, $data = null) {
    $logMessage = '[' . date('Y-m-d H:i:s') . '] Reminders API: ' . $message;
    if ($data) {
        $logMessage .= ' | Data: ' . json_encode($data, JSON_UNESCAPED_UNICODE);
    }
    error_log($logMessage);
}

// Funksioon JSON vastuse saatmiseks
function sendJsonResponse($data, $status = 200) {
    http_response_code($status);
    echo json_encode($data, JSON_UNESCAPED_UNICODE);
    exit;
}

// Funksioon vea saatmiseks
function sendError($message, $status = 400) {
    apiLog('ERROR: ' . $message);
    sendJsonResponse(['error' => $message, 'success' => false], $status);
}

// Funksioon edukas vastuse saatmiseks
function sendSuccess($data = [], $message = 'Tegevus õnnestus') {
    apiLog('SUCCESS: ' . $message, ['dataCount' => is_array($data) ? count($data) : 'N/A']);
    sendJsonResponse([
        'success' => true,
        'message' => $message,
        'data' => $data
    ]);
}

$method = $_SERVER['REQUEST_METHOD'];
$action = $_GET['action'] ?? '';

// Log API call - PARANDATUD LOGIMINE
apiLog('API called', [
    'method' => $method,
    'action' => $action,
    'uri' => $_SERVER['REQUEST_URI'],
    'input' => file_get_contents('php://input')
]);

// Cron job'ide ja pending kontrollide jaoks ei nõua sisselogimist
if (!in_array($action, ['process', 'pending', 'cron']) && !isLoggedIn()) {
    sendError('Sisselogimine nõutav', 401);
}

$current_user_id = isLoggedIn() ? $_SESSION['user_id'] : null;

try {
    // Loo/uuenda event_reminders tabel
    ensureRemindersTable($pdo);
    
    switch ($method) {
        case 'GET':
            handleGetRequest($pdo, $current_user_id, $action);
            break;
        case 'POST':
            handlePostRequest($pdo, $current_user_id, $action);
            break;
        case 'PUT':
            handlePutRequest($pdo, $current_user_id);
            break;
        case 'DELETE':
            handleDeleteRequest($pdo, $current_user_id);
            break;
        default:
            sendError('Meetod pole toetatud', 405);
    }
} catch (Exception $e) {
    apiLog('EXCEPTION: ' . $e->getMessage());
    sendError('Serveri viga: ' . $e->getMessage(), 500);
}

/**
 * Tagab et event_reminders tabel on uuendatud
 */
function ensureRemindersTable($pdo) {
    try {
        // Loo põhitabel
        $pdo->exec("
            CREATE TABLE IF NOT EXISTS event_reminders (
                id INTEGER PRIMARY KEY AUTOINCREMENT,
                event_id INTEGER NOT NULL,
                custom_message TEXT NOT NULL,
                reminder_datetime TIMESTAMP NOT NULL,
                minutes_before INTEGER NOT NULL DEFAULT 60,
                is_recurring BOOLEAN DEFAULT 0,
                recurring_type VARCHAR(20) DEFAULT NULL,
                recurring_interval INTEGER DEFAULT 1,
                recurring_end_date DATE DEFAULT NULL,
                is_enabled BOOLEAN DEFAULT 1,
                sent_at TIMESTAMP NULL,
                sent_count INTEGER DEFAULT 0,
                last_error TEXT NULL,
                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
                updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
                FOREIGN KEY (event_id) REFERENCES events(id) ON DELETE CASCADE
            )
        ");
        
        // Kontrolli ja lisa puuduvad veerud
        $result = $pdo->query("PRAGMA table_info(event_reminders)");
        $columns = $result->fetchAll(PDO::FETCH_ASSOC);
        $existingColumns = array_column($columns, 'name');
        
        $requiredColumns = [
            'minutes_before' => 'INTEGER DEFAULT 60',
            'is_recurring' => 'BOOLEAN DEFAULT 0',
            'recurring_type' => 'VARCHAR(20) DEFAULT NULL',
            'recurring_interval' => 'INTEGER DEFAULT 1',
            'recurring_end_date' => 'DATE DEFAULT NULL',
            'is_enabled' => 'BOOLEAN DEFAULT 1',
            'sent_count' => 'INTEGER DEFAULT 0',
            'last_error' => 'TEXT NULL',
            'updated_at' => 'TIMESTAMP DEFAULT CURRENT_TIMESTAMP'
        ];
        
        foreach ($requiredColumns as $columnName => $columnDefinition) {
            if (!in_array($columnName, $existingColumns)) {
                apiLog("Adding missing column: $columnName");
                try {
                    $pdo->exec("ALTER TABLE event_reminders ADD COLUMN $columnName $columnDefinition");
                } catch (PDOException $e) {
                    apiLog("Error adding column $columnName: " . $e->getMessage());
                }
            }
        }
        
        // Loo indeksid
        $pdo->exec("CREATE INDEX IF NOT EXISTS idx_reminders_event_id ON event_reminders(event_id)");
        $pdo->exec("CREATE INDEX IF NOT EXISTS idx_reminders_datetime ON event_reminders(reminder_datetime)");
        $pdo->exec("CREATE INDEX IF NOT EXISTS idx_reminders_enabled ON event_reminders(is_enabled)");
        $pdo->exec("CREATE INDEX IF NOT EXISTS idx_reminders_sent ON event_reminders(sent_at)");
        
        return true;
    } catch (PDOException $e) {
        apiLog('Error ensuring reminders table: ' . $e->getMessage());
        return false;
    }
}

/**
 * ======================
 * GET PÄRINGUTE KÄITLEMINE
 * ======================
 */
function handleGetRequest($pdo, $user_id, $action) {
    switch ($action) {
        case 'list':
            getReminders($pdo, $user_id);
            break;
        case 'event':
            getEventReminders($pdo, $user_id);
            break;
        case 'pending':
            getPendingRemindersAPI($pdo, $user_id);
            break;
        case 'process':
        case 'cron':
            processRemindersAPI($pdo);
            break;
        case 'stats':
            getReminderStats($pdo, $user_id);
            break;
        default:
            getReminders($pdo, $user_id);
    }
}

/**
 * Lae kasutaja kõik meeldetuletused
 */
function getReminders($pdo, $user_id) {
    if (!$user_id) {
        sendError('Kasutaja ID on nõutav');
    }
    
    try {
        $stmt = $pdo->prepare("
            SELECT 
                r.*,
                e.title as event_title,
                e.start_datetime as event_start,
                e.location as event_location,
                c.name as category_name,
                c.icon as category_icon,
                c.color as category_color
            FROM event_reminders r
            INNER JOIN events e ON r.event_id = e.id
            LEFT JOIN event_categories c ON e.category_id = c.id
            WHERE e.user_id = ? AND r.is_enabled = 1
            ORDER BY r.reminder_datetime ASC
        ");
        
        $stmt->execute([$user_id]);
        $reminders = $stmt->fetchAll(PDO::FETCH_ASSOC);
        
        // Lisa täiendavat infot
        foreach ($reminders as &$reminder) {
            $reminder['is_pending'] = strtotime($reminder['reminder_datetime']) <= time() && !$reminder['sent_at'];
            $reminder['time_until_event'] = calculateTimeUntil($reminder['event_start']);
            $reminder['formatted_reminder_time'] = date('d.m.Y H:i', strtotime($reminder['reminder_datetime']));
            $reminder['is_past'] = strtotime($reminder['event_start']) < time();
            
            // Korduvuse info
            if ($reminder['is_recurring']) {
                $reminder['recurring_info'] = formatRecurringInfo($reminder);
            }
        }
        
        apiLog('Reminders loaded', ['user_id' => $user_id, 'count' => count($reminders)]);
        sendSuccess($reminders);
        
    } catch (PDOException $e) {
        apiLog('Reminders load error: ' . $e->getMessage());
        sendError('Meeldetuletuste laadimine ebaõnnestus');
    }
}

/**
 * Lae konkreetse sündmuse meeldetuletused
 */
function getEventReminders($pdo, $user_id) {
    $event_id = $_GET['event_id'] ?? null;
    
    if (!$event_id) {
        sendError('Sündmuse ID on nõutav');
    }
    
    if (!$user_id) {
        sendError('Kasutaja ID on nõutav');
    }
    
    try {
        // Kontrolli, kas sündmus kuulub kasutajale
        $stmt = $pdo->prepare("SELECT id FROM events WHERE id = ? AND user_id = ?");
        $stmt->execute([$event_id, $user_id]);
        if (!$stmt->fetch()) {
            sendError('Sündmust ei leitud või puuduvad õigused', 404);
        }
        
        // Lae sündmuse meeldetuletused
        $stmt = $pdo->prepare("
            SELECT 
                r.*,
                e.title as event_title,
                e.start_datetime as event_start
            FROM event_reminders r
            INNER JOIN events e ON r.event_id = e.id
            WHERE r.event_id = ? AND r.is_enabled = 1
            ORDER BY r.reminder_datetime ASC
        ");
        
        $stmt->execute([$event_id]);
        $reminders = $stmt->fetchAll(PDO::FETCH_ASSOC);
        
        // Lisa täiendavat infot
        foreach ($reminders as &$reminder) {
            $reminder['is_pending'] = strtotime($reminder['reminder_datetime']) <= time() && !$reminder['sent_at'];
            $reminder['formatted_reminder_time'] = date('d.m.Y H:i', strtotime($reminder['reminder_datetime']));
            
            if ($reminder['is_recurring']) {
                $reminder['recurring_info'] = formatRecurringInfo($reminder);
            }
        }
        
        apiLog('Event reminders loaded', ['event_id' => $event_id, 'count' => count($reminders)]);
        sendSuccess($reminders);
        
    } catch (PDOException $e) {
        apiLog('Event reminders load error: ' . $e->getMessage());
        sendError('Sündmuse meeldetuletuste laadimine ebaõnnestus');
    }
}

/**
 * ======================
 * POST PÄRINGUTE KÄITLEMINE - PARANDATUD EXACT_TIME TUGIGA!
 * ======================
 */
function handlePostRequest($pdo, $user_id, $action) {
    if ($action === 'mark_sent') {
        markReminderAsSentByUser($pdo, $user_id);
    } else if ($action === 'process') {
        processRemindersAPI($pdo);
    } else {
        createReminder($pdo, $user_id);
    }
}

/**
 * Loo uus meeldetuletus - KRITILISELT PARANDATUD!
 */
function createReminder($pdo, $user_id) {
    if (!$user_id) {
        sendError('Sisselogimine nõutav', 401);
    }
    
    $input = json_decode(file_get_contents('php://input'), true);
    apiLog('🎯 POST reminder data received', $input);
    
    if (!$input) {
        sendError('Vigased sisendandmed - JSON parsimise viga');
    }
    
    // PARANDATUD VALIDEERIMISED
    if (empty($input['event_id'])) {
        sendError('Sündmuse ID on nõutav');
    }
    
    if (empty($input['custom_message'])) {
        sendError('Meeldetuletuse tekst on nõutav');
    }
    
    // PARANDATUD KONTROLL: Kas antud exact_time VÕI minutes_before (mitte mõlemad!)
    $hasExactTime = !empty($input['exact_time']);
    $hasMinutesBefore = !empty($input['minutes_before']);
    
    apiLog('🔍 Reminder time validation', [
        'exact_time' => $input['exact_time'] ?? 'NOT SET',
        'minutes_before' => $input['minutes_before'] ?? 'NOT SET',
        'hasExactTime' => $hasExactTime,
        'hasMinutesBefore' => $hasMinutesBefore
    ]);
    
    if (!$hasExactTime && !$hasMinutesBefore) {
        sendError('Kas täpne kellaaeg või minutid enne peab olema määratud');
    }
    
    try {
        // Kontrolli, kas sündmus kuulub kasutajale
        $stmt = $pdo->prepare("
            SELECT id, title, start_datetime FROM events 
            WHERE id = ? AND user_id = ?
        ");
        $stmt->execute([$input['event_id'], $user_id]);
        $event = $stmt->fetch(PDO::FETCH_ASSOC);
        
        if (!$event) {
            sendError('Sündmust ei leitud või puuduvad õigused', 404);
        }
        
        // KRITILISELT PARANDATUD: Arvuta meeldetuletuse kellaaeg
        $reminder_datetime = calculateReminderTime($input, $event['start_datetime']);
        
        if (!$reminder_datetime) {
            sendError('Vigane meeldetuletuse aja arvutus');
        }
        
        apiLog('📅 Calculated reminder datetime', [
            'event_start' => $event['start_datetime'],
            'calculated_reminder_datetime' => $reminder_datetime,
            'exact_time_input' => $input['exact_time'] ?? 'N/A',
            'minutes_before_input' => $input['minutes_before'] ?? 'N/A'
        ]);
        
        // Ära loo möödunud meeldetuletusi (kui pole korduv)
        if (!($input['is_recurring'] ?? false) && strtotime($reminder_datetime) <= time()) {
            sendError('Meeldetuletuse aeg ei saa olla minevikus');
        }
        
        // Lisa meeldetuletus
        $stmt = $pdo->prepare("
            INSERT INTO event_reminders (
                event_id, custom_message, reminder_datetime, minutes_before,
                is_recurring, recurring_type, recurring_interval, recurring_end_date,
                is_enabled, created_at, updated_at
            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, 1, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP)
        ");
        
        $stmt->execute([
            $input['event_id'],
            trim($input['custom_message']),
            $reminder_datetime,
            $input['minutes_before'] ?? 60, // Vaikimisi 60 kui exact_time kasutatud
            ($input['is_recurring'] ?? false) ? 1 : 0,
            $input['recurring_type'] ?? null,
            $input['recurring_interval'] ?? 1,
            $input['recurring_end_date'] ?? null
        ]);
        
        $reminder_id = $pdo->lastInsertId();
        
        apiLog('✅ Reminder created successfully', [
            'reminder_id' => $reminder_id,
            'event_id' => $input['event_id'],
            'user_id' => $user_id,
            'reminder_datetime' => $reminder_datetime
        ]);
        
        sendSuccess(['id' => $reminder_id], 'Meeldetuletus edukalt lisatud!');
        
    } catch (PDOException $e) {
        apiLog('Reminder creation database error: ' . $e->getMessage());
        sendError('Andmebaasi viga: ' . $e->getMessage());
    } catch (Exception $e) {
        apiLog('Reminder creation general error: ' . $e->getMessage());
        sendError('Meeldetuletuse lisamine ebaõnnestus: ' . $e->getMessage());
    }
}

/**
 * ======================
 * PUT PÄRINGUTE KÄITLEMINE
 * ======================
 */
function handlePutRequest($pdo, $user_id) {
    $input = json_decode(file_get_contents('php://input'), true);
    
    apiLog('PUT reminder data', $input);
    
    if (!$input || empty($input['id'])) {
        sendError('Meeldetuletuse ID on nõutav');
    }
    
    $reminder_id = $input['id'];
    
    try {
        // Kontrolli, kas meeldetuletus kuulub kasutajale
        $stmt = $pdo->prepare("
            SELECT r.*, e.user_id, e.start_datetime
            FROM event_reminders r
            INNER JOIN events e ON r.event_id = e.id
            WHERE r.id = ? AND e.user_id = ?
        ");
        $stmt->execute([$reminder_id, $user_id]);
        $reminder = $stmt->fetch(PDO::FETCH_ASSOC);
        
        if (!$reminder) {
            sendError('Meeldetuletust ei leitud või puuduvad õigused', 404);
        }
        
        // Arvuta uus meeldetuletuse kellaaeg
        $reminder_datetime = calculateReminderTime($input, $reminder['start_datetime']);
        
        // Uuenda meeldetuletust
        $stmt = $pdo->prepare("
            UPDATE event_reminders SET 
                custom_message = ?, 
                reminder_datetime = ?, 
                minutes_before = ?,
                is_recurring = ?, 
                recurring_type = ?, 
                recurring_interval = ?, 
                recurring_end_date = ?,
                is_enabled = ?,
                updated_at = CURRENT_TIMESTAMP
            WHERE id = ?
        ");
        
        $stmt->execute([
            trim($input['custom_message']),
            $reminder_datetime,
            $input['minutes_before'] ?? 60,
            ($input['is_recurring'] ?? false) ? 1 : 0,
            $input['recurring_type'] ?? null,
            $input['recurring_interval'] ?? 1,
            $input['recurring_end_date'] ?? null,
            isset($input['is_enabled']) ? ($input['is_enabled'] ? 1 : 0) : 1,
            $reminder_id
        ]);
        
        apiLog('Reminder updated', [
            'reminder_id' => $reminder_id,
            'user_id' => $user_id
        ]);
        
        sendSuccess(['id' => $reminder_id], 'Meeldetuletus edukalt uuendatud!');
        
    } catch (PDOException $e) {
        apiLog('Reminder update error: ' . $e->getMessage());
        sendError('Meeldetuletuse uuendamine ebaõnnestus');
    }
}

/**
 * ======================
 * DELETE PÄRINGUTE KÄITLEMINE
 * ======================
 */
function handleDeleteRequest($pdo, $user_id) {
    $input = json_decode(file_get_contents('php://input'), true);
    $reminder_id = $input['id'] ?? $_GET['id'] ?? null;
    
    apiLog('DELETE reminder request', ['reminder_id' => $reminder_id]);
    
    if (!$reminder_id) {
        sendError('Meeldetuletuse ID on nõutav');
    }
    
    try {
        // Kontrolli, kas meeldetuletus kuulub kasutajale
        $stmt = $pdo->prepare("
            SELECT r.id, e.user_id 
            FROM event_reminders r
            INNER JOIN events e ON r.event_id = e.id
            WHERE r.id = ? AND e.user_id = ?
        ");
        $stmt->execute([$reminder_id, $user_id]);
        
        if (!$stmt->fetch()) {
            sendError('Meeldetuletust ei leitud või puuduvad õigused', 404);
        }
        
        // Kustuta meeldetuletus
        $stmt = $pdo->prepare("DELETE FROM event_reminders WHERE id = ?");
        $stmt->execute([$reminder_id]);
        
        apiLog('Reminder deleted', [
            'reminder_id' => $reminder_id,
            'user_id' => $user_id
        ]);
        
        sendSuccess([], 'Meeldetuletus edukalt kustutatud!');
        
    } catch (PDOException $e) {
        apiLog('Reminder deletion error: ' . $e->getMessage());
        sendError('Meeldetuletuse kustutamine ebaõnnestus');
    }
}

/**
 * ======================
 * HELPER FUNKTSIOONID - KRITILISELT PARANDATUD!
 * ======================
 */

/**
 * Arvuta meeldetuletuse kellaaeg - TÄIELIKULT ÜMBER KIRJUTATUD!
 */
function calculateReminderTime($input, $event_start_datetime) {
    apiLog('🧮 calculateReminderTime called', [
        'input_exact_time' => $input['exact_time'] ?? 'NOT SET',
        'input_minutes_before' => $input['minutes_before'] ?? 'NOT SET',
        'event_start_datetime' => $event_start_datetime
    ]);
    
    // ESMATÄHTIS: Kui on määratud täpne kellaaeg, kasuta seda
    if (!empty($input['exact_time'])) {
        $exactTime = $input['exact_time'];
        
        // Valideeri exact_time formaati
        $testTime = strtotime($exactTime);
        if ($testTime === false) {
            apiLog('❌ Invalid exact_time format', ['exact_time' => $exactTime]);
            return null;
        }
        
        // Konverdi õigesse formaati
        $formattedTime = date('Y-m-d H:i:s', $testTime);
        
        apiLog('🎯 Using EXACT TIME', [
            'input_exact_time' => $exactTime,
            'formatted_exact_time' => $formattedTime
        ]);
        
        return $formattedTime;
    }
    
    // SEKUNDAARNE: Kui on määratud minutid enne
    if (!empty($input['minutes_before'])) {
        $event_time = strtotime($event_start_datetime);
        if ($event_time === false) {
            apiLog('❌ Invalid event start time', ['event_start_datetime' => $event_start_datetime]);
            return null;
        }
        
        $minutes_before = (int)$input['minutes_before'];
        $reminder_time = $event_time - ($minutes_before * 60);
        $formattedTime = date('Y-m-d H:i:s', $reminder_time);
        
        apiLog('⏰ Using MINUTES BEFORE', [
            'minutes_before' => $minutes_before,
            'event_time' => date('Y-m-d H:i:s', $event_time),
            'calculated_reminder_time' => $formattedTime
        ]);
        
        return $formattedTime;
    }
    
    apiLog('❌ No valid time specification found');
    return null;
}

/**
 * Vormista korduvuse info
 */
function formatRecurringInfo($reminder) {
    $type_names = [
        'daily' => 'päev',
        'weekly' => 'nädal', 
        'monthly' => 'kuu'
    ];
    
    $type_name = $type_names[$reminder['recurring_type']] ?? $reminder['recurring_type'];
    $interval = $reminder['recurring_interval'];
    
    if ($interval == 1) {
        return "Iga {$type_name}";
    } else {
        return "Iga {$interval} {$type_name}";
    }
}

/**
 * Arvuta aeg sündmuseni
 */
function calculateTimeUntil($event_datetime) {
    $now = time();
    $event_time = strtotime($event_datetime);
    $diff = $event_time - $now;
    
    if ($diff <= 0) {
        return 'möödunud';
    }
    
    if ($diff < 3600) {
        return floor($diff / 60) . ' min';
    } elseif ($diff < 86400) {
        return floor($diff / 3600) . 'h ' . floor(($diff % 3600) / 60) . 'min';
    } else {
        return floor($diff / 86400) . ' päeva';
    }
}

/**
 * ======================
 * API FUNKTSIOONID
 * ======================
 */

/**
 * API kaudu meeldetuletuste töötlemine
 */
function processRemindersAPI($pdo) {
    try {
        // Kasuta sama loogika mis cron job'is
        $reminders = getPendingRemindersForAPI($pdo);
        
        $processed = 0;
        $sent = 0;
        $errors = 0;
        
        foreach ($reminders as $reminder) {
            $processed++;
            
            // Siin võiks olla meili saatmise loogika, 
            // aga API kaudu üldjuhul ei saada meile
            // ainult märgime saadetud kui see on test
            if (isset($_GET['test']) && $_GET['test'] == 'true') {
                // Test režiimis märgi lihtsalt saadetud
                markReminderAsSentAPI($pdo, $reminder['reminder_id']);
                $sent++;
            }
        }
        
        apiLog('API reminder processing completed', [
            'processed' => $processed,
            'sent' => $sent,
            'errors' => $errors
        ]);
        
        sendSuccess([
            'processed' => $processed,
            'sent' => $sent,
            'errors' => $errors,
            'reminders' => $reminders
        ], 'Meeldetuletuste töötlemine lõpetatud');
        
    } catch (Exception $e) {
        apiLog('API reminder processing error: ' . $e->getMessage());
        sendError('Meeldetuletuste töötlemine ebaõnnestus: ' . $e->getMessage());
    }
}

/**
 * Lae ootel meeldetuletused API jaoks
 */
function getPendingRemindersForAPI($pdo) {
    try {
        $stmt = $pdo->prepare("
            SELECT 
                r.id as reminder_id,
                r.custom_message,
                r.reminder_datetime,
                r.minutes_before,
                e.id as event_id,
                e.user_id,
                e.title as event_title,
                e.start_datetime as event_start,
                u.email as user_email,
                u.firstName,
                u.lastName
            FROM event_reminders r
            INNER JOIN events e ON r.event_id = e.id
            INNER JOIN users u ON e.user_id = u.id
            WHERE r.is_enabled = 1 
            AND r.sent_at IS NULL
            AND r.reminder_datetime <= datetime('now', 'localtime')
            AND e.start_datetime > datetime('now', 'localtime')
            AND u.email IS NOT NULL
            AND u.email != ''
            ORDER BY r.reminder_datetime ASC
            LIMIT 20
        ");
        
        $stmt->execute();
        $reminders = $stmt->fetchAll(PDO::FETCH_ASSOC);
        
        return $reminders;
        
    } catch (PDOException $e) {
        apiLog('Error getting pending reminders for API: ' . $e->getMessage());
        return [];
    }
}

/**
 * API kaudu ootel meeldetuletuste kuvamine
 */
function getPendingRemindersAPI($pdo, $user_id) {
    try {
        $reminders = getPendingRemindersForAPI($pdo);
        
        // Filtreeri kasutaja järgi kui user_id on antud
        if ($user_id) {
            $reminders = array_filter($reminders, function($reminder) use ($user_id) {
                return $reminder['user_id'] == $user_id;
            });
        }
        
        sendSuccess(array_values($reminders), 'Ootel meeldetuletused laaditud');
        
    } catch (Exception $e) {
        apiLog('Error getting pending reminders API: ' . $e->getMessage());
        sendError('Ootel meeldetuletuste laadimine ebaõnnestus');
    }
}

/**
 * Märgi meeldetuletus saadetud API kaudu
 */
function markReminderAsSentAPI($pdo, $reminder_id) {
    try {
        $stmt = $pdo->prepare("
            UPDATE event_reminders 
            SET sent_at = datetime('now', 'localtime'), 
                sent_count = sent_count + 1,
                last_error = NULL,
                updated_at = datetime('now', 'localtime')
            WHERE id = ?
        ");
        return $stmt->execute([$reminder_id]);
    } catch (PDOException $e) {
        apiLog('Error marking reminder as sent via API: ' . $e->getMessage());
        return false;
    }
}

/**
 * Märgi meeldetuletus saadetud kasutaja poolt
 */
function markReminderAsSentByUser($pdo, $user_id) {
    $input = json_decode(file_get_contents('php://input'), true);
    $reminder_id = $input['reminder_id'] ?? null;
    
    if (!$reminder_id) {
        sendError('Meeldetuletuse ID on nõutav');
    }
    
    try {
        // Kontrolli kas kuulub kasutajale
        $stmt = $pdo->prepare("
            SELECT r.id 
            FROM event_reminders r
            INNER JOIN events e ON r.event_id = e.id
            WHERE r.id = ? AND e.user_id = ?
        ");
        $stmt->execute([$reminder_id, $user_id]);
        
        if (!$stmt->fetch()) {
            sendError('Meeldetuletust ei leitud või puuduvad õigused', 404);
        }
        
        // Märgi saadetud
        if (markReminderAsSentAPI($pdo, $reminder_id)) {
            sendSuccess([], 'Meeldetuletus märgitud saadetud');
        } else {
            sendError('Meeldetuletuse märkimine ebaõnnestus');
        }
        
    } catch (Exception $e) {
        apiLog('Error marking reminder as sent by user: ' . $e->getMessage());
        sendError('Meeldetuletuse märkimine ebaõnnestus');
    }
}

/**
 * Meeldetuletuste statistika
 */
function getReminderStats($pdo, $user_id) {
    if (!$user_id) {
        sendError('Kasutaja ID on nõutav');
    }
    
    try {
        // Põhistatistika
        $stmt = $pdo->prepare("
            SELECT 
                COUNT(*) as total_reminders,
                SUM(CASE WHEN sent_at IS NOT NULL THEN 1 ELSE 0 END) as sent_reminders,
                SUM(CASE WHEN sent_at IS NULL AND reminder_datetime <= datetime('now') THEN 1 ELSE 0 END) as pending_reminders,
                SUM(CASE WHEN last_error IS NOT NULL THEN 1 ELSE 0 END) as failed_reminders
            FROM event_reminders r
            INNER JOIN events e ON r.event_id = e.id
            WHERE e.user_id = ? AND r.is_enabled = 1
        ");
        $stmt->execute([$user_id]);
        $stats = $stmt->fetch(PDO::FETCH_ASSOC);
        
        sendSuccess($stats, 'Statistika laaditud');
        
    } catch (PDOException $e) {
        apiLog('Error getting reminder stats: ' . $e->getMessage());
        sendError('Statistika laadimine ebaõnnestus');
    }
}
?>