// tests/adresar/post_adresar_test.rs
use rstest::{fixture, rstest};
use server::adresar::handlers::post_adresar;
use common::proto::multieko2::adresar::PostAdresarRequest;
use crate::common::setup_test_db;
use sqlx::PgPool;
use tonic;

// Fixtures
#[fixture]
async fn pool() -> PgPool {
    setup_test_db().await
}

#[fixture]
async fn closed_pool(#[future] pool: PgPool) -> PgPool {
    let pool = pool.await;
    pool.close().await;
    pool
}

#[fixture]
fn valid_request() -> PostAdresarRequest {
    PostAdresarRequest {
        firma: "Test Company".into(),
        kz: "KZ123".into(),
        drc: "DRC456".into(),
        ulica: "Test Street".into(),
        psc: "12345".into(),
        mesto: "Test City".into(),
        stat: "Test Country".into(),
        banka: "Test Bank".into(),
        ucet: "123456789".into(),
        skladm: "Warehouse M".into(),
        ico: "12345678".into(),
        kontakt: "John Doe".into(),
        telefon: "+421123456789".into(),
        skladu: "Warehouse U".into(),
        fax: "+421123456700".into(),
    }
}

#[fixture]
fn minimal_request() -> PostAdresarRequest {
    PostAdresarRequest {
        firma: "Required Only".into(),
        ..Default::default()
    }
}

// Helper to check database state
async fn assert_response_matches(pool: &PgPool, response: &common::proto::multieko2::adresar::AdresarResponse) {
    let db_record = sqlx::query!("SELECT * FROM adresar WHERE id = $1", response.id)
        .fetch_one(pool)
        .await
        .unwrap();

    assert_eq!(db_record.firma, response.firma);
    assert_eq!(db_record.telefon.as_deref(), Some(response.telefon.as_str()));
    // Add assertions for other fields...
    assert!(!db_record.deleted);
    assert!(db_record.created_at.is_some());
}

// Tests
#[rstest]
#[tokio::test]
async fn test_create_adresar_success(#[future] pool: PgPool, valid_request: PostAdresarRequest) {
    let pool = pool.await;
    let response = post_adresar(&pool, valid_request).await.unwrap();

    assert!(response.id > 0);
    assert_eq!(response.firma, "Test Company");
    assert_response_matches(&pool, &response).await;
}

#[rstest]
#[tokio::test]
async fn test_create_adresar_whitespace_trimming(
    #[future] pool: PgPool,
    valid_request: PostAdresarRequest,
) {
    let pool = pool.await;
    let mut request = valid_request;
    request.firma = "  Test Company  ".into();
    request.telefon = "  +421123456789  ".into();
    request.ulica = "  Test Street  ".into();

    let response = post_adresar(&pool, request).await.unwrap();
    assert_eq!(response.firma, "Test Company");
    assert_eq!(response.telefon, "+421123456789");
    assert_eq!(response.ulica, "Test Street");
}

#[rstest]
#[tokio::test]
async fn test_create_adresar_empty_optional_fields(
    #[future] pool: PgPool,
    valid_request: PostAdresarRequest,
) {
    let pool = pool.await;
    let mut request = valid_request;
    request.telefon = "   ".into();

    let response = post_adresar(&pool, request).await.unwrap();
    let db_telefon = sqlx::query_scalar!("SELECT telefon FROM adresar WHERE id = $1", response.id)
        .fetch_one(&pool)
        .await
        .unwrap();

    assert!(db_telefon.is_none());
    assert_eq!(response.telefon, "");
}

#[rstest]
#[tokio::test]
async fn test_create_adresar_invalid_firma(
    #[future] pool: PgPool,
    valid_request: PostAdresarRequest,
) {
    let pool = pool.await;
    let mut request = valid_request;
    request.firma = "   ".into();
    let result = post_adresar(&pool, request).await;

    assert!(result.is_err());
    assert_eq!(result.unwrap_err().code(), tonic::Code::InvalidArgument);
}

#[rstest]
#[tokio::test]
async fn test_create_adresar_minimal_valid_request(
    #[future] pool: PgPool,
    minimal_request: PostAdresarRequest,
) {
    let pool = pool.await;
    let response = post_adresar(&pool, minimal_request).await.unwrap();

    assert!(response.id > 0);
    assert_eq!(response.firma, "Required Only");
    assert!(response.kz.is_empty());
    assert!(response.drc.is_empty());
}

#[rstest]
#[tokio::test]
async fn test_create_adresar_empty_firma(
    #[future] pool: PgPool,
    minimal_request: PostAdresarRequest,
) {
    let pool = pool.await;
    let mut request = minimal_request;
    request.firma = "".into();
    let result = post_adresar(&pool, request).await;

    assert!(result.is_err());
    assert_eq!(result.unwrap_err().code(), tonic::Code::InvalidArgument);
}

#[rstest]
#[tokio::test]
async fn test_create_adresar_database_error(
    #[future] closed_pool: PgPool,
    minimal_request: PostAdresarRequest,
) {
    let closed_pool = closed_pool.await;
    let result = post_adresar(&closed_pool, minimal_request).await;

    assert!(result.is_err());
    assert_eq!(result.unwrap_err().code(), tonic::Code::Internal);
}

#[rstest]
#[tokio::test]
async fn test_create_adresar_field_length_limits(
    #[future] pool: PgPool,
    valid_request: PostAdresarRequest,
) {
    let pool = pool.await;
    let mut request = valid_request;
    request.firma = "a".repeat(255);
    request.telefon = "1".repeat(20);

    let response = post_adresar(&pool, request).await.unwrap();
    assert_eq!(response.firma.len(), 255);
    assert_eq!(response.telefon.len(), 20);
}

#[rstest]
#[tokio::test]
async fn test_create_adresar_special_characters(
    #[future] pool: PgPool,
    valid_request: PostAdresarRequest,
) {
    let pool = pool.await;
    let mut request = valid_request;
    request.telefon = "+420 123-456.789".into();
    request.ulica = "Náměstí 28. října".into();

    let response = post_adresar(&pool, request.clone()).await.unwrap();
    assert_eq!(response.telefon, request.telefon);
    assert_eq!(response.ulica, request.ulica);
}

#[rstest]
#[tokio::test]
async fn test_create_adresar_optional_fields_null_vs_empty(
    #[future] pool: PgPool,
    valid_request: PostAdresarRequest,
) {
    let pool = pool.await;
    let mut request = valid_request;
    request.telefon = String::new();
    let response = post_adresar(&pool, request).await.unwrap();

    let db_telefon = sqlx::query_scalar!("SELECT telefon FROM adresar WHERE id = $1", response.id)
        .fetch_one(&pool)
        .await
        .unwrap();

    assert!(db_telefon.is_none());
}