use chrono::{Local, NaiveDate};
use ics::properties::{DtStart, Summary};
use serde::Serialize;
use sqlx::SqlitePool;

use super::{
    event::{Event, Registration},
    log::Log,
    notification::Notification,
    tripdetails::TripDetails,
    triptype::TripType,
    user::{ErgoUser, SteeringUser, User},
    usertrip::UserTrip,
};

#[derive(Serialize, Clone, Debug)]
pub struct Trip {
    id: i64,
    pub cox_id: i64,
    cox_name: String,
    trip_details_id: Option<i64>,
    planned_starting_time: String,
    pub max_people: i64,
    pub day: String,
    pub notes: Option<String>,
    pub allow_guests: bool,
    trip_type_id: Option<i64>,
    always_show: bool,
    is_locked: bool,
}

#[derive(Serialize, Debug)]
pub struct TripWithUserAndType {
    #[serde(flatten)]
    pub trip: Trip,
    pub rower: Vec<Registration>,
    trip_type: Option<TripType>,
}

pub struct TripUpdate<'a> {
    pub cox: &'a User,
    pub trip: &'a Trip,
    pub max_people: i32,
    pub notes: Option<&'a str>,
    pub trip_type: Option<i64>, //TODO: Move to `TripType`
    pub is_locked: bool,
}

impl TripWithUserAndType {
    pub async fn from(db: &SqlitePool, trip: Trip) -> Self {
        let mut trip_type = None;
        if let Some(trip_type_id) = trip.trip_type_id {
            trip_type = TripType::find_by_id(db, trip_type_id).await;
        }
        Self {
            rower: Registration::all_rower(db, trip.trip_details_id.unwrap()).await,
            trip,
            trip_type,
        }
    }
}

impl Trip {
    /// Cox decides to create own trip.
    pub async fn new_own(db: &SqlitePool, cox: &SteeringUser, trip_details: TripDetails) {
        Self::perform_new(db, &cox.user, trip_details).await
    }

    pub async fn new_own_ergo(db: &SqlitePool, ergo: &ErgoUser, trip_details: TripDetails) {
        let typ = trip_details.triptype(db).await;
        if let Some(typ) = typ {
            let allowed_type = TripType::find_by_id(db, 4).await.unwrap();
            if typ == allowed_type {
                Self::perform_new(db, &ergo.user, trip_details).await;
            }
        }
    }

    async fn perform_new(db: &SqlitePool, user: &User, trip_details: TripDetails) {
        let _ = sqlx::query!(
            "INSERT INTO trip (cox_id, trip_details_id) VALUES(?, ?)",
            user.id,
            trip_details.id
        )
        .execute(db)
        .await;

        let same_starting_datetime = TripDetails::find_by_startingdatetime(
            db,
            trip_details.day,
            trip_details.planned_starting_time,
        )
        .await;
        for notify in same_starting_datetime {
            // don't notify oneself
            if notify.id == trip_details.id {
                continue;
            }

            // don't notify people who have cancelled their trip
            if notify.cancelled() {
                continue;
            }

            if let Some(trip) = Trip::find_by_trip_details(db, notify.id).await {
                let user_earlier_trip = User::find_by_id(db, trip.cox_id as i32).await.unwrap();
                Notification::create(
                    db,
                    &user_earlier_trip,
                    &format!(
                        "{} hat eine Ausfahrt zur selben Zeit ({} um {}) wie du erstellt",
                        user.name, trip.day, trip.planned_starting_time
                    ),
                    "Neue Ausfahrt zur selben Zeit",
                    None,
                    None,
                )
                .await;
            }
        }
    }

    pub async fn find_by_trip_details(db: &SqlitePool, tripdetails_id: i64) -> Option<Self> {
        sqlx::query_as!(
            Self,
            "
SELECT trip.id, cox_id, user.name as cox_name, trip_details_id, planned_starting_time, max_people, day, trip_details.notes, allow_guests, trip_type_id, always_show, is_locked
FROM trip 
INNER JOIN trip_details ON trip.trip_details_id = trip_details.id
INNER JOIN user ON trip.cox_id = user.id
WHERE trip_details.id=?
        ",
            tripdetails_id
        )
        .fetch_one(db)
        .await
        .ok()
    }

    pub(crate) async fn get_vevent(self, user: &User) -> ics::Event {
        let mut vevent = ics::Event::new(format!("{}@rudernlinz.at", self.id), "19900101T180000");
        vevent.push(DtStart::new(format!(
            "{}T{}00",
            self.day.replace('-', ""),
            self.planned_starting_time.replace(':', "")
        )));
        let mut name = String::new();
        if self.is_cancelled() {
            name.push_str("ABGESAGT");
            if let Some(notes) = &self.notes {
                if !notes.is_empty() {
                    name.push_str(&format!(" (Grund: {notes})"))
                }
            }

            name.push_str("! :-( ");
        }
        if self.cox_id == user.id {
            name.push_str("Ruderausfahrt (selber ausgeschrieben)");
        } else {
            name.push_str(&format!("Ruderausfahrt mit {} ", self.cox_name));
        }

        vevent.push(Summary::new(name));
        vevent
    }

