fws_actors 0.1.0

use std::{ffi::os_str::Display, fmt::Debug, sync::Arc};

use corlib::text::AsStr;

use fastwebsockets::{upgrade::{IncomingUpgrade, UpgradeFut}, WebSocket};

use highly_sendable::text::SendableText;
use hyper::upgrade::Upgraded;
use hyper_util::rt::TokioIo;
use thiserror::Error;

use super::{OwnedFrame, WebSocketReader};

//Client actor - for a single connection

//A request is sent to the WebSocket actor to connect to a server.

//The WebSocket actor closes its current connection, if it has one, and attempts to connect to the server at the provided address.

//The WebSocket actor sends a unit via the provided sender to the actor-client to indicate that the message has been acknowledged and that a new connection to the server at the provided address is being made.

//The WebSocket actor then communicates its connection ptogress and the connected servers output via its provided output queue.

//#[derive(Debug)]
pub enum WebSocketActorInputMessage //<T> //WebSocketClientActorInputMessage
{

    NewConnection(WebSocket<TokioIo<Upgraded>>), //NewWebSocket? //(T),
    //ConnectTo(SendableText), //(String), //URL, Has the WebSockect actor started trying to connect to the server?
    Disconnect,
    DisconnectNow,
    WriteFrame(OwnedFrame),

    //Shared frames e.g: Arc<RwLock<OwnedFrame>>

    //SendPing(SendableText),
    //SendPingZero
    //FromReadWebSocketActor(FromReadWebSocketActorMessage)
    //Exit //The WebSocketActor has to be manually told to exit.

}

impl WebSocketActorInputMessage
{

    pub fn is_new_connection(&self) -> bool
    {

        matches!(self, WebSocketActorInputMessage::NewConnection(_))

        /*
        if let WebSocketActorInputMessage::NewConnection(_) = self
        {

            return true;

        }

        false
        */

    }

    pub fn is_disconnect(&self) -> bool
    {

        matches!(self, WebSocketActorInputMessage::Disconnect)

        /*
        if let WebSocketActorInputMessage::Disconnect = self
        {

            return true;

        }

        false
        */

    }

    pub fn is_disconnect_now(&self) -> bool
    {

        matches!(self, WebSocketActorInputMessage::DisconnectNow)

        /* 
        if let WebSocketActorInputMessage::DisconnectNow = self
        {

            return true;

        }

        false
        */

    }

    pub fn is_write_frame(&self) -> bool
    {

        matches!(self, WebSocketActorInputMessage::WriteFrame(_))

        /* 
        if let WebSocketActorInputMessage::WriteFrame(_) = self
        {

            return true;

        }

        false
        */

    }

}

impl Debug for WebSocketActorInputMessage
{
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Self::NewConnection(arg0) => f.debug_tuple("NewConnection").finish(), //.field(arg0)
            Self::Disconnect => write!(f, "Disconnect"),
            Self::DisconnectNow => write!(f, "DisconnectNow"),
            Self::WriteFrame(arg0) => f.debug_tuple("WriteFrame").field(arg0).finish(),
        }
    }
}

#[derive(Debug)]
pub enum WebSocketWorkerActorInputMessage
{

    Disconnect,
    DisconnectNow,
    WriteFrame(OwnedFrame),

}

impl WebSocketWorkerActorInputMessage
{

    pub fn is_disconnect(&self) -> bool
    {

        matches!(self, WebSocketWorkerActorInputMessage::Disconnect)
    }

    pub fn is_disconnect_now(&self) -> bool
    {

        matches!(self, WebSocketWorkerActorInputMessage::DisconnectNow)

    }

    pub fn is_write_frame(&self) -> bool
    {

        matches!(self, WebSocketWorkerActorInputMessage::WriteFrame(_))

    }

    pub fn into_web_socket_actor_input_message<T>(self) -> WebSocketActorInputMessage //<T>
    {

        match self
        {

            WebSocketWorkerActorInputMessage::Disconnect => WebSocketActorInputMessage::Disconnect,
            WebSocketWorkerActorInputMessage::DisconnectNow => WebSocketActorInputMessage::DisconnectNow,
            WebSocketWorkerActorInputMessage::WriteFrame(owned_frame) => WebSocketActorInputMessage::WriteFrame(owned_frame)

        }

    }

}

