//! Module containing the [SimpleWrapper] handler and the [SimpleCBORHandler] (to be renamed)
//! trait, along with the [SimpleSerialization] helper trait and its corresponding implementations
//! for various serde(ish) (de)serializers.

use crate::helpers::{block2_write_with_cf, codeconvert, Block2RequestData};
use crate::Code;
use coap_handler::Handler;
use coap_message::{MessageOption, MutableWritableMessage, ReadableMessage};
use coap_numbers::{code, option};
use core::marker::PhantomData;

use serde::Serialize;

/// A simple Handler trait that supports GET, POST and/or PUT on a data structure that supports
/// serde.
///
/// A SimpleCBORHandler implementation can be turned into a [Handler] by wrapping it in
/// [SimpleWrapper::new].
///
/// The type a misnomer that can't be fixed until trait aliases are stabilized: It doesn't need to
/// turn into CBOR, just something the Simple...Wrapper can (de)serialize.
pub trait SimpleCBORHandler {
    type Get;
    type Post;
    type Put;

    fn get(&mut self) -> Result<Self::Get, Code> {
        Err(code::METHOD_NOT_ALLOWED)
    }
    fn post(&mut self, _representation: &Self::Post) -> Code {
        code::METHOD_NOT_ALLOWED
    }
    fn put(&mut self, _representation: &Self::Put) -> Code {
        code::METHOD_NOT_ALLOWED
    }
}

/// Keeping them hidden to stay flexible; they don't need to be named for their'e either default or
/// their users have aliases.
mod sealed {
    pub trait SimpleSerialization {
        const CF: Option<u16>;
    }

    pub struct SerdeCBORSerialization;
    pub struct MiniCBORSerialization;
}
use sealed::*;

impl SimpleSerialization for SerdeCBORSerialization {
    const CF: Option<u16> = Some(60);
}
impl SimpleSerialization for MiniCBORSerialization {
    const CF: Option<u16> = Some(60);
}

/// Wrapper for resource handlers that are implemented in terms of GETting, POSTing or PUTting
/// objects in CBOR format.
///
/// The wrapper handles all encoding and decoding, options processing (ignoring the critical
/// Uri-Path option under the assumption that that has been already processed by an underlying
/// request router), the corresponding errors and block-wise GETs.
///
/// More complex handlers (eg. implementing additional representations, or processing query
/// aprameters into additional data available to the [SimpleCBORHandler]) can be built by
/// forwarding to this (where any critical but already processed options would need to be masked
/// from the message's option) or taking inspiration from it.
pub struct SimpleWrapper<H, S: SimpleSerialization = SerdeCBORSerialization>
where
    H: SimpleCBORHandler,
{
    handler: H,
    _phantom: PhantomData<S>,
}
#[deprecated(note = "Renamed to SimpleWrapper")]
pub type SimpleCBORWrapper<H> = SimpleWrapper<H, SerdeCBORSerialization>;

impl<H, S> SimpleWrapper<H, S>
where
    H: SimpleCBORHandler,
    S: SimpleSerialization,
{
    fn check_get_options(request: &impl ReadableMessage) -> Result<Block2RequestData, Code> {
        let mut block2 = Ok(None);

        for o in request.options() {
            match o.number() {
                option::ACCEPT => {
                    if let Some(cf) = S::CF {
                        if o.value_uint() != Some(cf) {
                            return Err(code::UNSUPPORTED_CONTENT_FORMAT);
                        }
                    }
                }
                option::BLOCK2 => {
                    block2 = match block2 {
                        Err(e) => Err(e),
                        Ok(Some(_)) => Err(coap_numbers::code::BAD_REQUEST),
                        Ok(None) => Block2RequestData::from_option(&o)
                            .map(Some)
                            .map_err(|_| code::BAD_REQUEST),
                    }
                }
                o if option::get_criticality(o) == option::Criticality::Critical => {
                    return Err(code::BAD_OPTION);
                }
                _ => {}
            }
        }

        Ok(block2?.unwrap_or_default())
    }

    fn check_postput_options(request: &impl ReadableMessage) -> Result<(), Code> {
        for o in request.options() {
            match o.number() {
                option::CONTENT_FORMAT => {
                    if let Some(cf) = S::CF {
                        if o.value_uint() != Some(cf) {
                            return Err(code::NOT_ACCEPTABLE);
                        }
                    } else {
                        /* Nothing was configured, not letting the option pass */
                        return Err(code::NOT_ACCEPTABLE);
                    }
                }
                o if option::get_criticality(o) == option::Criticality::Critical => {
                    return Err(code::BAD_OPTION);
                }
                _ => {}
            }
        }

        Ok(())
    }
}

impl<H> SimpleWrapper<H, SerdeCBORSerialization>
where
    H: SimpleCBORHandler,
    H::Get: for<'de> serde::Serialize,
    H::Post: for<'de> serde::Deserialize<'de>,
    H::Put: for<'de> serde::Deserialize<'de>,
{
    pub fn new(handler: H) -> Self {
        SimpleWrapper {
            handler,
            _phantom: PhantomData,
        }
    }
}

#[cfg(feature = "minicbor")]
impl<H> SimpleWrapper<H, MiniCBORSerialization>
where
    H: SimpleCBORHandler,
    H::Get: for<'de> minicbor::Encode,
    H::Post: for<'de> minicbor::Decode<'de>,
    H::Put: for<'de> minicbor::Decode<'de>,
{
    pub fn new_minicbor(handler: H) -> Self {
        SimpleWrapper {
            handler,
            _phantom: PhantomData,
        }
    }
}

