verdigris 0.2.1

use yew::worker::*;

use crate::coapwsmessage::{CoAPWSMessageR, CoAPWSMessageW};

use coap_message::{MinimalWritableMessage, ReadableMessage};
use coap_handler_implementations::option_processing::OptionsExt;

pub enum Input {
    Initialize { uri: String },
    Message(CoAPWSMessageW),
}

#[derive(Debug)]
/// Event generated by a Connection
///
/// Most applications will want to match for Connected while waiting for the Go to send, and
/// Message later on, and treat anything else as an error that can be Debug-displayed. A connection
/// being closed by the peer, no matter how orderly, is expressed as an error (but without any
/// outstanding or later requests to send, servers will typically discard them anyway).
///
/// The regular sequence of messages produced is a Connected, followed by any sequence of Message
/// and SignalingInfo events. An error can be produced at any time. It is final; no more events
/// will be reported, and any input sent is ignored.
///
/// ```text
///               /---[ Connected ] ----- [ Message or SignalingInfo ]--\
///              /                    /                                 |
///   <start>---<                     \_________________________________/\
///              \________________________________________________________>---[ Error(...) ]
/// ```
pub enum Output {
    /// Connection is now ready. Emitted once, and before any Received events. Does not yet contain
    /// the CSM; that will be reported later (and, if the peer behaves correctly but that's not
    /// checked for here, immediately) as the next event.
    Connected,

    /// A (non-signaling) CoAP messager was received
    Message(CoAPWSMessageR<Box<[u8]>>),

    /// A signaling message was received and handled by the Connection. The application does not
    /// need to process this any further (but may display it for debugging purposes or draw
    /// additional conclusions from it). Most applications can treat this as a no-op (which is
    /// needs to be sent anyway as the construction of this inside the yew ecosystem means that
    /// every message from the socket must result in exactly one message to the application).
    ///
    /// This includes Release messages.
    SignalingInfo(CoAPWSMessageR<Box<[u8]>>),

    Error(OutputError)
}

#[derive(Debug)]
#[non_exhaustive]
/// As errors could be added later, they are expressed in a non-exhaustive fashion.
pub enum OutputError {
    /// The connection can't even be created
    ConnectError(String),
    /// A malformed message was received
    ParseError(&'static str),
    /// A text message was received (that's a protocol error too, but it may help to show the text
    /// for debugging purposes).
    // It's admittedly a bit inconsistent to strip the variable-lengthness off the box but not of
    // the error; this is primarily because Box<str> is an unfamiliar idiom but Box<[u8]> is more
    // common, and because TextReceived is a corner case anyway (where optimization does not matter
    // a lot) while CoAPWSMessageR<Box<[u8]>> is the regular case.
    TextReceived(String),
    /// An unknown signaling message was received, aborting the connection.
    ///
    /// This includes Abort messages.
    SignalingError(CoAPWSMessageR<Box<[u8]>>),
    /// The connection was closed
    Closed,
    /// An error was reported by the WebSocket
    SocketError,
}

impl From<OutputError> for Output {
    fn from(e: OutputError) -> Output {
        Output::Error(e)
    }
}

/// A pool of CoAP-over-WS connections that is usable inside yew.
///
/// (This being a pool is not really essential to the functionality, but a consequence of the way
/// actors are designed or bridges are implemented).
///
/// This is only responsible for opening up a connection, parsing/serializing in- and outgoing
/// messages, and handling signalling messages. It does not take tasks like managing tokens or
/// request/response correlation, and only passes on messages. The only active part in the protocol
/// it takes is determining low-level protocol errors, handling signaling messages and responding
/// to them by closing the connection.
///
/// As this does not handle tokens on its own, each bridge (handler) requesting a connection will
/// get its own connection. A 
pub struct Connection {
    tasks: std::collections::HashMap<HandlerId, crate::ws::Websocket>,
    link: AgentLink<Self>,
}

impl Agent for Connection {
    type Reach = Context<Self>;
    type Message = (HandlerId, WSMsg);
    type Input = Input;
    type Output = Output;

    fn create(
        link: AgentLink<Self>,
    ) -> Self {
        let tasks =  Default::default();
        Connection {
            tasks,
            link,
        }
    }

    fn disconnected(&mut self, id: HandlerId) {
        // It's OK if that is None -- then either there was no connect, or there was an error
        drop(self.tasks.remove(&id));
    }