//Both

//Messages from WebSocket actors.

/*
#[derive(Debug)]
pub enum ConnectionError
{



}
*/

//https://crates.io/crates/thiserror

#[derive(Error, Debug, Clone)]
pub enum NonConnectionError
{

    #[error("An empty URL was provided.")]
    EmptyUrlProvided,
    #[error("URL parse error: {0}")]
    UrlParseError(Arc<str>), //(String), //May be changed to an Arc<str>.
    #[error("Handshake error: {0}")]
    HandshakeError(Arc<str>), //(String),
    #[error("Not connected")]
    NotConnected

}

impl NonConnectionError
{

    pub fn is_empty_url_provided(&self) -> bool
    {

        matches!(self, NonConnectionError::EmptyUrlProvided)
    }

    pub fn is_url_parse_error(&self) -> bool
    {

        matches!(self, NonConnectionError::UrlParseError(_))

    }

    pub fn is_handshake_error(&self) -> bool
    {

        matches!(self, NonConnectionError::HandshakeError(_))

    }

    pub fn is_not_connected(&self) -> bool
    {

        matches!(self, NonConnectionError::NotConnected)

    }

}

//Errors should probably get types.

//#[derive(Debug)]
//pub enum WebSocketClientActorOutputMessage
#[derive(Debug)]
pub enum WebSocketActorOutputMessage
{

    //ConnectionSucceeded, //(SendableText),
    NewConnection,
    ConnectionError(SendableText),                // Errors relating to active connections.Indicate that it is the reader or witer actor having the issue at some point. (Equivalent to the Disconnected variant with a message.)
    NonConnectionError(NonConnectionError),       // Errors relating to issues and situations surrounding connections, not necessarily the connections themselves.       (If you're connected, don't drop it because you've received this error.)
    Disconnecting, //(SendableText),
    Disconnected, //(SendableText),
    NotConnected, //(SendableText),
    //SendingPongFrame,
    //SendingCloseFrame,
    //PingFrameReceived, //(SendableText),
    //PingFrameSent,
    //PongFrameReceived, //(SendableText),
    PongFrameSent,
    //CloseFrameReceived, //(SendableText)
    CloseFrameSent,
    ReadFrame(OwnedFrame),
    CloseWindowElapsed      //Disconnected

}

impl WebSocketActorOutputMessage
{

    pub fn is_new_connection(&self) -> bool
    {

        matches!(self, WebSocketActorOutputMessage::NewConnection)

    }

    pub fn is_connection_error(&self) -> bool
    {

        matches!(self, WebSocketActorOutputMessage::ConnectionError(_))

    }

    pub fn is_non_connection_error(&self) -> bool
    {

        matches!(self, WebSocketActorOutputMessage::NonConnectionError(_))

    }

    pub fn is_disconnecting(&self) -> bool
    {

        matches!(self, WebSocketActorOutputMessage::Disconnecting)

    }

    pub fn is_disconnected(&self) -> bool
    {

        matches!(self, WebSocketActorOutputMessage::Disconnected)

    }

    pub fn is_pong_frame_sent(&self) -> bool
    {

        matches!(self, WebSocketActorOutputMessage::PongFrameSent)

    }

    pub fn is_close_frame_sent(&self) -> bool
    {

        matches!(self, WebSocketActorOutputMessage::CloseFrameSent)

    }

    pub fn is_read_frame(&self) -> bool
    {

        matches!(self, WebSocketActorOutputMessage::ReadFrame(_))

    }

    pub fn is_close_window_elapsed(&self) -> bool
    {

        matches!(self, WebSocketActorOutputMessage::CloseWindowElapsed)

    }

