use std::sync::Arc;
use tracing::debug;
use tonic::{Request, Response, Status};
use utils::null_string::NullTerminatedString;
use crate::character_db_client::CharacterDbClient;
use crate::character_service::character::character_service_server::CharacterService;
use crate::character_service::character::{CreateCharacterRequest, CreateCharacterResponse, DeleteCharacterRequest, DeleteCharacterResponse, Empty, GetCharacterListRequest, GetCharacterListResponse, GetCharacterRequest};
use crate::character_service::character_common::{Character, Looks, Stats};

pub mod character_common {
    tonic::include_proto!("character_common");
}
pub mod character {
    
    tonic::include_proto!("character");
}

pub struct MyCharacterService {
    pub character_db_client: Arc<CharacterDbClient>,
}

#[tonic::async_trait]
impl CharacterService for MyCharacterService {
    async fn get_character_list(&self, request: Request<GetCharacterListRequest>) -> Result<Response<GetCharacterListResponse>, Status> {
        let req = request.into_inner();

        let user_id = req.user_id;
        debug!("Character list for User ID: {}", user_id);

        let character_list = self.character_db_client.as_ref().clone().get_character_list(&user_id).await
            .map_err(|_| Status::aborted("Unable to get character list"))?;
        debug!("{:?}", character_list.characters);

        let mut characters: Vec<Character> = vec![];
        for character in character_list.characters {
            characters.push(
                Character {
                    character_id: character.id.to_string(),
                    name: character.name,
                    last_played: 0,
                    delete_time: character.deleted_at.parse().unwrap_or_default(),
                    stats: serde_json::from_str(&character.stats).unwrap(),
                    looks: serde_json::from_str(&character.looks).unwrap(),
                    items: serde_json::from_str(&character.inventory).unwrap(),
                }
            )
        }

        let response = GetCharacterListResponse { characters };
        Ok(Response::new(response))
    }

    async fn create_character(&self, request: Request<CreateCharacterRequest>) -> Result<Response<CreateCharacterResponse>, Status> {
        let req = request.into_inner();
        debug!("{:?}", req);
        
        let create_character_response = self.character_db_client.as_ref().clone().create_character(&req.user_id, &req.name, req.race, req.face, req.hair, req.stone)
            .await
            .map_err(|_| Status::aborted("Unable to create character"))?;
        
        let response = CreateCharacterResponse { result: create_character_response.result };
        Ok(Response::new(response))
    }

    async fn delete_character(&self, request: Request<DeleteCharacterRequest>) -> Result<Response<DeleteCharacterResponse>, Status> {
        let req = request.into_inner();
        debug!("{:?}", req);

        let delete_character_response = self.character_db_client.as_ref().clone().delete_character(&req.user_id, &req.char_id, req.delete_type).await.map_err(|_| Status::not_found("Character not found"))?;
        let response = DeleteCharacterResponse { remaining_time: delete_character_response.remaining_time, name: delete_character_response.name };
        Ok(Response::new(response))
    }

    async fn get_character(&self, request: Request<GetCharacterRequest>) -> Result<Response<Empty>, Status> {
        let req = request.into_inner();
        debug!("{:?}", req);
        Ok(Response::new(Empty{}))
    }
}