use crate::{State, get_user_from_token};
use axum::{Extension, Json, extract::Path, response::IntoResponse};
use axum_extra::extract::CookieJar;
use tetratto_core::model::{stacks::UserStack, ApiReturn, Error};
use super::{
    AddOrRemoveStackUser, CreateStack, UpdateStackMode, UpdateStackName, UpdateStackPrivacy,
    UpdateStackSort,
};

pub async fn create_request(
    jar: CookieJar,
    Extension(data): Extension<State>,
    Json(req): Json<CreateStack>,
) -> impl IntoResponse {
    let data = &(data.read().await).0;
    let user = match get_user_from_token!(jar, data) {
        Some(ua) => ua,
        None => return Json(Error::NotAllowed.into()),
    };

    match data
        .create_stack(UserStack::new(req.name, user.id, Vec::new()))
        .await
    {
        Ok(s) => Json(ApiReturn {
            ok: true,
            message: "Stack created".to_string(),
            payload: s.id.to_string(),
        }),
        Err(e) => Json(e.into()),
    }
}

pub async fn update_name_request(
    jar: CookieJar,
    Extension(data): Extension<State>,
    Path(id): Path<usize>,
    Json(req): Json<UpdateStackName>,
) -> impl IntoResponse {
    let data = &(data.read().await).0;
    let user = match get_user_from_token!(jar, data) {
        Some(ua) => ua,
        None => return Json(Error::NotAllowed.into()),
    };

    match data.update_stack_name(id, user, &req.name).await {
        Ok(_) => Json(ApiReturn {
            ok: true,
            message: "Stack updated".to_string(),
            payload: (),
        }),
        Err(e) => Json(e.into()),
    }
}

pub async fn update_privacy_request(
    jar: CookieJar,
    Extension(data): Extension<State>,
    Path(id): Path<usize>,
    Json(req): Json<UpdateStackPrivacy>,
) -> impl IntoResponse {
    let data = &(data.read().await).0;
    let user = match get_user_from_token!(jar, data) {
        Some(ua) => ua,
        None => return Json(Error::NotAllowed.into()),
    };

    match data.update_stack_privacy(id, user, req.privacy).await {
        Ok(_) => Json(ApiReturn {
            ok: true,
            message: "Stack updated".to_string(),
            payload: (),
        }),
        Err(e) => Json(e.into()),
    }
}

pub async fn update_mode_request(
    jar: CookieJar,
    Extension(data): Extension<State>,
    Path(id): Path<usize>,
    Json(req): Json<UpdateStackMode>,
) -> impl IntoResponse {
    let data = &(data.read().await).0;
    let user = match get_user_from_token!(jar, data) {
        Some(ua) => ua,
        None => return Json(Error::NotAllowed.into()),
    };

    match data.update_stack_mode(id, user, req.mode).await {
        Ok(_) => Json(ApiReturn {
            ok: true,
            message: "Stack updated".to_string(),
            payload: (),
        }),
        Err(e) => Json(e.into()),
    }
}

pub async fn update_sort_request(
    jar: CookieJar,
    Extension(data): Extension<State>,
    Path(id): Path<usize>,
    Json(req): Json<UpdateStackSort>,
) -> impl IntoResponse {
    let data = &(data.read().await).0;
    let user = match get_user_from_token!(jar, data) {
        Some(ua) => ua,
        None => return Json(Error::NotAllowed.into()),
    };

    match data.update_stack_sort(id, user, req.sort).await {
        Ok(_) => Json(ApiReturn {
            ok: true,
            message: "Stack updated".to_string(),
            payload: (),
        }),
        Err(e) => Json(e.into()),
    }
}

pub async fn add_user_request(
    jar: CookieJar,
    Extension(data): Extension<State>,
    Path(id): Path<usize>,
    Json(req): Json<AddOrRemoveStackUser>,
) -> impl IntoResponse {
    let data = &(data.read().await).0;
    let user = match get_user_from_token!(jar, data) {
        Some(ua) => ua,
        None => return Json(Error::NotAllowed.into()),
    };

    let other_user = match data.get_user_by_username(&req.username).await {
        Ok(c) => c,
        Err(e) => return Json(Error::MiscError(e.to_string()).into()),
    };

    // check block status
    if data
        .get_userblock_by_initiator_receiver(other_user.id, user.id)
        .await
        .is_ok()
    {
        return Json(Error::NotAllowed.into());
    }

    // add user
    let mut stack = match data.get_stack_by_id(id).await {
        Ok(s) => s,
        Err(e) => return Json(e.into()),
    };

    stack.users.push(other_user.id);
    match data.update_stack_users(id, user, stack.users).await {
        Ok(_) => Json(ApiReturn {
            ok: true,
            message: "User added".to_string(),
            payload: (),
        }),
        Err(e) => Json(e.into()),
    }
}

pub async fn remove_user_request(
    jar: CookieJar,
    Extension(data): Extension<State>,
    Path(id): Path<usize>,
    Json(req): Json<AddOrRemoveStackUser>,
) -> impl IntoResponse {
    let data = &(data.read().await).0;
    let user = match get_user_from_token!(jar, data) {
        Some(ua) => ua,
        None => return Json(Error::NotAllowed.into()),
    };

    let mut stack = match data.get_stack_by_id(id).await {
        Ok(s) => s,
        Err(e) => return Json(e.into()),
    };

    let other_user = match data.get_user_by_username(&req.username).await {
        Ok(c) => c,
        Err(e) => return Json(Error::MiscError(e.to_string()).into()),
    };

    stack
        .users
        .remove(match stack.users.iter().position(|x| x == &other_user.id) {
            Some(idx) => idx,
            None => return Json(Error::GeneralNotFound("user".to_string()).into()),
        });

    match data.update_stack_users(id, user, stack.users).await {
        Ok(_) => Json(ApiReturn {
            ok: true,
            message: "User removed".to_string(),
            payload: (),
        }),
        Err(e) => Json(e.into()),
    }
}

pub async fn delete_request(
    jar: CookieJar,
    Extension(data): Extension<State>,
    Path(id): Path<usize>,
) -> impl IntoResponse {
    let data = &(data.read().await).0;
    let user = match get_user_from_token!(jar, data) {
        Some(ua) => ua,
        None => return Json(Error::NotAllowed.into()),
    };

    match data.delete_stack(id, &user).await {
        Ok(_) => Json(ApiReturn {
            ok: true,
            message: "Stack deleted".to_string(),
            payload: (),
        }),
        Err(e) => Json(e.into()),
    }
}