    pub fn try_get_control_message(&self) -> Option<WebSocketActorControlMessage>
    {

        match self
        {

            WebSocketActorOutputMessage::NewConnection => Some(WebSocketActorControlMessage::NewConnection),
            WebSocketActorOutputMessage::ConnectionError(sendable_text) => Some(WebSocketActorControlMessage::ConnectionError(sendable_text.clone())),
            WebSocketActorOutputMessage::NonConnectionError(non_connection_error) => Some(WebSocketActorControlMessage::NonConnectionError(non_connection_error.clone())),
            WebSocketActorOutputMessage::Disconnecting => Some(WebSocketActorControlMessage::Disconnecting),
            WebSocketActorOutputMessage::Disconnected => Some(WebSocketActorControlMessage::Disconnected),
            WebSocketActorOutputMessage::NotConnected => Some(WebSocketActorControlMessage::NotConnected),
            //WebSocketActorOutputMessage::SendingPongFrame => Some(WebSocketActorControlMessage::SendingPongFrame),
            //WebSocketActorOutputMessage::SendingCloseFrame => Some(WebSocketActorControlMessage::SendingCloseFrame),
            //WebSocketActorOutputMessage::PingFrameReceived => Some(WebSocketActorControlMessage::PingFrameReceived),
            //WebSocketActorOutputMessage::PingFrameSent => Some(WebSocketActorControlMessage::PingFrameSent),
            //WebSocketActorOutputMessage::PongFrameReceived => Some(WebSocketActorControlMessage::PongFrameReceived),
            WebSocketActorOutputMessage::PongFrameSent => Some(WebSocketActorControlMessage::PongFrameSent),
            //WebSocketActorOutputMessage::CloseFrameReceived => Some(WebSocketActorControlMessage::CloseFrameReceived),
            WebSocketActorOutputMessage::CloseFrameSent=> Some(WebSocketActorControlMessage::CloseFrameSent),
            WebSocketActorOutputMessage::ReadFrame(_) => None,
            WebSocketActorOutputMessage::CloseWindowElapsed => Some(WebSocketActorControlMessage::CloseWindowElapsed)

        }

    }

    pub fn try_get_worker_message<T>(&self) -> Option<WebSocketActorWorkerMessage<T>>
    {

        match self
        {

            WebSocketActorOutputMessage::NewConnection => Some(WebSocketActorWorkerMessage::NewConnection),
            WebSocketActorOutputMessage::ConnectionError(_sendable_text) => Some(WebSocketActorWorkerMessage::Disconnected),
            WebSocketActorOutputMessage::NonConnectionError(_sendable_text) => None,
            WebSocketActorOutputMessage::Disconnecting => Some(WebSocketActorWorkerMessage::Disconnecting),
            WebSocketActorOutputMessage::Disconnected => Some(WebSocketActorWorkerMessage::Disconnected),
            WebSocketActorOutputMessage::NotConnected => None,
            //WebSocketActorOutputMessage::SendingPongFrame => None,
            //WebSocketActorOutputMessage::SendingCloseFrame => None,
            //WebSocketActorOutputMessage::PingFrameReceived => None,
            //WebSocketActorOutputMessage::PingFrameSent => None,
            //WebSocketActorOutputMessage::PongFrameReceived => None,
            WebSocketActorOutputMessage::PongFrameSent => None,
            //WebSocketActorOutputMessage::CloseFrameReceived => None,
            WebSocketActorOutputMessage::CloseFrameSent => None,
            WebSocketActorOutputMessage::ReadFrame(_owned_frame) => None,
            WebSocketActorOutputMessage::CloseWindowElapsed => Some(WebSocketActorWorkerMessage::Disconnected)

        }

    }

    pub fn try_into_worker_frame_message(self) -> Option<WebSocketActorWorkerFrameMessage>
    {

        match self
        {

            WebSocketActorOutputMessage::NewConnection => Some(WebSocketActorWorkerFrameMessage::NewConnection),
            WebSocketActorOutputMessage::ConnectionError(_sendable_text) => Some(WebSocketActorWorkerFrameMessage::Disconnected),
            WebSocketActorOutputMessage::NonConnectionError(_sendable_text) => None,
            WebSocketActorOutputMessage::Disconnecting => Some(WebSocketActorWorkerFrameMessage::Disconnecting),
            WebSocketActorOutputMessage::Disconnected => Some(WebSocketActorWorkerFrameMessage::Disconnected),
            WebSocketActorOutputMessage::NotConnected => None,
            //WebSocketActorOutputMessage::SendingPongFrame => None,
            //WebSocketActorOutputMessage::SendingCloseFrame => None,
            //WebSocketActorOutputMessage::PingFrameReceived => None,
            //WebSocketActorOutputMessage::PingFrameSent => None,
            //WebSocketActorOutputMessage::PongFrameReceived => None,
            WebSocketActorOutputMessage::PongFrameSent => None,
            //WebSocketActorOutputMessage::CloseFrameReceived => None,*/
            WebSocketActorOutputMessage::CloseFrameSent => None,
            WebSocketActorOutputMessage::ReadFrame(owned_frame) => Some(WebSocketActorWorkerFrameMessage::ReadFrame(owned_frame)),
            WebSocketActorOutputMessage::CloseWindowElapsed => Some(WebSocketActorWorkerFrameMessage::Disconnected)

        }

    }

