use serde::{Deserialize, Serialize};
use sqlx::{FromRow, SqlitePool};

#[derive(FromRow, Debug, Serialize, Deserialize)]
pub struct TripDetails {
    pub id: i64,
    planned_starting_time: String,
    max_people: i64,
    day: String,
    notes: Option<String>,
}

impl TripDetails {
    pub async fn find_by_id(db: &SqlitePool, id: i64) -> Option<Self> {
        sqlx::query_as!(
            TripDetails,
            "
SELECT id, planned_starting_time, max_people, day, notes 
FROM trip_details 
WHERE id like ?
        ",
            id
        )
        .fetch_one(db)
        .await
        .ok()
    }

    /// Creates a new entry in `trip_details` and returns its id.
    pub async fn create(
        db: &SqlitePool,
        planned_starting_time: String,
        max_people: i32,
        day: String,
        notes: Option<String>,
    ) -> i64 {
        let query = sqlx::query!(
            "INSERT INTO trip_details(planned_starting_time, max_people, day, notes) VALUES(?, ?, ?, ?)" ,
            planned_starting_time,
            max_people,
            day,
            notes
        )
        .execute(db)
        .await
        .unwrap(); //Okay, TripDetails can only be created if self.id exists
        query.last_insert_rowid()
    }

    pub async fn is_full(&self, db: &SqlitePool) -> bool {
        let amount_currently_registered = sqlx::query!(
            "SELECT COUNT(*) as count FROM user_trip WHERE trip_details_id = ?",
            self.id
        )
        .fetch_one(db)
        .await
        .unwrap(); //TODO: fixme
        let amount_currently_registered = i64::from(amount_currently_registered.count);

        let amount_allowed_to_register =
            sqlx::query!("SELECT max_people FROM trip_details WHERE id = ?", self.id)
                .fetch_one(db)
                .await
                .unwrap(); //Okay, TripDetails can only be created if self.id exists
        let amount_allowed_to_register = amount_allowed_to_register.max_people;

        amount_currently_registered >= amount_allowed_to_register
    }
}

#[cfg(test)]
mod test {
    use crate::testdb;

    use super::TripDetails;
    use sqlx::SqlitePool;

    #[sqlx::test]
    fn test_find_true() {
        let pool = testdb!();

        assert!(TripDetails::find_by_id(&pool, 1).await.is_some());
    }

    #[sqlx::test]
    fn test_find_false() {
        let pool = testdb!();

        assert!(TripDetails::find_by_id(&pool, 1337).await.is_none());
    }

    #[sqlx::test]
    fn test_create() {
        let pool = testdb!();

        assert_eq!(
            TripDetails::create(&pool, "10:00".into(), 2, "1970-01-01".into(), None).await,
            3,
        );
        assert_eq!(
            TripDetails::create(&pool, "10:00".into(), 2, "1970-01-01".into(), None).await,
            4,
        );
    }

    #[sqlx::test]
    fn test_false_full() {
        let pool = testdb!();

        let trip_details = TripDetails::find_by_id(&pool, 1).await.unwrap();
        assert_eq!(trip_details.is_full(&pool).await, false);
    }

    #[sqlx::test]
    fn test_true_full() {
        //TODO: register user for trip_details = 1; check if is_full returns true
    }
}