use serde::{Deserialize, Serialize};

use serde::{Deserialize, Serialize};

/// User entity
#[derive(Serialize, Deserialize, utoipa::ToSchema)]
pub struct User {
    pub id: u64,
    pub username: String,
}

/// Payload for creating a user
#[derive(Serialize, Deserialize, utoipa::ToSchema)]
pub struct CreateUserDTO {
    #[schema(example = "new.username")]
    pub username: String,
}

/// Payload for updating an existing user
#[derive(Serialize, Deserialize, utoipa::ToSchema)]
pub struct UpdateUserDTO {
    #[schema(example = "update.username")]
    pub username: String,
}

use crate::entity::User;
use std::collections::HashMap;
use std::sync::RwLock;
use std::sync::atomic::{AtomicU64, Ordering};

pub struct UserDbMock {
    users: RwLock<HashMap<u64, String>>,
    next_id: AtomicU64,
}

impl UserDbMock {
    pub fn new() -> Self {
        Self {
            users: RwLock::new(HashMap::new()),
            next_id: AtomicU64::new(1),
        }
    }

    pub fn create_user(&self, username: String) -> User {
        let id = self.next_id.fetch_add(1, Ordering::SeqCst);

        let user = User {
            id,
            username: username.clone(),
        };

        let mut users_guard = self.users.write().unwrap();

        users_guard.insert(id, username);

        user
    }

    pub fn get_user(&self, user_id: u64) -> Option<User> {
        let users_guard = self.users.read().unwrap();

        users_guard.get(&user_id).map(|username| User {
            id: user_id,
            username: username.clone(),
        })
    }

    pub fn update_user(&self, user_id: u64, new_username: String) -> Option<User> {
        let mut users_guard = self.users.write().unwrap();

        if let Some(username) = users_guard.get_mut(&user_id) {
            *username = new_username.clone();
            Some(User {
                id: user_id,
                username: new_username,
            })
        } else {
            None
        }
    }

    pub fn delete_user(&self, user_id: u64) -> bool {
        let mut users_guard = self.users.write().unwrap();

        users_guard.remove(&user_id).is_some()
    }

    pub fn list_users(&self) -> Vec<User> {
        let users_guard = self.users.read().unwrap();

        users_guard
            .iter()
            .map(|(&id, username)| User {
                id,
                username: username.clone(),
            })
            .collect()
    }
}

#[utoipa::path(
    method(post),
    path = "",
    tag = USERS_TAG,
    request_body = CreateUserDTO,
    responses(
        (status = CREATED, description = "User created successfully", body = User)
    )
)]
async fn create_user(
    State(app_state): State<AppState>,
    Json(payload): Json<CreateUserDTO>,
) -> (StatusCode, Json<User>) {
    let user = User {
        id: 0,
        username: payload.username,
    };

    let created_user = app_state.user_db.create_user(user.username.clone());

    (StatusCode::CREATED, Json(created_user))
}

#[utoipa::path(
    get,
    path = "/{id}",
    tag = USERS_TAG,
    params(
        ("id" = i32, Path, description = "User ID to get")
    ),
    responses(
        (status = OK, description = "User found", body = User),
        (status = NOT_FOUND, description = "User not found")
    )
)]
async fn get_user(State(app_state): State<AppState>, Path(id): Path<u64>) -> Response {
    match app_state.user_db.get_user(id) {
        Some(user) => (StatusCode::OK, Json(user)).into_response(),
        None => StatusCode::NOT_FOUND.into_response(),
    }
}

#[utoipa::path(
    put,
    path = "/{id}",
    tag = USERS_TAG,
    params(
        ("id" = u64, Path, description = "User ID to update")
    ),
    request_body = CreateUserDTO,
    responses(
        (status = OK, description = "User updated successfully", body = User),
        (status = NOT_FOUND, description = "User not found")
    )
)]
async fn update_user(
    State(app_state): State<AppState>,
    Path(id): Path<u64>,
    Json(payload): Json<UpdateUserDTO>,
) -> Response {
    match app_state.user_db.update_user(id, payload.username) {
        Some(user) => (StatusCode::OK, Json(user)).into_response(),
        None => StatusCode::NOT_FOUND.into_response(),
    }
}

#[utoipa::path(
    delete,
    path = "/{id}",
    tag = USERS_TAG,
    params(
        ("id" = u64, Path, description = "User ID to delete")
    ),
    responses(
        (status = NO_CONTENT, description = "User deleted successfully"),
        (status = NOT_FOUND, description = "User not found")
    )
)]
async fn delete_user(State(app_state): State<AppState>, Path(id): Path<u64>) -> StatusCode {
    if app_state.user_db.delete_user(id) {
        // 204 NO_CONTENT is standard for a successful DELETE
        StatusCode::NO_CONTENT
    } else {
        StatusCode::NOT_FOUND
    }
}

pub fn users_openapi_router(app_state: AppState) -> utoipa_axum::router::OpenApiRouter {
    utoipa_axum::router::OpenApiRouter::new()
        .routes(utoipa_axum::routes!(create_user))
        .routes(utoipa_axum::routes!(get_user))
        .routes(utoipa_axum::routes!(list_users))
        .routes(utoipa_axum::routes!(update_user))
        .routes(utoipa_axum::routes!(delete_user))
        .with_state(app_state)
}

let (router, api) = utoipa_axum::router::OpenApiRouter::with_openapi(ApiDoc::openapi())
    .nest(
        "/api/v1/basic",
        rust_axum_swagger_example::routes::basic::basic_openapi_router(),
    )
     .nest(
         "/api/v1/users",
         rust_axum_swagger_example::routes::users::users_openapi_router(app_state.clone()),
    )
    .split_for_parts();