    /*
    pub fn try_get_essential_control_message(&self) -> Option<WebSocketActorControlOutputMessage>
    {

        match self
        {

            //WebSocketActorOutputMessage::ConnectionSucceeded => Some(WebSocketActorControlOutputMessage::ConnectionSucceeded),
            WebSocketActorOutputMessage::NewConnection => Some(WebSocketActorControlOutputMessage::NewConnection),
            WebSocketActorOutputMessage::ConnectionError(sendable_text) => Some(WebSocketActorControlOutputMessage::ConnectionError(sendable_text.clone())),
            WebSocketActorOutputMessage::NonConnectionError(sendable_text) => Some(WebSocketActorControlOutputMessage::NonConnectionError(sendable_text.clone())),
            WebSocketActorOutputMessage::Disconnected => Some(WebSocketActorControlOutputMessage::Disconnected),
            WebSocketActorOutputMessage::Disconnecting => Some(WebSocketActorControlOutputMessage::Disconnecting),
            WebSocketActorOutputMessage::NotConnected => None,
            WebSocketActorOutputMessage::PingFrameReceived => None,
            WebSocketActorOutputMessage::PongFrameReceived => None,
            WebSocketActorOutputMessage::CloseFrameReceived => None,
            WebSocketActorOutputMessage::ReadFrame(_) => None

        }

    }
    */

    /*
    pub fn try_into_control_message(self) -> WebSocketActorControlOrFullOutputMessage
    {

        match self
        {
            WebSocketActorOutputMessage::ConnectionSucceeded =>
            {

                WebSocketActorControlOrFullOutputMessage::Control(WebSocketActorControlOutputMessage::ConnectionSucceeded)

            }
            WebSocketActorOutputMessage::ConnectionError(sendable_text) =>
            {

                WebSocketActorControlOrFullOutputMessage::Control(WebSocketActorControlOutputMessage::ConnectionSucceeded)

            }
            WebSocketActorOutputMessage::Disconnected => todo!(),
            WebSocketActorOutputMessage::Disconnecting => todo!(),
            WebSocketActorOutputMessage::NotConnected => todo!(),
            WebSocketActorOutputMessage::PingFrameReceived => todo!(),
            WebSocketActorOutputMessage::PongFrameReceived => todo!(),
            WebSocketActorOutputMessage::CloseFrameReceived => todo!(),
        }
    
    }
    */

}

//#[derive(Debug)]
//pub enum WebSocketClientActorControlOutputMessage
#[derive(Debug)]
pub enum WebSocketActorControlMessage
{

    NewConnection,
    //ConnectionSucceeded,
    ConnectionError(SendableText),
    NonConnectionError(NonConnectionError), //(SendableText),
    Disconnecting,
    Disconnected,
    NotConnected,
    //SendingPongFrame,
    //SendingCloseFrame,
    //PingFrameReceived,
    //PingFrameSent,
    //PongFrameReceived,
    PongFrameSent,
    //CloseFrameReceived,
    CloseFrameSent,
    CloseWindowElapsed

}

impl WebSocketActorControlMessage
{

    pub fn is_new_connection(&self) -> bool
    {

        matches!(self, WebSocketActorControlMessage::NewConnection)

    }

    pub fn is_connection_error(&self) -> bool
    {

        matches!(self, WebSocketActorControlMessage::ConnectionError(_))

    }

    pub fn is_non_connection_error(&self) -> bool
    {

        matches!(self, WebSocketActorControlMessage::NonConnectionError(_))

    }

