use rocket::{
    form::Form,
    get, post,
    response::{Flash, Redirect},
    routes, FromForm, Route, State,
};
use sqlx::SqlitePool;

use crate::model::{
    trip::{CoxHelpError, Trip, TripDeleteError, TripUpdateError},
    tripdetails::TripDetails,
    user::CoxUser,
};

//TODO: add constraints (e.g. planned_amount_cox > 0)
#[derive(FromForm)]
struct AddTripForm {
    day: String,
    planned_starting_time: String,
    max_people: i32,
    notes: Option<String>,
}

#[post("/trip", data = "<data>")]
async fn create(db: &State<SqlitePool>, data: Form<AddTripForm>, cox: CoxUser) -> Flash<Redirect> {
    //TODO: fix clones()
    let trip_details_id = TripDetails::create(
        db,
        data.planned_starting_time.clone(),
        data.max_people,
        data.day.clone(),
        data.notes.clone(),
    )
    .await;

    //TODO: fix clone()
    Trip::new_own(db, cox.id, trip_details_id).await;

    Flash::success(Redirect::to("/"), "Ausfahrt erfolgreich erstellt.")
}

#[derive(FromForm)]
struct EditTripForm {
    max_people: i32,
    notes: Option<String>,
}

#[post("/trip/<trip_id>", data = "<data>")]
async fn update(
    db: &State<SqlitePool>,
    data: Form<EditTripForm>,
    trip_id: i64,
    cox: CoxUser,
) -> Flash<Redirect> {
    match Trip::update_own(db, cox.id, trip_id, data.max_people, data.notes.clone()).await {
        Ok(_) => Flash::success(Redirect::to("/"), "Ausfahrt erfolgreich aktualisiert."),
        Err(TripUpdateError::NotYourTrip) => {
            Flash::error(Redirect::to("/"), "Nicht deine Ausfahrt!")
        }
        Err(TripUpdateError::TripDoesNotExist) => {
            Flash::error(Redirect::to("/"), "Ausfahrt gibt's nicht")
        }
    }
}

#[get("/join/<planned_event_id>")]
async fn join(db: &State<SqlitePool>, planned_event_id: i64, cox: CoxUser) -> Flash<Redirect> {
    match Trip::new_join(db, cox.id, planned_event_id).await {
        Ok(_) => Flash::success(Redirect::to("/"), "Danke für's helfen!"),
        Err(CoxHelpError::AlreadyRegisteredAsCox) => {
            Flash::error(Redirect::to("/"), "Du hilfst bereits aus!")
        }
        Err(CoxHelpError::AlreadyRegisteredAsRower) => Flash::error(
            Redirect::to("/"),
            "Du hast dich bereits als Ruderer angemeldet!",
        ),
    }
}

#[get("/remove/trip/<trip_id>")]
async fn remove_trip(db: &State<SqlitePool>, trip_id: i64, cox: CoxUser) -> Flash<Redirect> {
    match Trip::delete(db, cox.id, trip_id).await {
        Ok(_) => Flash::success(Redirect::to("/"), "Erfolgreich abgemeldet!"),
        Err(TripDeleteError::SomebodyAlreadyRegistered) => Flash::error(
            Redirect::to("/"),
            "Ausfahrt kann nicht gelöscht werden, da bereits jemand registriert ist!",
        ),
        Err(TripDeleteError::NotYourTrip) => {
            Flash::error(Redirect::to("/"), "Nicht deine Ausfahrt!")
        }
    }
}

#[get("/remove/<planned_event_id>")]
async fn remove(db: &State<SqlitePool>, planned_event_id: i64, cox: CoxUser) -> Flash<Redirect> {
    Trip::delete_by_planned_event_id(db, cox.id, planned_event_id).await;

    Flash::success(Redirect::to("/"), "Erfolgreich abgemeldet!")
}

pub fn routes() -> Vec<Route> {
    routes![create, join, remove, remove_trip, update]
}