use actix_web::{test, web, App, HttpResponse};

/// Простой тест health check
#[actix_web::test]
async fn test_health_check() {
    let app = test::init_service(App::new().route(
        "/",
        web::get().to(|req: actix_web::HttpRequest| async move {
            match req.method().as_str() {
                "GET" => Ok::<HttpResponse, actix_web::Error>(
                    HttpResponse::Ok().content_type("text/plain").body("ok"),
                ),
                _ => {
                    Ok::<HttpResponse, actix_web::Error>(HttpResponse::MethodNotAllowed().finish())
                }
            }
        }),
    ))
    .await;

    // Тестируем GET запрос
    let req = test::TestRequest::get().uri("/").to_request();

    let resp = test::call_service(&app, req).await;
    assert!(resp.status().is_success());

    let body = test::read_body(resp).await;
    assert_eq!(body, "ok");

    // Тестируем POST запрос (должен вернуть 405)
    let req = test::TestRequest::post().uri("/").to_request();

    let resp = test::call_service(&app, req).await;
    assert_eq!(resp.status(), actix_web::http::StatusCode::NOT_FOUND);
}

/// Тест для проверки JSON сериализации/десериализации
#[test]
async fn test_json_serialization() {
    #[derive(serde::Serialize, serde::Deserialize, PartialEq, Debug)]
    struct TestStruct {
        user_id: String,
        current_quota: u64,
        max_quota: u64,
    }

    let test_data = TestStruct {
        user_id: "test-user-123".to_string(),
        current_quota: 1024,
        max_quota: 5368709120, // 5 GB
    };

    // Сериализация
    let json_string = serde_json::to_string(&test_data).unwrap();
    assert!(json_string.contains("test-user-123"));
    assert!(json_string.contains("1024"));
    assert!(json_string.contains("5368709120"));

    // Десериализация
    let deserialized: TestStruct = serde_json::from_str(&json_string).unwrap();
    assert_eq!(deserialized, test_data);
}

/// Тест для проверки multipart form data
#[test]
async fn test_multipart_form_data() {
    let boundary = "test-boundary";
    let filename = "test.png";
    let content = b"fake image data";

    let mut form_data = Vec::new();

    // Начало multipart
    form_data.extend_from_slice(format!("--{}\r\n", boundary).as_bytes());
    form_data.extend_from_slice(
        format!(
            "Content-Disposition: form-data; name=\"file\"; filename=\"{}\"\r\n",
            filename
        )
        .as_bytes(),
    );
    form_data.extend_from_slice(b"Content-Type: image/png\r\n\r\n");

    // Содержимое файла
    form_data.extend_from_slice(content);
    form_data.extend_from_slice(b"\r\n");

    // Конец multipart
    form_data.extend_from_slice(format!("--{}--\r\n", boundary).as_bytes());

    // Проверяем, что form_data содержит ожидаемые части
    let form_data_str = String::from_utf8_lossy(&form_data);
    assert!(form_data_str.contains(filename));
    assert!(form_data_str.contains("image/png"));
    assert!(form_data_str.contains("fake image data"));
    assert!(form_data_str.contains(&format!("--{}", boundary)));
}

/// Тест для проверки UUID генерации
#[test]
async fn test_uuid_generation() {
    use uuid::Uuid;

    let uuid1 = Uuid::new_v4();
    let uuid2 = Uuid::new_v4();

    // UUID должны быть разными
    assert_ne!(uuid1, uuid2);

    // UUID должны быть в правильном формате
    let uuid_str = uuid1.to_string();
    assert_eq!(uuid_str.len(), 36); // 32 символа + 4 дефиса
    assert!(uuid_str.contains('-'));

    // Проверяем, что UUID можно парсить обратно
    let parsed_uuid = Uuid::parse_str(&uuid_str).unwrap();
    assert_eq!(parsed_uuid, uuid1);
}

/// Тест для проверки MIME типов
#[test]
async fn test_mime_type_detection() {
    // Тестируем определение MIME типа по расширению
    let get_mime_type = |ext: &str| -> Option<&'static str> {
        match ext.to_lowercase().as_str() {
            "jpg" | "jpeg" => Some("image/jpeg"),
            "png" => Some("image/png"),
            "gif" => Some("image/gif"),
            "webp" => Some("image/webp"),
            "mp3" => Some("audio/mpeg"),
            "wav" => Some("audio/wav"),
            "mp4" => Some("video/mp4"),
            _ => None,
        }
    };

    assert_eq!(get_mime_type("jpg"), Some("image/jpeg"));
    assert_eq!(get_mime_type("jpeg"), Some("image/jpeg"));
    assert_eq!(get_mime_type("png"), Some("image/png"));
    assert_eq!(get_mime_type("gif"), Some("image/gif"));
    assert_eq!(get_mime_type("webp"), Some("image/webp"));
    assert_eq!(get_mime_type("mp3"), Some("audio/mpeg"));
    assert_eq!(get_mime_type("wav"), Some("audio/wav"));
    assert_eq!(get_mime_type("mp4"), Some("video/mp4"));
    assert_eq!(get_mime_type("pdf"), None);
    assert_eq!(get_mime_type(""), None);
}

