use crate::db::Database;
use crate::database::{CreateUserRequest, CreateUserResponse, GetUserRequest, GetUserByUsernameRequest, GetUserResponse};
use tonic::{Request, Response, Status};

use crate::database::database_service_server::{DatabaseService};
use tracing::{debug, error};

pub struct MyDatabaseService {
    pub db: Database, // Use the Database struct from users.rs
}

#[tonic::async_trait]
impl DatabaseService for MyDatabaseService {
    async fn get_user(
        &self,
        request: Request<GetUserRequest>,
    ) -> Result<Response<GetUserResponse>, Status> {
        let req = request.into_inner();

        let user = self.db.users_service.get_user_by_id(req.user_id)
            .await
            .map_err(|_| Status::not_found("User not found"))?;

        Ok(Response::new(GetUserResponse {
            user_id: user.id,
            username: user.username,
            email: user.email,
            hashed_password: user.hashed_password,
        }))
    }

    async fn get_user_by_username(
        &self,
        request: Request<GetUserByUsernameRequest>,
    ) -> Result<Response<GetUserResponse>, Status> {
        let req = request.into_inner();

        let user = self.db.users_service.get_user_by_username(&req.username)
            .await
            .map_err(|_| Status::not_found("User not found"))?;

        Ok(Response::new(GetUserResponse {
            user_id: user.id,
            username: user.username,
            email: user.email,
            hashed_password: user.hashed_password,
        }))
    }

    async fn create_user(
        &self,
        request: Request<CreateUserRequest>,
    ) -> Result<Response<CreateUserResponse>, Status> {
        let req = request.into_inner();

        let user_id = self.db.users_service.create_user(&req.username, &req.email, &req.hashed_password)
            .await
            .map_err(|_| Status::internal("Failed to create user"))?;

        // Return the newly created user ID
        Ok(Response::new(CreateUserResponse { user_id: user_id }))
    }
}