cal-core 0.2.158

use std::fmt::{Debug, Formatter};
use std::collections::BTreeMap;
use bson::DateTime;
use serde::{Deserialize, Deserializer, Serialize};
use serde_json::Value;
#[cfg(feature = "openapi")]
use utoipa::ToSchema;

#[derive(Serialize, Deserialize, Clone, PartialEq, Eq, Hash)]
#[serde(rename_all = "camelCase")]
#[cfg_attr(feature = "openapi", derive(ToSchema))]
pub struct RecordReference {
    #[serde(deserialize_with = "object_id_as_string", rename = "_id")]
    pub id: String,
    pub name: String,
    #[serde(default)]
    pub meta: BTreeMap<String, String>,
}

impl RecordReference {
    /// Create a new RecordReference with empty metadata
    pub fn new(id: String, name: String) -> Self {
        Self {
            id,
            name,
            meta: BTreeMap::new(),
        }
    }

    /// Create a new RecordReference with metadata
    pub fn with_meta(id: String, name: String, meta: BTreeMap<String, String>) -> Self {
        Self { id, name, meta }
    }

    /// Create from a HashMap (for compatibility)
    pub fn with_meta_from_hashmap(id: String, name: String, meta: std::collections::HashMap<String, String>) -> Self {
        Self {
            id,
            name,
            meta: meta.into_iter().collect()
        }
    }

    /// Convenience methods matching Java API
    pub fn id(&self) -> &str {
        &self.id
    }

    pub fn name(&self) -> &str {
        &self.name
    }
}

pub fn from_str<'de, D>(deserializer: D) -> Result<u16, D::Error>
where
    D: Deserializer<'de>,
{
    let value = Value::deserialize(deserializer)?;
    if value.is_string() {
        Ok(value.as_str().unwrap().parse().unwrap())
    } else if value.is_u64() {
        Ok(value.as_u64().unwrap() as u16)
    } else if value.is_i64() {
        Ok(value.as_i64().unwrap() as u16)
    } else {
        Err(serde::de::Error::custom("Cannot map extension to u16"))
    }
}

pub fn object_id_as_string<'de, D>(deserializer: D) -> Result<String, D::Error>
where
    D: Deserializer<'de>,
{
    let value = Value::deserialize(deserializer)?;
    if value.is_string() {
        Ok(value.as_str().unwrap().to_string())
    } else {
        match value.get("$oid") {
            Some(v) => Ok(v.as_str().unwrap().to_string()),
            None => Err(serde::de::Error::custom("Oid is required")),
        }
    }
}

pub fn build_timestamp() -> DateTime {
    DateTime::now()
}

pub fn build_id() -> String {
    bson::uuid::Uuid::new().to_string()
}

impl Debug for RecordReference {
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), std::fmt::Error> {
        f.debug_struct("RecordReference")
            .field("id", &self.id)
            .field("name", &self.name)
            .field("meta", &self.meta)
            .finish()
    }
}