    pub fn is_disconnecting(&self) -> bool
    {

        matches!(self, WebSocketActorControlMessage::Disconnecting)

    }

    pub fn is_disconnected(&self) -> bool
    {

        matches!(self, WebSocketActorControlMessage::Disconnected)

    }

    pub fn is_pong_frame_sent(&self) -> bool
    {

        matches!(self, WebSocketActorControlMessage::PongFrameSent)

    }

    pub fn is_close_frame_sent(&self) -> bool
    {

        matches!(self, WebSocketActorControlMessage::CloseFrameSent)

    }

    pub fn is_close_window_elapsed(&self) -> bool
    {

        matches!(self, WebSocketActorControlMessage::CloseWindowElapsed)

    }

}

#[derive(Debug)]
pub enum WebSocketActorWorkerFrameMessage
{

    NewConnection,
    Disconnecting,
    Disconnected,
    ReadFrame(OwnedFrame)

}

impl WebSocketActorWorkerFrameMessage
{

    pub fn is_new_connection(&self) -> bool
    {

        matches!(self, WebSocketActorWorkerFrameMessage::NewConnection)

    }

    pub fn is_disconnecting(&self) -> bool
    {

        matches!(self, WebSocketActorWorkerFrameMessage::Disconnecting)

    }

    pub fn is_disconnected(&self) -> bool
    {

        matches!(self, WebSocketActorWorkerFrameMessage::Disconnected)

    }

    pub fn is_read_frame(&self) -> bool
    {

        matches!(self, WebSocketActorWorkerFrameMessage::ReadFrame(_))

    }

}

//#[derive(Debug)]
pub enum WebSocketActorWorkerMessage<T>
{

    NewConnection,
    Disconnecting,
    Disconnected,
    WorkInfo(T)

}

impl<T> WebSocketActorWorkerMessage<T>
{

    pub fn is_new_connection(&self) -> bool
    {

        matches!(self, WebSocketActorWorkerMessage::NewConnection)

    }

    pub fn is_disconnecting(&self) -> bool
    {

        matches!(self, WebSocketActorWorkerMessage::Disconnecting)

    }

    pub fn is_disconnected(&self) -> bool
    {

        matches!(self, WebSocketActorWorkerMessage::Disconnected)

    }

    pub fn is_work_info(&self) -> bool
    {

        matches!(self, WebSocketActorWorkerMessage::WorkInfo(_))

    }

}

impl<T> Debug for WebSocketActorWorkerMessage<T>
    where T: Debug
{

    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Self::NewConnection => write!(f, "NewConnection"),
            Self::Disconnecting => write!(f, "Disconnecting"),
            Self::Disconnected => write!(f, "Disconnected"),
            Self::WorkInfo(arg0) => f.debug_tuple("WorkInfo").field(arg0).finish(),
        }
    }

}

/*
#[derive(Debug)]
pub enum WebSocketActorEssentialControlOutputMessage
{

    NewConnection,
    //ConnectionSucceeded,
    ConnectionError(SendableText),
    Disconnected,
    Disconnecting

}
*/

/*
#[derive(Debug)]
pub enum WebSocketActorControlOrFullOutputMessage
{

    Control(WebSocketActorControlOutputMessage),
    Full(WebSocketActorOutputMessage)

}
*/

//Server actor - for a single connection

/*
#[derive(Debug)]
pub enum WebSocketServerActorInputMessage
{

    NewConnection(UpgradeFut),
    Disconnect,
    DisconnectNow,
    WriteFrame(OwnedFrame)

}
*/

/*
#[derive(Debug)]
pub enum WebSocketServerActorOutputMessage
{


}
*/

//ReadWebSocketActors

//Back-channel messages

//#[derive(Debug)]
pub enum ReadWebSocketActorInputMessage
{

    NewConnection(WebSocketReader),
    Disconnecting,
    Disconnect

}

impl ReadWebSocketActorInputMessage
{

    pub fn is_new_connection(&self) -> bool
    {

        matches!(self, ReadWebSocketActorInputMessage::NewConnection(_))

    }

    pub fn is_disconnecting(&self) -> bool
    {

        matches!(self, ReadWebSocketActorInputMessage::Disconnecting)

    }

