pub mod contact {
    use sqlx::Row;

    pub async fn insert(
        pool: &sqlx::PgPool,
        contact: &textsender_models::contact::Contact,
    ) -> Result<uuid::Uuid, sqlx::Error> {
        match sqlx::query(
            r#"
        INSERT INTO "contacts" (firstname, lastname, nickname, phone_number, user_id) 
        VALUES($1, $2, $3, $4, $5) RETURNING id;
        "#,
        )
        .bind(&contact.firstname)
        .bind(&contact.lastname)
        .bind(&contact.nickname)
        .bind(&contact.phone_number)
        .bind(contact.user_id)
        .fetch_one(pool)
        .await
        {
            Ok(row) => {
                let id: uuid::Uuid = row.try_get("id")?;
                Ok(id)
            }
            Err(_) => Err(sqlx::Error::RowNotFound),
        }
    }

    pub async fn get(
        pool: &sqlx::PgPool,
        id: &uuid::Uuid,
    ) -> Result<textsender_models::contact::Contact, sqlx::Error> {
        match sqlx::query(
            r#"
        SELECT id, firstname, lastname, nickname, phone_number, user_id FROM "contacts"
        WHERE
            id = $1;
        "#,
        )
        .bind(id)
        .fetch_one(pool)
        .await
        {
            Ok(row) => {
                let id: uuid::Uuid = row.try_get("id")?;

                let phone_number: String = row.try_get("phone_number")?;
                let user_id: uuid::Uuid = row.try_get("user_id")?;
                Ok(textsender_models::contact::Contact {
                    id: Some(id),
                    firstname: match row.try_get("firstname") {
                        Ok(val) => val,
                        Err(err) => {
                            eprintln!("Error: {err:?}");
                            None
                        }
                    },
                    lastname: match row.try_get("lastname") {
                        Ok(val) => val,
                        Err(err) => {
                            eprintln!("Error: {err:?}");
                            None
                        }
                    },
                    nickname: match row.try_get("nickname") {
                        Ok(val) => val,
                        Err(err) => {
                            eprintln!("Error: nickname has no value for contacts record {err:?}");
                            None
                        }
                    },
                    phone_number,
                    user_id: Some(user_id),
                })
            }
            Err(_) => Err(sqlx::Error::RowNotFound),
        }
    }

    pub async fn get_with_user_id_and_phone(
        pool: &sqlx::PgPool,
        user_id: &uuid::Uuid,
        phone_number: &str,
    ) -> Result<textsender_models::contact::Contact, sqlx::Error> {
        match sqlx::query(
            r#"
        SELECT id, firstname, lastname, nickname, phone_number, user_id FROM "contacts"
        WHERE
            phone_number = $1 AND user_id = $2;
        "#,
        )
        .bind(phone_number)
        .bind(user_id)
        .fetch_one(pool)
        .await
        {
            Ok(row) => {
                println!("In here");
                let id: uuid::Uuid = row.try_get("id")?;
                let firstname: String = row.try_get("firstname")?;
                let lastname: String = row.try_get("lastname")?;
                let nickname: String = row.try_get("nickname")?;
                let phone_number: String = row.try_get("phone_number")?;
                let user_id: uuid::Uuid = row.try_get("user_id")?;
                println!("Found");
                Ok(textsender_models::contact::Contact {
                    id: Some(id),
                    firstname: Some(firstname),
                    lastname: Some(lastname),
                    nickname: Some(nickname),
                    phone_number,
                    user_id: Some(user_id),
                })
            }
            Err(err) => match err {
                sqlx::Error::RowNotFound => Err(err),
                _ => Err(sqlx::Error::WorkerCrashed),
            },
        }
    }

    pub async fn get_with_user_id(
        pool: &sqlx::PgPool,
        user_id: &uuid::Uuid,
    ) -> Result<Vec<textsender_models::contact::Contact>, sqlx::Error> {
        match sqlx::query(
            r#"
        SELECT id, firstname, lastname, nickname, phone_number, user_id FROM "contacts"
        WHERE
            user_id = $1;
        "#,
        )
        .bind(user_id)
        .fetch_all(pool)
        .await
        {
            Ok(rows) => {
                let mut contacts: Vec<textsender_models::contact::Contact> = Vec::new();
                for row in rows {
                    let id: uuid::Uuid = row.try_get("id")?;

                    let phone_number: String = row.try_get("phone_number")?;
                    let user_id: uuid::Uuid = row.try_get("user_id")?;
                    let contact = textsender_models::contact::Contact {
                        id: Some(id),
                        firstname: match row.try_get("firstname") {
                            Ok(val) => val,
                            Err(err) => {
                                eprintln!("Error: {err:?}");
                                None
                            }
                        },
                        lastname: match row.try_get("lastname") {
                            Ok(val) => val,
                            Err(err) => {
                                eprintln!("Error: {err:?}");
                                None
                            }
                        },
                        nickname: match row.try_get("nickname") {
                            Ok(val) => val,
                            Err(err) => {
                                eprintln!(
                                    "Error: nickname has no value for contacts record {err:?}"
                                );
                                None
                            }
                        },
                        phone_number,
                        user_id: Some(user_id),
                    };
                    contacts.push(contact);
                }
                Ok(contacts)
            }
            Err(_) => Err(sqlx::Error::RowNotFound),
        }
    }
}