use sqlx::Row;

pub async fn insert(
    pool: &sqlx::PgPool,
    event: &schedtxt_models::message::event::MessageEventResponse,
) -> Result<uuid::Uuid, sqlx::Error> {
    match sqlx::query(
        r#"
        INSERT INTO "message_event_responses" (scheduled_message_event_id, response, user_id, sent, contact_id, message_id, status) 
        VALUES($1, $2, $3, $4, $5, $6, $7) RETURNING id;
        "#,
    )
    .bind(event.scheduled_message_event_id)
    .bind(&event.response)
    .bind(event.user_id)
    .bind(event.sent)
    .bind(event.contact_id)
    .bind(event.message_id)
    .bind(&event.status)
    .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<schedtxt_models::message::event::MessageEventResponse, sqlx::Error> {
    match sqlx::query(
        r#"
        SELECT id, scheduled_message_event_id, response, user_id, sent, contact_id, message_id, status FROM "message_event_responses"
        WHERE
            id = $1;
        "#,
    )
    .bind(id)
    .fetch_one(pool)
    .await
    {
        Ok(row) => match parse_row(&row).await {
            Ok(event) => Ok(event),
            Err(err) => Err(err),
        },
        Err(_) => Err(sqlx::Error::RowNotFound),
    }
}

pub async fn get_with_user_id(
    pool: &sqlx::PgPool,
    user_id: &uuid::Uuid,
) -> Result<Vec<schedtxt_models::message::event::MessageEventResponse>, sqlx::Error> {
    match sqlx::query(
        r#"
        SELECT id, scheduled_message_event_id, response, user_id, sent, contact_id, message_id, status FROM "message_event_responses"
        WHERE
            user_id = $1;
        "#,
    )
    .bind(user_id)
    .fetch_all(pool)
    .await
    {
        Ok(rows) => {
            let mut events: Vec<schedtxt_models::message::event::MessageEventResponse> =
                Vec::new();
            for row in rows {
                match parse_row(&row).await {
                    Ok(event) => {
                        events.push(event);
                    }
                    Err(err) => {
                        return Err(err);
                    }
                }
            }

            Ok(events)
        }
        Err(_) => Err(sqlx::Error::RowNotFound),
    }
}

async fn parse_row(
    row: &sqlx::postgres::PgRow,
) -> Result<schedtxt_models::message::event::MessageEventResponse, sqlx::Error> {
    println!("Parsing MER");
    let id: uuid::Uuid = row.try_get("id")?;
    let response: serde_json::Value = row.try_get("response")?;
    let status: String = row.try_get("status")?;
    let contact_id: uuid::Uuid = row.try_get("contact_id")?;
    let message_id: uuid::Uuid = row.try_get("message_id")?;
    let sent: time::OffsetDateTime = row.try_get("sent")?;
    let scheduled_message_event_id: Option<uuid::Uuid> = row
        .try_get("scheduled_message_event_id")
        .unwrap_or_default();
    let user_id: uuid::Uuid = row.try_get("user_id")?;

    Ok(schedtxt_models::message::event::MessageEventResponse {
        id,
        response,
        contact_id,
        message_id,
        status,
        sent: Some(sent),
        scheduled_message_event_id,
        user_id,
    })
}