pub use crate::ToPeerDataStream;

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

#[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 struct OkAnnoucePayload {
    server_cert: Vec<u8>,
    ca_chain: Vec<Vec<u8>>,
    server_prkey: Vec<u8>,
}

impl OkAnnoucePayload {
    pub fn parse<'a>(self) -> LeafCertPair<'a> {
        LeafCertPair::parse(self.server_cert, self.ca_chain, self.server_prkey)
    }
}

#[derive(Debug, Serialize, Deserialize)]
pub enum ToGuestServerMessage {
    OkAnnounce(OkAnnoucePayload),
    FailedNameAlreadyOccupied,
}

impl ToGuestServerMessage {
    pub fn make_okannounce(server_leaf: &LeafCertPair) -> Self {
        ToGuestServerMessage::OkAnnounce(OkAnnoucePayload {
            server_cert: server_leaf.cert().to_vec(),
            ca_chain: server_leaf.fullchain().into_iter().map(|c| c.to_vec()).collect(),
            server_prkey: server_leaf.prkey().secret_pkcs8_der().to_vec(),
        })
    }
}