use bytes::Bytes;
use lanspread_db::db::{Game, GameFileDescription};
use serde::{Deserialize, Serialize};
use tracing::error;

#[derive(Debug, Serialize, Deserialize)]
pub enum Request {
    Ping,
    ListGames,
    GetGame { id: String },
    GetGameFileData(GameFileDescription),
    Invalid(Bytes, String),
}

#[derive(Clone, Debug, Serialize, Deserialize)]
pub enum Response {
    Pong,
    Games(Vec<Game>),
    GetGame(Vec<GameFileDescription>),
    GameNotFound(String),
    InvalidRequest(Bytes, String),
    EncodingError(String),
    DecodingError(Bytes, String),
}

// Add Message trait
pub trait Message {
    fn decode(bytes: Bytes) -> Self;
    fn encode(&self) -> Bytes;
}

// Implement for Request
impl Message for Request {
    fn decode(bytes: Bytes) -> Self {
        match serde_json::from_slice(&bytes) {
            Ok(t) => t,
            Err(e) => {
                tracing::error!(
                    "got invalid request from client (error: {}): {}",
                    e,
                    String::from_utf8_lossy(&bytes)
                );
                Request::Invalid(bytes, e.to_string())
            }
        }
    }

    fn encode(&self) -> Bytes {
        match serde_json::to_vec(self) {
            Ok(s) => Bytes::from(s),
            Err(e) => {
                error!(?e, "Request encoding error");
                Bytes::from(format!(r#"{{"error": "encoding error: {e}"}}"#))
            }
        }
    }
}

// Implement for Response
impl Message for Response {
    fn decode(bytes: Bytes) -> Self {
        match serde_json::from_slice(&bytes) {
            Ok(t) => t,
            Err(e) => Response::DecodingError(bytes, e.to_string()),
        }
    }

    fn encode(&self) -> Bytes {
        match serde_json::to_vec(self) {
            Ok(s) => Bytes::from(s),
            Err(e) => {
                error!(?e, "Response encoding error");
                Bytes::from(format!(r#"{{"error": "encoding error: {e}"}}"#))
            }
        }
    }
}