ticketmaster-rs 0.0.9

use std::fmt::Display;

use serde::{Deserialize, Serialize};
use thiserror::Error;

#[derive(Serialize, Deserialize, Debug)]
pub struct DiscoveryPagedData<T> {
    pub page: PageInfo,
    #[serde(rename = "_embedded")]
    pub data: Option<T>,
}

impl<T> DiscoveryPagedData<T> {
    pub fn transform<R>(self, f: impl FnOnce(T) -> R) -> DiscoveryPagedData<R> {
        let Self { page, data } = self;

        let f = |a| Some(f(a));

        let data = data.and_then(f);
        DiscoveryPagedData { page, data }
    }
}

#[derive(Serialize, Deserialize, Debug)]
#[serde(rename_all = "camelCase")]
pub struct PageInfo {
    pub number: u64,
    pub size: u64,
    pub total_elements: u64,
    pub total_pages: u64,
}

#[derive(Serialize, Deserialize, Debug, Error)]
pub struct DiscoveryError {
    faultstring: String,
    detail: ErrorDetail,
}

impl Display for DiscoveryError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        writeln!(f, "error returned from ticketmaster")?;
        f.write_str(&serde_json::to_string_pretty(self).unwrap())
    }
}

#[derive(Serialize, Deserialize, Debug)]
pub struct ErrorDetail {
    pub errorcode: String,
}

#[derive(Serialize, Deserialize, Debug)]
pub(crate) struct ContainerError {
    pub fault: DiscoveryError,
}

#[derive(Serialize, Deserialize, Debug)]
#[serde(untagged)]
pub(crate) enum DiscoveryPagedResponse<T> {
    Fault(ContainerError),
    Data(DiscoveryPagedData<T>),
}

#[derive(Serialize, Deserialize, Debug)]
#[serde(untagged)]
pub(crate) enum DiscoveryResponse<T> {
    Fault(ContainerError),
    Data(T),
}

impl<T> DiscoveryPagedResponse<T> {
    pub fn into_result(self) -> crate::error::Result<DiscoveryPagedData<T>> {
        match self {
            Self::Data(data) => Ok(data),
            Self::Fault(ContainerError { fault }) => Err(fault)?,
        }
    }
}

impl<T> DiscoveryResponse<T> {
    pub fn into_result(self) -> crate::error::Result<T> {
        match self {
            Self::Data(data) => Ok(data),
            Self::Fault(ContainerError { fault }) => Err(fault)?,
        }
    }
}