use futures_core::Stream;
use serde::{Deserialize, Serialize};

use crate::{
    codec::MessageCodec,
    metadata::Metadata,
    status::{Code, Status},
};

pub trait Message {
    fn codec() -> MessageCodec;
}

pub trait MessageStream<T>: Stream<Item = MessageStreamItem<T>> {}

pub enum MessageStreamItem<T> {
    Message(MessageStreamMessage<T>),
    EndStream(EndStream),
}

impl<T> MessageStreamItem<T> {
    pub fn message(message: T, encoded: bool) -> Self {
        Self::Message(MessageStreamMessage { encoded, message })
    }

    pub fn complete(metadata: Metadata) -> Self {
        Self::EndStream(EndStream {
            error: None,
            metadata,
        })
    }

    pub fn error(code: Code, message: impl Into<String>, metadata: Metadata) -> Self {
        Self::EndStream(EndStream {
            error: Some(Status {
                code,
                message: message.into(),
                details: Default::default(),
            }),
            metadata,
        })
    }
}

pub struct MessageStreamMessage<T> {
    encoded: bool,
    message: T,
}

#[derive(Clone, Debug, Default, Serialize, Deserialize)]
pub struct EndStream {
    /// If set, the stream has ended with the given error [`Status`]`.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub error: Option<Status>,

    #[serde(default, skip_serializing_if = "Metadata::is_empty")]
    pub metadata: Metadata,
}