    pub async fn all(db: &SqlitePool) -> Vec<Self> {
        sqlx::query_as!(
            Self,
            "
SELECT trip.id, cox_id, user.name as cox_name, trip_details_id, planned_starting_time, max_people, day, trip_details.notes, allow_guests, trip_type_id, always_show, is_locked
FROM trip 
INNER JOIN trip_details ON trip.trip_details_id = trip_details.id
INNER JOIN user ON trip.cox_id = user.id
",
        )
        .fetch_all(db)
        .await
        .unwrap() //TODO: fixme
    }

    pub async fn all_with_user(db: &SqlitePool, user: &User) -> Vec<Self> {
        let mut ret = Vec::new();
        let trips = Self::all(db).await;
        for trip in trips {
            if user.id == trip.cox_id {
                ret.push(trip.clone());
            }
            if let Some(trip_details_id) = trip.trip_details_id {
                if UserTrip::find_by_userid_and_trip_detail_id(db, user.id, trip_details_id)
                    .await
                    .is_some()
                {
                    ret.push(trip);
                }
            }
        }
        ret
    }

    pub async fn find_by_id(db: &SqlitePool, id: i64) -> Option<Self> {
        sqlx::query_as!(
            Self,
            "
SELECT trip.id, cox_id, user.name as cox_name, trip_details_id, planned_starting_time, max_people, day, trip_details.notes, allow_guests, trip_type_id, always_show, is_locked
FROM trip 
INNER JOIN trip_details ON trip.trip_details_id = trip_details.id
INNER JOIN user ON trip.cox_id = user.id
WHERE trip.id=?
        ",
            id
        )
        .fetch_one(db)
        .await
        .ok()
    }

    /// Cox decides to help in a event.
    pub async fn new_join(
        db: &SqlitePool,
        cox: &SteeringUser,
        event: &Event,
    ) -> Result<(), CoxHelpError> {
        if event.is_rower_registered(db, cox).await {
            return Err(CoxHelpError::AlreadyRegisteredAsRower);
        }

        if event.trip_details(db).await.is_locked {
            return Err(CoxHelpError::DetailsLocked);
        }

        if event.max_people == 0 {
            return Err(CoxHelpError::CanceledEvent);
        }

        match sqlx::query!(
            "INSERT INTO trip (cox_id, planned_event_id) VALUES(?, ?)",
            cox.id,
            event.id
        )
        .execute(db)
        .await
        {
            Ok(_) => Ok(()),
            Err(_) => Err(CoxHelpError::AlreadyRegisteredAsCox),
        }
    }

    pub async fn get_for_today(db: &SqlitePool) -> Vec<TripWithUserAndType> {
        let today = Local::now().date_naive();
        Self::get_for_day(db, today).await
    }

    pub async fn get_for_day(db: &SqlitePool, day: NaiveDate) -> Vec<TripWithUserAndType> {
        let day = format!("{day}");
        let trips = sqlx::query_as!(
            Trip,
            "
SELECT trip.id, cox_id, user.name as cox_name, trip_details_id, planned_starting_time, max_people, day, trip_details.notes, allow_guests, trip_type_id, always_show, is_locked
FROM trip 
INNER JOIN trip_details ON trip.trip_details_id = trip_details.id
INNER JOIN user ON trip.cox_id = user.id
WHERE day=?
    ",
            day
        )
        .fetch_all(db)
        .await
        .unwrap(); //Okay, as Trip can only be created with proper DB backing

        let mut ret = Vec::new();
        for trip in trips {
            ret.push(TripWithUserAndType::from(db, trip).await);
        }
        ret
    }

