use sqlx::SqlitePool;

use super::{tripdetails::TripDetails, user::User};

pub struct UserTrip {}

impl UserTrip {
    pub async fn create(
        db: &SqlitePool,
        user: &User,
        trip_details: &TripDetails,
    ) -> Result<(), UserTripError> {
        if trip_details.is_full(db).await {
            return Err(UserTripError::EventAlreadyFull);
        }

        if trip_details.is_locked {
            return Err(UserTripError::DetailsLocked);
        }

        if user.is_guest && !trip_details.allow_guests {
            return Err(UserTripError::GuestNotAllowedForThisEvent);
        }

        //TODO: Check if user sees the event (otherwise she could forge trip_details_id

        //check if cox if own event
        let is_cox = sqlx::query!(
            "SELECT count(*) as amount
            FROM trip 
            WHERE trip_details_id = ? 
            AND cox_id = ?",
            trip_details.id,
            user.id
        )
        .fetch_one(db)
        .await
        .unwrap();
        if is_cox.amount > 0 {
            return Err(UserTripError::CantRegisterAtOwnEvent);
        }

        //TODO: can probably move to trip.rs?
        //check if cox if planned_event
        let is_cox = sqlx::query!(
            "SELECT count(*) as amount
            FROM trip 
            WHERE planned_event_id = (
                SELECT id FROM planned_event WHERE trip_details_id = ?
            ) 
            AND cox_id = ?",
            trip_details.id,
            user.id
        )
        .fetch_one(db)
        .await
        .unwrap();
        if is_cox.amount > 0 {
            return Err(UserTripError::AlreadyRegisteredAsCox);
        }

        match sqlx::query!(
            "INSERT INTO user_trip (user_id, trip_details_id) VALUES(?, ?)",
            user.id,
            trip_details.id
        )
        .execute(db)
        .await
        {
            Ok(_) => Ok(()),
            Err(_) => Err(UserTripError::AlreadyRegistered),
        }
    }

    pub async fn delete(
        db: &SqlitePool,
        user: &User,
        trip_details: &TripDetails,
    ) -> Result<(), UserTripDeleteError> {
        if trip_details.is_locked {
            return Err(UserTripDeleteError::DetailsLocked);
        }

        let _ = sqlx::query!(
            "DELETE FROM user_trip WHERE user_id = ? AND trip_details_id = ?",
            user.id,
            trip_details.id
        )
        .execute(db)
        .await
        .unwrap();

        Ok(())
    }
}

#[derive(Debug, PartialEq)]
pub enum UserTripError {
    AlreadyRegistered,
    AlreadyRegisteredAsCox,
    EventAlreadyFull,
    DetailsLocked,
    CantRegisterAtOwnEvent,
    GuestNotAllowedForThisEvent,
}

#[derive(Debug, PartialEq)]
pub enum UserTripDeleteError {
    DetailsLocked,
}

#[cfg(test)]
mod test {
    use crate::{
        model::{
            planned_event::PlannedEvent, trip::Trip, tripdetails::TripDetails, user::CoxUser,
            usertrip::UserTripError,
        },
        testdb,
    };

    use super::{User, UserTrip};
    use sqlx::SqlitePool;

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

        let user = User::find_by_name(&pool, "rower".into()).await.unwrap();

        let trip_details = TripDetails::find_by_id(&pool, 1).await.unwrap();

        UserTrip::create(&pool, &user, &trip_details).await.unwrap();
    }

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

        let user = User::find_by_name(&pool, "rower".into()).await.unwrap();
        let user2 = User::find_by_name(&pool, "cox".into()).await.unwrap();
        let user3 = User::find_by_name(&pool, "rower2".into()).await.unwrap();

        let trip_details = TripDetails::find_by_id(&pool, 1).await.unwrap();

        UserTrip::create(&pool, &user, &trip_details).await.unwrap();
        UserTrip::create(&pool, &user2, &trip_details)
            .await
            .unwrap();

        let result = UserTrip::create(&pool, &user3, &trip_details)
            .await
            .expect_err("Expect registration to fail because trip is already full");

        assert_eq!(result, UserTripError::EventAlreadyFull);
    }

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

        let user = User::find_by_name(&pool, "cox".into()).await.unwrap();
        let trip_details = TripDetails::find_by_id(&pool, 1).await.unwrap();

        UserTrip::create(&pool, &user, &trip_details).await.unwrap();

        let result = UserTrip::create(&pool, &user, &trip_details)
            .await
            .expect_err("Expect registration to fail because user is same as responsible cox");

        assert_eq!(result, UserTripError::AlreadyRegistered);
    }

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

        let user = User::find_by_name(&pool, "cox".into()).await.unwrap();

        let trip_details = TripDetails::find_by_id(&pool, 2).await.unwrap();

        let result = UserTrip::create(&pool, &user, &trip_details)
            .await
            .expect_err("Expect registration to fail because user is same as responsible cox");

        assert_eq!(result, UserTripError::CantRegisterAtOwnEvent);
    }

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

        let cox: CoxUser = User::find_by_name(&pool, "cox".into())
            .await
            .unwrap()
            .try_into()
            .unwrap();

        let trip_details = TripDetails::find_by_id(&pool, 1).await.unwrap();
        let planned_event = PlannedEvent::find_by_id(&pool, 1).await.unwrap();

        Trip::new_join(&pool, &cox, &planned_event).await.unwrap();

        let result = UserTrip::create(&pool, &cox, &trip_details)
            .await
            .expect_err("Expect registration to fail because user is already registered as cox");

        assert_eq!(result, UserTripError::AlreadyRegisteredAsCox);
    }

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

        let user = User::find_by_name(&pool, "guest".into()).await.unwrap();

        let trip_details = TripDetails::find_by_id(&pool, 1).await.unwrap();

        let result = UserTrip::create(&pool, &user, &trip_details)
            .await
            .expect_err("Not allowed for guests");

        assert_eq!(result, UserTripError::GuestNotAllowedForThisEvent);
    }
}