/// Data carried around between a request and its response for [SimpleWrapper]s
pub enum SimpleRequestData {
    Get(Block2RequestData), // GET to be processed later, but all request opions were in order
    Done(Code), // All done, just a response to emit -- if POST/PUT has been processed, or GET had a bad accept/option
}
#[deprecated(note = "Renamed to SimpleRequestData")]
pub type SimpleCBORRequestData = SimpleRequestData;
use self::SimpleRequestData::{Done, Get};

// FIXME for all the below: deduplicate (but not sure how, without HKTs)

impl<H> Handler for SimpleWrapper<H, SerdeCBORSerialization>
where
    H: SimpleCBORHandler,
    H::Get: for<'de> serde::Serialize,
    H::Post: for<'de> serde::Deserialize<'de>,
    H::Put: for<'de> serde::Deserialize<'de>,
{
    type RequestData = SimpleRequestData;

    fn extract_request_data(&mut self, request: &impl ReadableMessage) -> Self::RequestData {
        match request.code().into() {
            code::GET => match Self::check_get_options(request) {
                Err(e) => Done(e),
                Ok(block) => Get(block),
            },
            code::POST => {
                if let Err(e) = Self::check_postput_options(request) {
                    return Done(e);
                }

                // FIXME: allow getting a mutable payload here, which may be hard for general
                // Message but usually cheap for GNRC-based.
                let parsed: Result<H::Post, _> =
                    serde_cbor::de::from_slice_with_scratch(request.payload(), &mut []);
                match parsed {
                    Ok(p) => Done(self.handler.post(&p)),
                    Err(_) => Done(code::BAD_REQUEST),
                }
            }
            code::PUT => {
                if let Err(e) = Self::check_postput_options(request) {
                    return Done(e);
                }

                let parsed: Result<H::Put, _> =
                    serde_cbor::de::from_slice_with_scratch(request.payload(), &mut []);
                match parsed {
                    Ok(p) => Done(self.handler.put(&p)),
                    Err(_) => Done(code::BAD_REQUEST),
                }
            }
            _ => Done(code::METHOD_NOT_ALLOWED),
        }
    }

    fn estimate_length(&mut self, request: &Self::RequestData) -> usize {
        match request {
            Done(_) => 4,
            Get(block) => (block.size() + 25).into(), // FIXME: hard-coded copied over from block2_write_with_cf's estimated overhead
        }
    }

    fn build_response(
        &mut self,
        response: &mut impl MutableWritableMessage,
        request: Self::RequestData,
    ) {
        match request {
            Done(r) => {
                response.set_code(codeconvert(r));
                response.set_payload(b"");
            }
            Get(block2) => {
                let repr = self.handler.get();
                match repr {
                    Err(e) => {
                        response.set_code(codeconvert(e));
                        response.set_payload(b"");
                    }
                    Ok(repr) => {
                        response.set_code(codeconvert(code::CONTENT));
                        match block2_write_with_cf(
                            block2,
                            response,
                            |win| repr.serialize(&mut serde_cbor::ser::Serializer::new(win)),
                            SerdeCBORSerialization::CF,
                        ) {
                            Ok(()) => (),
                            Err(_) => {
                                // FIXME: Rewind all the written options
                                response.set_code(codeconvert(code::INTERNAL_SERVER_ERROR));
                            }
                        }
                    }
                }
            }
        }
    }
}

#[cfg(feature = "minicbor")]
impl<H> Handler for SimpleWrapper<H, MiniCBORSerialization>
where
    H: SimpleCBORHandler,
    H::Get: for<'de> minicbor::Encode,
    H::Post: for<'de> minicbor::Decode<'de>,
    H::Put: for<'de> minicbor::Decode<'de>,
{
    type RequestData = SimpleRequestData;

    fn extract_request_data(&mut self, request: &impl ReadableMessage) -> Self::RequestData {
        match request.code().into() {
            code::GET => match Self::check_get_options(request) {
                Err(e) => Done(e),
                Ok(block) => Get(block),
            },
            code::POST => {
                if let Err(e) = Self::check_postput_options(request) {
                    return Done(e);
                }

                let parsed: Result<H::Post, _> = minicbor::decode(request.payload());
                match parsed {
                    Ok(p) => Done(self.handler.post(&p)),
                    Err(_) => Done(code::BAD_REQUEST),
                }
            }
            code::PUT => {
                if let Err(e) = Self::check_postput_options(request) {
                    return Done(e);
                }

                let parsed: Result<H::Put, _> = minicbor::decode(request.payload());
                match parsed {
                    Ok(p) => Done(self.handler.put(&p)),
                    Err(_) => Done(code::BAD_REQUEST),
                }
            }
            _ => Done(code::METHOD_NOT_ALLOWED),
        }
    }

    fn estimate_length(&mut self, request: &Self::RequestData) -> usize {
        match request {
            Done(_) => 4,
            Get(block) => (block.size() + 25).into(), // FIXME: hard-coded copied over from block2_write_with_cf's estimated overhead
        }
    }

    fn build_response(
        &mut self,
        response: &mut impl MutableWritableMessage,
        request: Self::RequestData,
    ) {
        match request {
            Done(r) => {
                response.set_code(codeconvert(r));
                response.set_payload(b"");
            }
            Get(block2) => {
                let repr = self.handler.get();
                match repr {
                    Err(e) => {
                        response.set_code(codeconvert(e));
                        response.set_payload(b"");
                    }
                    Ok(repr) => {
                        response.set_code(codeconvert(code::CONTENT));
                        match block2_write_with_cf(
                            block2,
                            response,
                            |win| minicbor::encode(&repr, win),
                            MiniCBORSerialization::CF,
                        ) {
                            Ok(()) => (),
                            Err(_) => {
                                // FIXME: Rewind all the written options
                                response.set_code(codeconvert(code::INTERNAL_SERVER_ERROR));
                            }
                        }
                    }
                }
            }
        }
    }
}