    /// Cox decides to update own trip.
    pub async fn update_own(
        db: &SqlitePool,
        update: &TripUpdate<'_>,
    ) -> Result<(), TripUpdateError> {
        if !update.trip.is_trip_from_user(update.cox.id) {
            return Err(TripUpdateError::NotYourTrip);
        }

        if update.trip_type != Some(4) && !update.cox.allowed_to_steer(db).await {
            return Err(TripUpdateError::TripTypeNotAllowed);
        }

        let Some(trip_details_id) = update.trip.trip_details_id else {
            return Err(TripUpdateError::TripDetailsDoesNotExist); //TODO: Remove?
        };

        let tripdetails = TripDetails::find_by_id(db, trip_details_id).await.unwrap();
        let was_already_cancelled = tripdetails.max_people == 0;

        let is_locked = if update.max_people == 0 {
            false
        } else {
            update.is_locked
        };

        sqlx::query!(
            "UPDATE trip_details SET max_people = ?, notes = ?, trip_type_id = ?, is_locked = ? WHERE id = ?",
            update.max_people,
            update.notes,
            update.trip_type,
            is_locked,
            trip_details_id
        )
        .execute(db)
        .await
        .unwrap(); //Okay, as trip_details can only be created with proper DB backing

        if update.max_people == 0 && !was_already_cancelled {
            let rowers = TripWithUserAndType::from(db, update.trip.clone())
                .await
                .rower;
            for user in rowers {
                if let Some(user) = User::find_by_name(db, &user.name).await {
                    let notes = match update.notes {
                        Some(n) if !n.is_empty() => format!("Grund der Absage: {n}"),
                        _ => String::from(""),
                    };

                    Notification::create(
                        db,
                        &user,
                        &format!(
                            "Die Ausfahrt von {} am {} um {} wurde abgesagt. {} Bitte gib Bescheid, dass du die Info erhalten hast indem du auf ✓ klickst.",
                            update.cox.name,
                            update.trip.day,
                            update.trip.planned_starting_time,
                            notes
                        ),
                        "Absage Ausfahrt",
                        None,
                        Some(&format!(
                            "remove_user_trip_with_trip_details_id:{}",
                            trip_details_id
                        )),
                    )
                    .await;
                }
            }
        } else {
            Notification::delete_by_action(
                db,
                &format!("remove_user_trip_with_trip_details_id:{}", trip_details_id),
            )
            .await;
        }

        if update.max_people > 0 && was_already_cancelled {
            Notification::delete_by_action(
                db,
                &format!("remove_user_trip_with_trip_details_id:{}", trip_details_id),
            )
            .await;
        }

        let trip_details = TripDetails::find_by_id(db, trip_details_id).await.unwrap();
        trip_details.check_free_spaces(db).await;

        Ok(())
    }

    pub async fn trip_details(&self, db: &SqlitePool) -> Option<TripDetails> {
        if let Some(trip_details_id) = self.trip_type_id {
            return TripDetails::find_by_id(db, trip_details_id).await;
        }
        None
    }

    pub async fn delete_by_planned_event(
        db: &SqlitePool,
        cox: &SteeringUser,
        event: &Event,
    ) -> Result<(), TripHelpDeleteError> {
        if event.trip_details(db).await.is_locked {
            return Err(TripHelpDeleteError::DetailsLocked);
        }

        let affected_rows = sqlx::query!(
            "DELETE FROM trip WHERE cox_id = ? AND planned_event_id = ?",
            cox.id,
            event.id
        )
        .execute(db)
        .await
        .unwrap()
        .rows_affected();

        if affected_rows == 0 {
            return Err(TripHelpDeleteError::CoxNotHelping);
        }

        Ok(())
    }

    pub(crate) async fn delete(&self, db: &SqlitePool, user: &User) -> Result<(), TripDeleteError> {
        let registered_rower = Registration::all_rower(db, self.trip_details_id.unwrap()).await;
        if !registered_rower.is_empty() {
            return Err(TripDeleteError::SomebodyAlreadyRegistered);
        }

        if !self.is_trip_from_user(user.id) && !user.has_role(db, "admin").await {
            return Err(TripDeleteError::NotYourTrip);
        }

        Log::create(db, format!("{} deleted trip: {:#?}", user.name, self)).await;

        sqlx::query!("DELETE FROM trip WHERE id = ?", self.id)
            .execute(db)
            .await
            .unwrap(); //TODO: fixme

        Ok(())
    }

    fn is_trip_from_user(&self, user_id: i64) -> bool {
        self.cox_id == user_id
    }

    pub(crate) async fn toggle_always_show(&self, db: &SqlitePool) {
        if let Some(trip_details) = self.trip_details_id {
            let new_state = !self.always_show;
            sqlx::query!(
                "UPDATE trip_details SET always_show = ? WHERE id = ?",
                new_state,
                trip_details
            )
            .execute(db)
            .await
            .unwrap();
        }
    }

    pub(crate) async fn get_pinned_for_day(
        db: &sqlx::Pool<sqlx::Sqlite>,
        day: NaiveDate,
    ) -> Vec<TripWithUserAndType> {
        let mut trips = Self::get_for_day(db, day).await;
        trips.retain(|e| e.trip.always_show);
        trips
    }

    fn is_cancelled(&self) -> bool {
        self.max_people == 0
    }
}

#[derive(Debug)]
pub enum CoxHelpError {
    AlreadyRegisteredAsRower,
    AlreadyRegisteredAsCox,
    DetailsLocked,
    CanceledEvent,
}

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

#[derive(Debug, PartialEq)]
pub enum TripDeleteError {
    SomebodyAlreadyRegistered,
    NotYourTrip,
}

