// tests/adresar/put_adresar_test.rs
use rstest::{fixture, rstest};
use server::adresar::handlers::put_adresar;
use common::proto::multieko2::adresar::PutAdresarRequest;
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]
async fn existing_record(#[future] pool: PgPool) -> (PgPool, i64) {
    let pool = pool.await;
    
    // Create a test record in the database
    let record = sqlx::query!(
        r#"
        INSERT INTO adresar (
            firma, kz, drc, ulica, psc, mesto, stat, banka, ucet,
            skladm, ico, kontakt, telefon, skladu, fax, deleted
        )
        VALUES (
            'Original Company', 'Original KZ', 'Original DRC', 'Original Street',
            '12345', 'Original City', 'Original Country', 'Original Bank',
            'Original Account', 'Original SkladM', 'Original ICO',
            'Original Contact', '+421123456789', 'Original SkladU', 'Original Fax',
            false
        )
        RETURNING id
        "#
    )
    .fetch_one(&pool)
    .await
    .unwrap();

    (pool, record.id)
}

#[fixture]
fn valid_request_template() -> PutAdresarRequest {
    PutAdresarRequest {
        id: 0, // This will be replaced in each test
        firma: "Updated Company".into(),
        kz: "Updated KZ".into(),
        drc: "Updated DRC".into(),
        ulica: "Updated Street".into(),
        psc: "67890".into(),
        mesto: "Updated City".into(),
        stat: "Updated Country".into(),
        banka: "Updated Bank".into(),
        ucet: "987654321".into(),
        skladm: "Updated SkladM".into(),
        ico: "87654321".into(),
        kontakt: "Jane Doe".into(),
        telefon: "+421987654321".into(),
        skladu: "Updated SkladU".into(),
        fax: "+421987654300".into(),
    }
}

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

    assert_eq!(db_record.firma, response.firma);
    assert_eq!(db_record.kz.unwrap_or_default(), response.kz);
    assert_eq!(db_record.drc.unwrap_or_default(), response.drc);
    assert_eq!(db_record.ulica.unwrap_or_default(), response.ulica);
    assert_eq!(db_record.psc.unwrap_or_default(), response.psc);
    assert_eq!(db_record.mesto.unwrap_or_default(), response.mesto);
    assert_eq!(db_record.stat.unwrap_or_default(), response.stat);
    assert_eq!(db_record.banka.unwrap_or_default(), response.banka);
    assert_eq!(db_record.ucet.unwrap_or_default(), response.ucet);
    assert_eq!(db_record.skladm.unwrap_or_default(), response.skladm);
    assert_eq!(db_record.ico.unwrap_or_default(), response.ico);
    assert_eq!(db_record.kontakt.unwrap_or_default(), response.kontakt);
    assert_eq!(db_record.telefon.unwrap_or_default(), response.telefon);
    assert_eq!(db_record.skladu.unwrap_or_default(), response.skladu);
    assert_eq!(db_record.fax.unwrap_or_default(), response.fax);
    assert!(!db_record.deleted, "Record should not be deleted");
}

// Tests
#[rstest]
#[tokio::test]
async fn test_update_adresar_success(#[future] existing_record: (PgPool, i64), valid_request_template: PutAdresarRequest) {
    let (pool, id) = existing_record.await;
    
    let mut request = valid_request_template;
    request.id = id;
    
    let response = put_adresar(&pool, request).await.unwrap();

    assert_eq!(response.id, id);
    assert_response_matches(&pool, id, &response).await;
}

#[rstest]
#[tokio::test]
async fn test_update_whitespace_fields(#[future] existing_record: (PgPool, i64), valid_request_template: PutAdresarRequest) {
    let (pool, id) = existing_record.await;
    
    let mut request = valid_request_template;
    request.id = id;
    request.firma = "  Updated Company  ".into();
    request.telefon = "  +421987654321  ".into();

    let response = put_adresar(&pool, request).await.unwrap();

    // Verify trimmed values in response
    assert_eq!(response.firma, "Updated Company");
    assert_eq!(response.telefon, "+421987654321");

    // Verify raw values in database
    let db_record = sqlx::query!("SELECT firma, telefon FROM adresar WHERE id = $1", id)
        .fetch_one(&pool)
        .await
        .unwrap();

    assert_eq!(db_record.firma, "Updated Company"); // Trimmed
    assert_eq!(db_record.telefon.unwrap(), "+421987654321"); // Trimmed
}

