pub use crate::ToPeerDataStream;

use tokio_rustls::rustls::pki_types::{CertificateDer, PrivatePkcs8KeyDer};
use serde::{Deserialize, Serialize};
use uuid::Uuid;

#[derive(Debug, Serialize, Deserialize)]
pub enum FromServerConnTypeMessage {
    SendCommand,
    Subscribe,
    OpenDataStream(Uuid),
}

#[derive(Debug, Serialize, Deserialize)]
pub enum ToServerConnTypeReply {
    OkSendCommand,
    OkSubscribe,
    // You are now a DataStream, wait the Open message
    OkDataStreamRequestAccepted,
    // The stream is open, you can pipe in-out the content you want!
    OkDataStreamOpen,
    GenericFailure,
}

#[derive(Debug, Serialize, Deserialize)]
pub enum FromServerCommandMessage {
    ChangeName { name: String },
    WhoAmI,
}

#[derive(Debug, Serialize, Deserialize)]
pub enum ToServerCommandReply {
    NameChanged,
    NameNotAvailable,
    YouAre { name: String },
    GenericFailure,
}

#[derive(Debug, Serialize, Deserialize)]
pub enum ToServerMessageBody {
    Request { conn_id: Uuid },
}

#[derive(Debug, Serialize, Deserialize)]
pub enum ToServerMessage {
    Ping,
    Msg {
        reply_id: u64,
        body: ToServerMessageBody,
    },
}

#[derive(Debug, Serialize, Deserialize)]
pub enum FromServerReplyBody {
    RequestAccepted,
    RequestFailed,
    Pong,
}

#[derive(Debug, Serialize, Deserialize)]
pub enum FromServerReply {
    Pong,
    Msg {
        reply_id: u64,
        body: FromServerReplyBody
    }
}

#[derive(Debug, Serialize, Deserialize)]
pub enum FromGuestServerMessage {
    Announce { name: String }
}

pub fn okannounce_to_cert<'a>(server_cert: Vec<u8>, server_prkey: Vec<u8>) -> (CertificateDer<'a>, PrivatePkcs8KeyDer<'a>) {
    let server_cert = CertificateDer::from(server_cert);
    let server_prkey = PrivatePkcs8KeyDer::from(server_prkey);
    (server_cert, server_prkey)
}

#[derive(Debug, Serialize, Deserialize)]
pub enum ToGuestServerMessage {
    OkAnnounce { server_cert: Vec<u8>, server_prkey: Vec<u8> },
    FailedNameAlreadyOccupied,
}

impl ToGuestServerMessage {
    pub fn make_okannounce(server_cert: CertificateDer, server_prkey: PrivatePkcs8KeyDer) -> Self {
        ToGuestServerMessage::OkAnnounce {
            server_cert: server_cert.to_vec(),
            server_prkey: server_prkey.secret_pkcs8_der().to_vec()
        }
    }
}