/// Тест для проверки парсинга путей файлов
#[test]
async fn test_file_path_parsing() {
    fn parse_file_path(path: &str) -> (String, u32, String) {
        let parts: Vec<&str> = path.split('.').collect();
        if parts.len() != 2 {
            return (path.to_string(), 0, "".to_string());
        }

        let base_with_width = parts[0];
        let ext = parts[1];

        // Ищем ширину в формате _NUMBER
        let base_parts: Vec<&str> = base_with_width.split('_').collect();
        if base_parts.len() >= 2 {
            if let Ok(width) = base_parts.last().unwrap().parse::<u32>() {
                let base = base_parts[..base_parts.len() - 1].join("_");
                return (base, width, ext.to_string());
            }
        }

        (base_with_width.to_string(), 0, ext.to_string())
    }

    let (base, width, ext) = parse_file_path("image_300.jpg");
    assert_eq!(base, "image");
    assert_eq!(width, 300);
    assert_eq!(ext, "jpg");

    let (base, width, ext) = parse_file_path("document.pdf");
    assert_eq!(base, "document");
    assert_eq!(width, 0);
    assert_eq!(ext, "pdf");

    let (base, width, ext) = parse_file_path("file_with_underscore_but_no_width.jpg");
    assert_eq!(base, "file_with_underscore_but_no_width");
    assert_eq!(width, 0);
    assert_eq!(ext, "jpg");
}

/// Тест для проверки расчетов квот
#[test]
async fn test_quota_calculations() {
    const MAX_QUOTA_BYTES: u64 = 5 * 1024 * 1024 * 1024; // 5 ГБ
    const MB: u64 = 1024 * 1024;
    const GB: u64 = 1024 * 1024 * 1024;

    // Тестируем различные сценарии
    let test_cases = vec![
        (0, 1 * MB, true),       // Пустая квота + 1MB = OK
        (1 * GB, 1 * MB, true),  // 1GB + 1MB = OK
        (4 * GB, 1 * GB, true),  // 4GB + 1GB = OK
        (4 * GB, 2 * GB, false), // 4GB + 2GB = превышение
        (5 * GB, 1 * MB, false), // 5GB + 1MB = превышение
    ];

    for (current_quota, file_size, should_allow) in test_cases {
        let would_exceed = current_quota + file_size > MAX_QUOTA_BYTES;
        assert_eq!(
            would_exceed,
            !should_allow,
            "Квота: {} + файл: {} = {}, должно быть разрешено: {}",
            current_quota,
            file_size,
            current_quota + file_size,
            should_allow
        );
    }
}

/// Тест для проверки форматирования размеров файлов
#[test]
async fn test_file_size_formatting() {
    fn format_file_size(bytes: u64) -> String {
        const KB: u64 = 1024;
        const MB: u64 = 1024 * 1024;
        const GB: u64 = 1024 * 1024 * 1024;

        match bytes {
            0..KB => format!("{} B", bytes),
            KB..MB => format!("{:.1} KB", bytes as f64 / KB as f64),
            MB..GB => format!("{:.1} MB", bytes as f64 / MB as f64),
            _ => format!("{:.1} GB", bytes as f64 / GB as f64),
        }
    }

    assert_eq!(format_file_size(512), "512 B");
    assert_eq!(format_file_size(1024), "1.0 KB");
    assert_eq!(format_file_size(1536), "1.5 KB");
    assert_eq!(format_file_size(1024 * 1024), "1.0 MB");
    assert_eq!(format_file_size(1024 * 1024 * 1024), "1.0 GB");
    assert_eq!(format_file_size(5 * 1024 * 1024 * 1024), "5.0 GB");
}

/// Тест для проверки обработки ошибок
#[test]
async fn test_error_handling() {
    // Тестируем парсинг неверного JSON
    let invalid_json = "{ invalid json }";
    let result: Result<serde_json::Value, _> = serde_json::from_str(invalid_json);
    assert!(result.is_err());

    // Тестируем парсинг неполного JSON
    let incomplete_json = r#"{"user_id": "test"#;
    let result: Result<serde_json::Value, _> = serde_json::from_str(incomplete_json);
    assert!(result.is_err());

    // Тестируем неверный UUID
    use uuid::Uuid;
    let invalid_uuid = "not-a-uuid";
    let result = Uuid::parse_str(invalid_uuid);
    assert!(result.is_err());

    // Тестируем пустой UUID
    let empty_uuid = "";
    let result = Uuid::parse_str(empty_uuid);
    assert!(result.is_err());
}

/// Тест для проверки производительности
#[test]
async fn test_performance() {
    use std::time::Instant;

    // Тест UUID генерации
    let start = Instant::now();
    let iterations = 10000;

    for _ in 0..iterations {
        let _uuid = uuid::Uuid::new_v4();
    }

    let duration = start.elapsed();
    let avg_time = duration.as_nanos() as f64 / iterations as f64;

    println!(
        "UUID generation: {} UUIDs in {:?}, avg: {:.2} ns per UUID",
        iterations, duration, avg_time
    );

    // Проверяем, что среднее время меньше 1μs
    assert!(
        avg_time < 1000.0,
        "UUID generation too slow: {:.2} ns",
        avg_time
    );

    // Тест JSON сериализации
    let start = Instant::now();

    for _ in 0..iterations {
        let data = serde_json::json!({
            "user_id": "test-user-123",
            "current_quota": 1024,
            "max_quota": 5368709120u64
        });
        let _json_string = serde_json::to_string(&data).unwrap();
    }

    let duration = start.elapsed();
    let avg_time = duration.as_micros() as f64 / iterations as f64;

    println!(
        "JSON serialization: {} operations in {:?}, avg: {:.2} μs per operation",
        iterations, duration, avg_time
    );

    // Проверяем, что среднее время меньше 100μs
    assert!(
        avg_time < 100.0,
        "JSON serialization too slow: {:.2} μs",
        avg_time
    );
}