    pub fn is_disconnect(&self) -> bool
    {

        matches!(self, ReadWebSocketActorInputMessage::Disconnect)

    }
    
}

impl Debug for ReadWebSocketActorInputMessage
{

    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Self::NewConnection(arg0) => f.debug_tuple("NewConnection").finish(), //.field(arg0)
            Self::Disconnecting => write!(f, "Disconnecting"),
            Self::Disconnect => write!(f, "Disconnect"),
        }
    }

}

#[derive(Debug)]
pub enum ReadWebSocketActorOutputMessage
{

    //CloseFrameReceived,
    //PingFrameReceived,
    //ReadFrame(OwnedFrame),
    ReadFrame(OwnedFrame), //Should be used for passing obligated frames to the WebSocketActor only.
    Disconnected,
    //ConnectionError(SendableText) //Send the ConnectionError directly.
    
}

impl ReadWebSocketActorOutputMessage
{

    pub fn is_read_frame(&self) -> bool
    {

        matches!(self, ReadWebSocketActorOutputMessage::ReadFrame(_))

    }

    pub fn is_disconnected(&self) -> bool
    {

        matches!(self,ReadWebSocketActorOutputMessage::Disconnected)

    }

}

//What has happened in the write-side of the current websocket actor?

//Should it continue executing?

#[derive(Debug)]
pub enum WebSocketWriterActorInternalMessage //<T>
{

    //NewConnection(T),
    ConnectionError, //(SendableText),
    NonConnectionError, //(NonConnectionError),
    //Disconnecting,
    Disconnected,
    NotConnected,
    //PongFrameSent,
    //CloseFrameSent,
    //ReadFrame(OwnedFrame),
    //CloseWindowElapsed
    //ReadWebSocketActorDropped,
    WebSocketReaderActorChannelSenderClosed,
    WebSocketReaderActorChannelReceiverClosed,
    ActorChannelSenderClosed,
    ActorChannelReceiverClosed

}

impl WebSocketWriterActorInternalMessage //<T>
{

    pub fn is_connection_error(&self) -> bool
    {

        matches!(self, WebSocketWriterActorInternalMessage::ConnectionError)

    }

    pub fn is_non_connection_error(&self) -> bool
    {

        matches!(self, WebSocketWriterActorInternalMessage::NonConnectionError)

    }

    pub fn is_disconnected(&self) -> bool
    {

        matches!(self, WebSocketWriterActorInternalMessage::Disconnected)

    }

    pub fn is_not_connected(&self) -> bool
    {

        matches!(self, WebSocketWriterActorInternalMessage::NotConnected)

    }

    pub fn is_web_socket_reader_actor_channel_sender_closed(&self) -> bool
    {

        matches!(self, WebSocketWriterActorInternalMessage::WebSocketReaderActorChannelSenderClosed)

    }

    pub fn is_web_socket_reader_actor_channel_receiver_closed(&self) -> bool
    {

        matches!(self, WebSocketWriterActorInternalMessage::WebSocketReaderActorChannelReceiverClosed)

    }

    pub fn is_actor_channel_sender_closed(&self) -> bool
    {

        matches!(self, WebSocketWriterActorInternalMessage::ActorChannelSenderClosed)

    }

    pub fn is_actor_channel_receiver_closed(&self) -> bool
    {

        matches!(self, WebSocketWriterActorInternalMessage::ActorChannelReceiverClosed)

    }

    pub fn should_continue(&self) -> bool
    {

        match self
        {

            WebSocketWriterActorInternalMessage::WebSocketReaderActorChannelSenderClosed | WebSocketWriterActorInternalMessage::WebSocketReaderActorChannelReceiverClosed | WebSocketWriterActorInternalMessage::ActorChannelSenderClosed | WebSocketWriterActorInternalMessage::ActorChannelReceiverClosed =>
            {

                false

            }
            _ =>
            {

                true

            }

        }

    }

}

pub type InternalConnectionResult<T> = Result<T, WebSocketWriterActorInternalMessage>;

/*
pub enum ConnectedOrOther<T>
{

    Connected(T),
    Other(WebSocketWriterActorInternalMessage)

}
*/