use shared::blockchain_core::{self, ChainData};
use std::fmt;
use std::net::SocketAddr;

pub const MAX_MESSAGE_SIZE: usize = 1_000_000;

#[derive(Debug, Clone, bincode::Encode, bincode::Decode, Hash, PartialEq, Eq)]
pub struct NodeId(pub [u8; 16]);

#[derive(Debug, Clone, bincode::Encode, bincode::Decode)]
pub enum ProtocolMessage {
  BootstrapRequest {
    peer_id: NodeId,
    version: String,
  },
  BootstrapResponse {
    blocks: Vec<u8>,
  },
  GetPeersRequest {
    peer_id: NodeId,
  },
  GetPeersResponse {
    peer_addresses: Vec<SocketAddr>,
  },
  Handshake {
    peer_id: NodeId,
    version: String,
  },
  HandshakeAck {
    peer_id: NodeId,
    version: String,
  },
  Block {
    peer_id: NodeId,
    height: u64,
    block: blockchain_core::Block,
  },
  ChainData {
    peer_id: NodeId,
    data: ChainData,
  },
  Ping {
    peer_id: NodeId,
  },
  Pong {
    peer_id: NodeId,
  },
  Disconnect {
    peer_id: NodeId,
  },
}

impl fmt::Display for NodeId {
  fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    let msg = self.to_string();
    write!(f, "{}", msg)
  }
}

impl fmt::Display for ProtocolMessage {
  fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    match self {
      ProtocolMessage::BootstrapRequest { peer_id, version } => {
        write!(f, "BootstrapRequest from {} (v{})", peer_id, version)
      }
      ProtocolMessage::BootstrapResponse { blocks } => {
        write!(
          f,
          "BootstrapResponse with {:?} blocks",
          blocks.len()
        )
      }
      ProtocolMessage::GetPeersRequest { peer_id } => {
        write!(f, "GetPeersRequest from {}", peer_id)
      }
      ProtocolMessage::GetPeersResponse { peer_addresses } => {
        write!(f, "GetPeersResponse with {} peers", peer_addresses.len())
      }
      ProtocolMessage::Handshake { peer_id, version } => {
        write!(f, "Handshake from {} (v{})", peer_id, version)
      }
      ProtocolMessage::HandshakeAck { peer_id, version } => {
        write!(f, "HandshakeAck from {} (v{})", peer_id, version)
      }
      ProtocolMessage::Block {
        peer_id,
        height,
        block: _,
      } => {
        write!(f, "Block #{} from {}", height, peer_id)
      }
      ProtocolMessage::ChainData { peer_id, data: _ } => {
        write!(f, "ChainData from {}", peer_id)
      }
      ProtocolMessage::Ping { peer_id } => {
        write!(f, "Ping from {}", peer_id)
      }
      ProtocolMessage::Pong { peer_id } => {
        write!(f, "Pong from {}", peer_id)
      }
      ProtocolMessage::Disconnect { peer_id } => {
        write!(f, "Disconnect from {}", peer_id)
      }
    }
  }
}