use serde::{Deserialize, Deserializer};
use serde_json::json;

#[derive(Debug, Deserialize, PartialEq, Eq)]
struct Account {
    id: usize,
}

#[derive(Debug, Deserialize, PartialEq, Eq)]
struct Session {
    id: String,
}

#[derive(Debug, PartialEq, Eq)]
struct Response {
    accounts: Vec<Account>,
    session: Session,
}

impl<'de> Deserialize<'de> for Response {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>,
    {
        use serde::de::{Error, SeqAccess, Visitor};

        #[derive(Deserialize)]
        enum Item {
            Account(Account),
            Session(Session),
        }

        struct ResponseVisitor;

        impl<'de> Visitor<'de> for ResponseVisitor {
            type Value = Response;

            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("Response array structure")
            }

            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
            where
                A: SeqAccess<'de>,
            {
                let mut accounts = Vec::with_capacity(seq.size_hint().unwrap_or(0));

                while let Some(item) = seq.next_element()? {
                    match item {
                        Item::Account(account) => accounts.push(account),
                        Item::Session(session) => {
                            while let Some(item) = seq.next_element()? {
                                match item {
                                    Item::Account(account) => accounts.push(account),
                                    Item::Session(_session) => {
                                        return Err(Error::duplicate_field("Session"))
                                    }
                                }
                            }

                            return Ok(Response { accounts, session });
                        }
                    }
                }

                Err(Error::missing_field("Session"))
            }
        }

        deserializer.deserialize_seq(ResponseVisitor)
    }
}

#[test]
fn test() {
    let value = json!([
        {
            "Account": {
                "id": 0,
            }
        },
        {
            "Account": {
                "id": 1,
            }
        },
        {
            "Session": {
                "id": "hello!"
            }
        },
    ]);

    let response: Response = serde_json::from_value(value).unwrap();
    assert_eq!(
        response,
        Response {
            accounts: vec![Account { id: 0 }, Account { id: 1 },],
            session: Session {
                id: "hello!".to_string()
            }
        }
    );
}