#[derive(Debug)]
pub enum TripUpdateError {
    NotYourTrip,
    TripDetailsDoesNotExist,
    TripTypeNotAllowed,
}

#[cfg(test)]
mod test {
    use crate::{
        model::{
            event::Event,
            notification::Notification,
            trip::{self, TripDeleteError},
            tripdetails::TripDetails,
            user::{SteeringUser, User},
            usertrip::UserTrip,
        },
        testdb,
    };

    use chrono::Local;
    use sqlx::SqlitePool;

    use super::Trip;

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

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

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

        Trip::new_own(&pool, &cox, trip_details).await;

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

    #[sqlx::test]
    fn test_notification_cox_if_same_datetime() {
        let pool = testdb!();
        let cox = SteeringUser::new(
            &pool,
            User::find_by_name(&pool, "cox".into()).await.unwrap(),
        )
        .await
        .unwrap();
        let trip_details = TripDetails::find_by_id(&pool, 1).await.unwrap();
        Trip::new_own(&pool, &cox, trip_details).await;

        let cox2 = SteeringUser::new(
            &pool,
            User::find_by_name(&pool, "cox2".into()).await.unwrap(),
        )
        .await
        .unwrap();
        let trip_details = TripDetails::find_by_id(&pool, 3).await.unwrap();
        Trip::new_own(&pool, &cox2, trip_details).await;

        let last_notification = &Notification::for_user(&pool, &cox).await[0];

        assert!(last_notification
            .message
            .starts_with("cox2 hat eine Ausfahrt zur selben Zeit"));
    }

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

        let tomorrow = Local::now().date_naive() + chrono::Duration::days(1);
        let res = Trip::get_for_day(&pool, tomorrow).await;
        assert_eq!(res.len(), 1);
    }

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

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

        let planned_event = Event::find_by_id(&pool, 1).await.unwrap();

        assert!(Trip::new_join(&pool, &cox, &planned_event).await.is_ok());
    }

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

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

        let planned_event = Event::find_by_id(&pool, 1).await.unwrap();

        Trip::new_join(&pool, &cox, &planned_event).await.unwrap();
        assert!(Trip::new_join(&pool, &cox, &planned_event).await.is_err());
    }

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

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

        let trip = Trip::find_by_id(&pool, 1).await.unwrap();

        let update = trip::TripUpdate {
            cox: &cox,
            trip: &trip,
            max_people: 10,
            notes: None,
            trip_type: None,
            is_locked: false,
        };

        assert!(Trip::update_own(&pool, &update).await.is_ok());

        let trip = Trip::find_by_id(&pool, 1).await.unwrap();
        assert_eq!(trip.max_people, 10);
    }

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

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

        let trip = Trip::find_by_id(&pool, 1).await.unwrap();

        let update = trip::TripUpdate {
            cox: &cox,
            trip: &trip,
            max_people: 10,
            notes: None,
            trip_type: Some(1),
            is_locked: false,
        };
        assert!(Trip::update_own(&pool, &update).await.is_ok());

        let trip = Trip::find_by_id(&pool, 1).await.unwrap();
        assert_eq!(trip.max_people, 10);
        assert_eq!(trip.trip_type_id, Some(1));
    }

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

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

        let trip = Trip::find_by_id(&pool, 1).await.unwrap();

        let update = trip::TripUpdate {
            cox: &cox,
            trip: &trip,
            max_people: 10,
            notes: None,
            trip_type: None,
            is_locked: false,
        };
        assert!(Trip::update_own(&pool, &update).await.is_err());
        assert_eq!(trip.max_people, 1);
    }

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

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

        let planned_event = Event::find_by_id(&pool, 1).await.unwrap();

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

        //TODO: check why following assert fails
        //assert!(Trip::find_by_id(&pool, 2).await.is_some());
        Trip::delete_by_planned_event(&pool, &cox, &planned_event)
            .await
            .unwrap();
        assert!(Trip::find_by_id(&pool, 2).await.is_none());
    }

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

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

        let trip = Trip::find_by_id(&pool, 1).await.unwrap();

        trip.delete(&pool, &cox).await.unwrap();

        assert!(Trip::find_by_id(&pool, 1).await.is_none());
    }

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

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

        let trip = Trip::find_by_id(&pool, 1).await.unwrap();

        let result = trip
            .delete(&pool, &cox)
            .await
            .expect_err("It should not be possible to delete trips from others");
        let expected = TripDeleteError::NotYourTrip;

        assert_eq!(result, expected);
    }

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

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

        let trip = Trip::find_by_id(&pool, 1).await.unwrap();

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

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

        let result = trip
            .delete(&pool, &cox)
            .await
            .expect_err("It should not be possible to delete trips if somebody already registered");
        let expected = TripDeleteError::SomebodyAlreadyRegistered;

        assert_eq!(result, expected);
    }
}