#[rstest]
#[tokio::test]
async fn test_update_empty_required_field(#[future] existing_record: (PgPool, i64), valid_request_template: PutAdresarRequest) {
    let (pool, id) = existing_record.await;
    
    let mut request = valid_request_template;
    request.id = id;
    request.firma = "".into();

    let result = put_adresar(&pool, request).await;
    assert!(result.is_err());
    assert_eq!(result.unwrap_err().code(), tonic::Code::InvalidArgument);
}

#[rstest]
#[tokio::test]
async fn test_update_nonexistent_id(#[future] pool: PgPool) {
    let pool = pool.await;
    
    let request = PutAdresarRequest {
        id: 9999, // Non-existent ID
        firma: "Updated Company".into(),
        kz: "Updated KZ".into(),
        drc: "Updated DRC".into(),
        ulica: "Updated Street".into(),
        psc: "67890".into(),
        mesto: "Updated City".into(),
        stat: "Updated Country".into(),
        banka: "Updated Bank".into(),
        ucet: "987654321".into(),
        skladm: "Updated SkladM".into(),
        ico: "87654321".into(),
        kontakt: "Jane Doe".into(),
        telefon: "+421987654321".into(),
        skladu: "Updated SkladU".into(),
        fax: "+421987654300".into(),
    };

    let result = put_adresar(&pool, request).await;
    assert!(result.is_err());
    assert_eq!(result.unwrap_err().code(), tonic::Code::Internal);
}

#[rstest]
#[tokio::test]
async fn test_update_deleted_record(#[future] existing_record: (PgPool, i64), valid_request_template: PutAdresarRequest) {
    let (pool, id) = existing_record.await;
    
    // Mark the record as deleted
    sqlx::query!("UPDATE adresar SET deleted = true WHERE id = $1", id)
        .execute(&pool)
        .await
        .unwrap();

    let mut request = valid_request_template;
    request.id = id;

    let result = put_adresar(&pool, request).await;
    assert!(result.is_err());
    assert_eq!(result.unwrap_err().code(), tonic::Code::Internal);
}

#[rstest]
#[tokio::test]
async fn test_clear_optional_fields(#[future] existing_record: (PgPool, i64), valid_request_template: PutAdresarRequest) {
    let (pool, id) = existing_record.await;
    
    let mut request = valid_request_template;
    request.id = id;
    request.telefon = String::new();
    request.ulica = String::new();

    let response = put_adresar(&pool, request).await.unwrap();

    // Check response contains empty strings
    assert!(response.telefon.is_empty());
    assert!(response.ulica.is_empty());

    // Check database contains NULL
    let db_record = sqlx::query!("SELECT telefon, ulica FROM adresar WHERE id = $1", id)
        .fetch_one(&pool)
        .await
        .unwrap();

    assert!(db_record.telefon.is_none());
    assert!(db_record.ulica.is_none());
}

#[rstest]
#[tokio::test]
async fn test_max_length_fields(#[future] existing_record: (PgPool, i64), valid_request_template: PutAdresarRequest) {
    let (pool, id) = existing_record.await;
    
    let mut request = valid_request_template;
    request.id = id;
    request.firma = "a".repeat(255);
    request.telefon = "1".repeat(20);

    let _response = put_adresar(&pool, request).await.unwrap();

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

    assert_eq!(db_record.firma.len(), 255);
    assert_eq!(db_record.telefon.unwrap().len(), 20);
}

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

    let _response = put_adresar(&pool, request).await.unwrap();

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

    assert_eq!(db_record.ulica.unwrap(), "Náměstí 28. října");
    assert_eq!(db_record.telefon.unwrap(), "+420 123-456.789");
}