    // Data coming from the socket
    fn update(&mut self, (handler, msg): (HandlerId, WSMsg)) {
        let Some(socket) = self.tasks.get_mut(&handler) else {
            // Not complaining loudly -- the message could have been enqueued before we decided to
            // drop the task in the last error.
            return;
        };

        match msg {
            WSMsg::Opened => {
                let mut empty_csm = CoAPWSMessageW::new(&[]);
                empty_csm.set_code(coap_numbers::code::CSM);

                if socket.send_binary(&empty_csm.serialize()).is_err() {
                    self.link.respond(handler, OutputError::SocketError.into());
                    self.tasks.remove(&handler);
                    return;
                }

                self.link.respond(handler, Output::Connected);
            }
            WSMsg::Binary(data) => {
                // Making the Vec into a Box primarily because we'd never use its variability any
                // more anyway. (Why does yew even make it one?)
                let msg = CoAPWSMessageR::new(data.into_boxed_slice());
                let msg = match msg {
                    Err(e) => {
                        self.link.respond(handler, OutputError::ParseError(e).into());
                        self.tasks.remove(&handler);
                        return;
                    }
                    Ok(m) => m,
                };

                if coap_numbers::code::classify(msg.code()) == coap_numbers::code::Range::Signaling {
                    match msg.code() {
                        coap_numbers::code::CSM | coap_numbers::code::RELEASE => {
                            let opts = msg.options().ignore_elective_others();
                            if opts.is_err() {
                                self.link.respond(handler, OutputError::SignalingError(msg).into());
                                self.tasks.remove(&handler);
                                return;
                            }
                        },
                        coap_numbers::code::PING => {
                            let mut pong = CoAPWSMessageW::new(msg.token());
                            pong.set_code(coap_numbers::code::PONG);

                            // When custody is implemented, this here would be the time to
                            // set custody on the response
                            let opts = msg.options().ignore_elective_others();
                            if opts.is_err() {
                                self.link.respond(handler, OutputError::SignalingError(msg).into());
                                self.tasks.remove(&handler);
                                return;
                            }
                            if socket.send_binary(&pong.serialize()).is_err() {
                                self.link.respond(handler, OutputError::SocketError.into());
                                self.tasks.remove(&handler);
                                return;
                            }
                        }
                        // including ABORT
                        _ => {
                            self.link.respond(handler, OutputError::SignalingError(msg).into());
                            self.tasks.remove(&handler);
                            return;
                        },
                    }

                    self.link.respond(handler, Output::SignalingInfo(msg));

                    return;
                }

                self.link.respond(handler, Output::Message(msg));
            }
            WSMsg::Close => {
                self.link.respond(handler, OutputError::Closed.into());
                self.tasks.remove(&handler);
            }
            WSMsg::Error => {
                self.link.respond(handler, OutputError::SocketError.into());
                self.tasks.remove(&handler);
            }
        }
    }

    // Data coming from a user
    fn handle_input(&mut self, input: Input, handler: HandlerId) {
        match input {
            Input::Initialize { uri } => {
                let on_message = self.link.callback(move |m| (handler, WSMsg::Binary(m)));
                let on_open = self.link.callback(move |()| (handler, WSMsg::Opened));
                let on_error = self.link.callback(move |()| (handler, WSMsg::Error));
                let on_close = self.link.callback(move |()| (handler, WSMsg::Close));
                let Ok(socket) = crate::ws::Websocket::new(&uri, "coap",
                    move |msg| on_message.emit(msg),
                    move || on_open.emit(()),
                    move || on_error.emit(()),
                    move || on_close.emit(()),
                    ) else {
                    self.link.send_message((handler, WSMsg::Error));
                    return;
                };

                let old = self.tasks.insert(handler, socket);
                debug_assert!(old.is_none(), "Double initialization message");
            }
            Input::Message(msg) => {
                let Some(socket) = self.tasks.get_mut(&handler) else {
                    // Usage error -- but not complaining, maybe the message was racing against our
                    // error notification?
                    return;
                };

                if socket.send_binary(&msg.serialize()).is_err() {
                    self.link.send_message((handler, WSMsg::Error));
                };
            }
        }
    }
}

/// Just a single message to represent all that can come in from yew
#[derive(Debug)]
// FIXME Can this be hidden even more effectively? Just because it's in my type doesn't mean
// anything about its internals should be public.
#[doc(hidden)]
pub enum WSMsg {
    Opened,
    Error,
    Close,
    Binary(Vec<u8>),
}