#[derive(Serialize, Deserialize)]
#[serde(tag = "schema_version")]
enum E {
    #[serde(rename = 1)]
    V1(...),
    #[serde(rename = 2)]
    V2(...),
}

#[derive(Serialize, Deserialize)]
#[serde(tag = "error")]
enum Response {
    #[serde(rename = false)]
    Ok(QueryResult),
    #[serde(rename = true)]
    Err(QueryError),
}

//! ```cargo
//! [dependencies]
//! serde = "1"
//! serde_repr = "0.1"
//! serde_json = "1"
//! ```

use std::fmt;

#[derive(Copy, Clone, Debug, serde_repr::Serialize_repr, serde_repr::Deserialize_repr)]
#[repr(i32)]
pub enum Test {
    Foo = 0,
    Bar = 2,
}

fn main() {
    println!("{}", serde_json::to_string(&Test::Foo).unwrap());
    println!("{:?}", serde_json::from_str::<Test>("0").unwrap());
}

#[derive(Serialize, Deserialize, Debug)]
#[serde(untagged)]
pub enum Bla {
    V1 {
        hello: String,
        version: Option<Version<1>>,
    },
    V2 {
        foo: String,
        version: Version<2>,
    },
}

#[derive(Debug)]
pub struct Version<const V: u8>;

#[derive(Debug, Error)]
#[error("Invalid version")]
struct VersionError;

impl<const V: u8> Serialize for Version<V> {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        serializer.serialize_u8(V)
    }
}

impl<'de, const V: u8> Deserialize<'de> for Version<V> {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        let value = u8::deserialize(deserializer)?;
        if value == V {
            Ok(Version::<V>)
        } else {
            Err(serde::de::Error::custom(VersionError))
        }
    }
}

#[derive(Clone, Debug)]
pub struct Edition<const V: u8>;

impl<const V: u8> Edition<V> {
    pub const ERROR: &'static str = "Invalid edition";
}

impl<const V: u8> PartialEq<Edition<V>> for u8 {
    fn eq(&self, _: &Edition<V>) -> bool {
        V == *self
    }
}

impl<const V: u8> Serialize for Edition<V> {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        serializer.serialize_u8(V)
    }
}

impl<'de, const V: u8> Deserialize<'de> for Edition<V> {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        let value = u8::deserialize(deserializer)?;
        if value == V {
            Ok(Edition::<V>)
        } else {
            Err(serde::de::Error::custom(Self::ERROR))
        }
    }
}

impl<const V: u8> JsonSchema for Edition<V> {
    fn schema_name() -> String {
        "Edition".to_owned()
    }

    fn schema_id() -> Cow<'static, str> {
        Cow::Owned(format!("Edition_{}", V))
    }

    fn json_schema(gen: &mut schemars::gen::SchemaGenerator) -> Schema {
        use schemars::schema::*;

        let mut schema = gen.subschema_for::<u8>();
        if let Schema::Object(schema_object) = &mut schema {
            if schema_object.has_type(InstanceType::Integer)
                || schema_object.has_type(InstanceType::Number)
            {
                let validation = schema_object.number();
                validation.minimum = Some(V as f64);
                validation.maximum = Some(V as f64);
            }
        }
        schema
    }
}

#[derive(Serialize)]
#[serde(untagged)]
pub enum MyObject {
    V2(v2::MyObject),
    V1(v1::MyObject),
}

impl<'de> Deserialize<'de> for MyObject {
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        use serde::__private::de::{Content, ContentRefDeserializer};

        let content = Content::deserialize(deserializer)?;

        match v2::MyObject::deserialize(ContentRefDeserializer::<D::Error>::new(&content))
        {
            Ok(v) => return Ok(ParsableWorkflow::V2(v)),
            Err(e) if e.to_string() != Edition::<2>::ERROR => return Err(e),
            Err(_) => {}
        }

        match v1::MyObject::deserialize(ContentRefDeserializer::<D::Error>::new(&content))
        {
            Ok(v) => return Ok(ParsableWorkflow::V1(v)),
            Err(e) if e.to_string() != Edition::<1>::ERROR => return Err(e),
            Err(_) => {}
        }

        Err(serde::de::Error::custom(
            "data did not match any variant of untagged enum MyObject",
        ))
    }
}