mod common;

use axum::http::StatusCode;
use common::*;

// ═══════════════════════════════════════════════════════════════════
// Report telemetry
// ═══════════════════════════════════════════════════════════════════

#[tokio::test]
async fn telemetry_report_success() {
    let (app, _pool) = build_test_app().await;
    let token = register_token(&app, "teluser").await;
    let now = chrono::Utc::now().to_rfc3339();

    let (status, body) = send(
        &app,
        post(
            "/api/v1/telemetry/report",
            &token,
            serde_json::json!({
                "device_id": "test-device-001",
                "app_version": "0.1.0",
                "entries": [{
                    "model_id": "test-model-v1",
                    "input_tokens": 100,
                    "output_tokens": 50,
                    "latency_ms": 200,
                    "success": true,
                    "timestamp": now,
                    "connection_mode": "tauri"
                }]
            }),
        ),
    ).await;
    assert_eq!(status, StatusCode::OK, "report telemetry: {body}");
    assert_eq!(body["accepted"], 1);
    assert_eq!(body["rejected"], 0);
}

#[tokio::test]
async fn telemetry_report_batch() {
    let (app, _pool) = build_test_app().await;
    let token = register_token(&app, "telbatch").await;
    let now = chrono::Utc::now().to_rfc3339();

    let entries: Vec<serde_json::Value> = (0..5)
        .map(|i| {
            serde_json::json!({
                "model_id": format!("model-{i}"),
                "input_tokens": 100 + i,
                "output_tokens": 50 + i,
                "success": true,
                "timestamp": now,
                "connection_mode": "tauri"
            })
        })
        .collect();

    let (status, body) = send(
        &app,
        post(
            "/api/v1/telemetry/report",
            &token,
            serde_json::json!({
                "device_id": "batch-device",
                "app_version": "0.1.0",
                "entries": entries
            }),
        ),
    ).await;
    assert_eq!(status, StatusCode::OK);
    assert_eq!(body["accepted"], 5);
}

// ═══════════════════════════════════════════════════════════════════
// Stats query
// ═══════════════════════════════════════════════════════════════════

#[tokio::test]
async fn telemetry_stats() {
    let (app, _pool) = build_test_app().await;
    let token = register_token(&app, "telstats").await;
    let (status, _) = send(&app, get("/api/v1/telemetry/stats", &token)).await;
    assert_eq!(status, StatusCode::OK);
}

#[tokio::test]
async fn telemetry_daily() {
    let (app, _pool) = build_test_app().await;
    let token = register_token(&app, "teldaily").await;
    let (status, _) = send(&app, get("/api/v1/telemetry/daily", &token)).await;
    assert_eq!(status, StatusCode::OK);
}

// ═══════════════════════════════════════════════════════════════════
// Audit summary
// ═══════════════════════════════════════════════════════════════════

#[tokio::test]
async fn telemetry_audit_report() {
    let (app, _pool) = build_test_app().await;
    let token = register_token(&app, "telaudit").await;
    let now = chrono::Utc::now().to_rfc3339();

    let (status, _) = send(
        &app,
        post(
            "/api/v1/telemetry/audit",
            &token,
            serde_json::json!({
                "device_id": "audit-device",
                "entries": [{
                    "action": "hand.trigger",
                    "target": "Browser",
                    "result": "success",
                    "timestamp": now
                }]
            }),
        ),
    ).await;
    assert_eq!(status, StatusCode::OK);
}