// @generated by jacquard-lexicon. DO NOT EDIT.
//
// Lexicon: social.pace.feed.activity
//
// This file was automatically generated from Lexicon schemas.
// Any manual changes will be overwritten on the next regeneration.

#[allow(unused_imports)]
use alloc::collections::BTreeMap;

#[allow(unused_imports)]
use core::marker::PhantomData;
use jacquard_common::CowStr;

#[allow(unused_imports)]
use jacquard_common::deps::codegen::unicode_segmentation::UnicodeSegmentation;
use jacquard_common::types::blob::BlobRef;
use jacquard_common::types::collection::{Collection, RecordError};
use jacquard_common::types::string::{AtUri, Cid, Datetime};
use jacquard_common::types::uri::{RecordUri, UriError};
use jacquard_common::xrpc::XrpcResp;
use jacquard_derive::{IntoStatic, lexicon};
use jacquard_lexicon::lexicon::LexiconDoc;
use jacquard_lexicon::schema::LexiconSchema;

#[allow(unused_imports)]
use jacquard_lexicon::validation::{ConstraintError, ValidationPath};
use serde::{Serialize, Deserialize};
use crate::social_pace::feed::ActivityType;
use crate::social_pace::feed::Split;
/// A recording of an activity. Like running, walking, lifting weights, etc. Helpful to create the rkey tid from the start time and clock id 23 so you can upsert easily.

#[lexicon]
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(rename_all = "camelCase")]
pub struct Activity<'a> {
    ///The number of active calories burned during the activity.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub calories: Option<i64>,
    ///When the activity was created
    pub created_at: Datetime,
    ///The distance covered during the activity, if any. This is a string to allow for float values. pace.social support is in feet and meters.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub distance: Option<CowStr<'a>>,
    ///The units used for distance measurement.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub distance_units: Option<CowStr<'a>>,
    ///When the activity ended.
    pub ended_at: Datetime,
    ///An export of the route taken during the activity, if any. A GPX or TCX file. Reminder, all atproto blobs are public. And is recommended if you do this to trim start and end.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub route: Option<BlobRef<'a>>,
    ///Array of splits if any.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub splits: Option<Vec<Split<'a>>>,
    ///When the activity was started.
    pub started_at: Datetime,
    ///The number of steps taken during the activity.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub steps: Option<i64>,
    #[serde(borrow)]
    pub r#type: ActivityType<'a>,
}

/// Typed wrapper for GetRecord response with this collection's record type.

#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
#[serde(rename_all = "camelCase")]
pub struct ActivityGetRecordOutput<'a> {
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(borrow)]
    pub cid: Option<Cid<'a>>,
    #[serde(borrow)]
    pub uri: AtUri<'a>,
    #[serde(borrow)]
    pub value: Activity<'a>,
}

impl<'a> Activity<'a> {
    pub fn uri(
        uri: impl Into<CowStr<'a>>,
    ) -> Result<RecordUri<'a, ActivityRecord>, UriError> {
        RecordUri::try_from_uri(AtUri::new_cow(uri.into())?)
    }
}

/// Marker type for deserializing records from this collection.

#[derive(Debug, Serialize, Deserialize)]
pub struct ActivityRecord;
impl XrpcResp for ActivityRecord {
    const NSID: &'static str = "social.pace.feed.activity";
    const ENCODING: &'static str = "application/json";
    type Output<'de> = ActivityGetRecordOutput<'de>;
    type Err<'de> = RecordError<'de>;
}

impl From<ActivityGetRecordOutput<'_>> for Activity<'_> {
    fn from(output: ActivityGetRecordOutput<'_>) -> Self {
        use jacquard_common::IntoStatic;
        output.value.into_static()
    }
}

impl Collection for Activity<'_> {
    const NSID: &'static str = "social.pace.feed.activity";
    type Record = ActivityRecord;
}

impl Collection for ActivityRecord {
    const NSID: &'static str = "social.pace.feed.activity";
    type Record = ActivityRecord;
}

impl<'a> LexiconSchema for Activity<'a> {
    fn nsid() -> &'static str {
        "social.pace.feed.activity"
    }
    fn def_name() -> &'static str {
        "main"
    }
    fn lexicon_doc() -> LexiconDoc<'static> {
        lexicon_doc_social_pace_feed_activity()
    }
    fn validate(&self) -> Result<(), ConstraintError> {
        if let Some(ref value) = self.distance_units {
            #[allow(unused_comparisons)]
            if <str>::len(value.as_ref()) > 10usize {
                return Err(ConstraintError::MaxLength {
                    path: ValidationPath::from_field("distance_units"),
                    max: 10usize,
                    actual: <str>::len(value.as_ref()),
                });
            }
        }
        if let Some(ref value) = self.route {
            {
                let mime = value.blob().mime_type.as_str();
                let accepted: &[&str] = &[
                    "application/vnd.garmin.tcx+xml",
                    "application/gpx+xml.",
                ];
                let matched = accepted
                    .iter()
                    .any(|pattern| {
                        if *pattern == "*/*" {
                            true
                        } else if pattern.ends_with("/*") {
                            let prefix = &pattern[..pattern.len() - 2];
                            mime.starts_with(prefix)
                                && mime.as_bytes().get(prefix.len()) == Some(&b'/')
                        } else {
                            mime == *pattern
                        }
                    });
                if !matched {
                    return Err(ConstraintError::BlobMimeTypeNotAccepted {
                        path: ValidationPath::from_field("route"),
                        accepted: vec![
                            "application/vnd.garmin.tcx+xml".to_string(),
                            "application/gpx+xml.".to_string()
                        ],
                        actual: mime.to_string(),
                    });
                }
            }
        }
        Ok(())
    }
}

pub mod activity_state {

    pub use crate::builder_types::{Set, Unset, IsSet, IsUnset};
    #[allow(unused)]
    use ::core::marker::PhantomData;
    mod sealed {
        pub trait Sealed {}
    }
    /// State trait tracking which required fields have been set
    pub trait State: sealed::Sealed {
        type StartedAt;
        type Type;
        type EndedAt;
        type CreatedAt;
    }
    /// Empty state - all required fields are unset
    pub struct Empty(());
    impl sealed::Sealed for Empty {}
    impl State for Empty {
        type StartedAt = Unset;
        type Type = Unset;
        type EndedAt = Unset;
        type CreatedAt = Unset;
    }
    ///State transition - sets the `started_at` field to Set
    pub struct SetStartedAt<S: State = Empty>(PhantomData<fn() -> S>);
    impl<S: State> sealed::Sealed for SetStartedAt<S> {}
    impl<S: State> State for SetStartedAt<S> {
        type StartedAt = Set<members::started_at>;
        type Type = S::Type;
        type EndedAt = S::EndedAt;
        type CreatedAt = S::CreatedAt;
    }
    ///State transition - sets the `type` field to Set
    pub struct SetType<S: State = Empty>(PhantomData<fn() -> S>);
    impl<S: State> sealed::Sealed for SetType<S> {}
    impl<S: State> State for SetType<S> {
        type StartedAt = S::StartedAt;
        type Type = Set<members::r#type>;
        type EndedAt = S::EndedAt;
        type CreatedAt = S::CreatedAt;
    }
    ///State transition - sets the `ended_at` field to Set
    pub struct SetEndedAt<S: State = Empty>(PhantomData<fn() -> S>);
    impl<S: State> sealed::Sealed for SetEndedAt<S> {}
    impl<S: State> State for SetEndedAt<S> {
        type StartedAt = S::StartedAt;
        type Type = S::Type;
        type EndedAt = Set<members::ended_at>;
        type CreatedAt = S::CreatedAt;
    }
    ///State transition - sets the `created_at` field to Set
    pub struct SetCreatedAt<S: State = Empty>(PhantomData<fn() -> S>);
    impl<S: State> sealed::Sealed for SetCreatedAt<S> {}
    impl<S: State> State for SetCreatedAt<S> {
        type StartedAt = S::StartedAt;
        type Type = S::Type;
        type EndedAt = S::EndedAt;
        type CreatedAt = Set<members::created_at>;
    }
    /// Marker types for field names
    #[allow(non_camel_case_types)]
    pub mod members {
        ///Marker type for the `started_at` field
        pub struct started_at(());
        ///Marker type for the `type` field
        pub struct r#type(());
        ///Marker type for the `ended_at` field
        pub struct ended_at(());
        ///Marker type for the `created_at` field
        pub struct created_at(());
    }
}

/// Builder for constructing an instance of this type
pub struct ActivityBuilder<'a, S: activity_state::State> {
    _state: PhantomData<fn() -> S>,
    _fields: (
        Option<i64>,
        Option<Datetime>,
        Option<CowStr<'a>>,
        Option<CowStr<'a>>,
        Option<Datetime>,
        Option<BlobRef<'a>>,
        Option<Vec<Split<'a>>>,
        Option<Datetime>,
        Option<i64>,
        Option<ActivityType<'a>>,
    ),
    _lifetime: PhantomData<&'a ()>,
}

impl<'a> Activity<'a> {
    /// Create a new builder for this type
    pub fn new() -> ActivityBuilder<'a, activity_state::Empty> {
        ActivityBuilder::new()
    }
}

impl<'a> ActivityBuilder<'a, activity_state::Empty> {
    /// Create a new builder with all fields unset
    pub fn new() -> Self {
        ActivityBuilder {
            _state: PhantomData,
            _fields: (None, None, None, None, None, None, None, None, None, None),
            _lifetime: PhantomData,
        }
    }
}

impl<'a, S: activity_state::State> ActivityBuilder<'a, S> {
    /// Set the `calories` field (optional)
    pub fn calories(mut self, value: impl Into<Option<i64>>) -> Self {
        self._fields.0 = value.into();
        self
    }
    /// Set the `calories` field to an Option value (optional)
    pub fn maybe_calories(mut self, value: Option<i64>) -> Self {
        self._fields.0 = value;
        self
    }
}

impl<'a, S> ActivityBuilder<'a, S>
where
    S: activity_state::State,
    S::CreatedAt: activity_state::IsUnset,
{
    /// Set the `createdAt` field (required)
    pub fn created_at(
        mut self,
        value: impl Into<Datetime>,
    ) -> ActivityBuilder<'a, activity_state::SetCreatedAt<S>> {
        self._fields.1 = Option::Some(value.into());
        ActivityBuilder {
            _state: PhantomData,
            _fields: self._fields,
            _lifetime: PhantomData,
        }
    }
}

impl<'a, S: activity_state::State> ActivityBuilder<'a, S> {
    /// Set the `distance` field (optional)
    pub fn distance(mut self, value: impl Into<Option<CowStr<'a>>>) -> Self {
        self._fields.2 = value.into();
        self
    }
    /// Set the `distance` field to an Option value (optional)
    pub fn maybe_distance(mut self, value: Option<CowStr<'a>>) -> Self {
        self._fields.2 = value;
        self
    }
}

impl<'a, S: activity_state::State> ActivityBuilder<'a, S> {
    /// Set the `distanceUnits` field (optional)
    pub fn distance_units(mut self, value: impl Into<Option<CowStr<'a>>>) -> Self {
        self._fields.3 = value.into();
        self
    }
    /// Set the `distanceUnits` field to an Option value (optional)
    pub fn maybe_distance_units(mut self, value: Option<CowStr<'a>>) -> Self {
        self._fields.3 = value;
        self
    }
}

impl<'a, S> ActivityBuilder<'a, S>
where
    S: activity_state::State,
    S::EndedAt: activity_state::IsUnset,
{
    /// Set the `endedAt` field (required)
    pub fn ended_at(
        mut self,
        value: impl Into<Datetime>,
    ) -> ActivityBuilder<'a, activity_state::SetEndedAt<S>> {
        self._fields.4 = Option::Some(value.into());
        ActivityBuilder {
            _state: PhantomData,
            _fields: self._fields,
            _lifetime: PhantomData,
        }
    }
}

impl<'a, S: activity_state::State> ActivityBuilder<'a, S> {
    /// Set the `route` field (optional)
    pub fn route(mut self, value: impl Into<Option<BlobRef<'a>>>) -> Self {
        self._fields.5 = value.into();
        self
    }
    /// Set the `route` field to an Option value (optional)
    pub fn maybe_route(mut self, value: Option<BlobRef<'a>>) -> Self {
        self._fields.5 = value;
        self
    }
}

impl<'a, S: activity_state::State> ActivityBuilder<'a, S> {
    /// Set the `splits` field (optional)
    pub fn splits(mut self, value: impl Into<Option<Vec<Split<'a>>>>) -> Self {
        self._fields.6 = value.into();
        self
    }
    /// Set the `splits` field to an Option value (optional)
    pub fn maybe_splits(mut self, value: Option<Vec<Split<'a>>>) -> Self {
        self._fields.6 = value;
        self
    }
}

impl<'a, S> ActivityBuilder<'a, S>
where
    S: activity_state::State,
    S::StartedAt: activity_state::IsUnset,
{
    /// Set the `startedAt` field (required)
    pub fn started_at(
        mut self,
        value: impl Into<Datetime>,
    ) -> ActivityBuilder<'a, activity_state::SetStartedAt<S>> {
        self._fields.7 = Option::Some(value.into());
        ActivityBuilder {
            _state: PhantomData,
            _fields: self._fields,
            _lifetime: PhantomData,
        }
    }
}

impl<'a, S: activity_state::State> ActivityBuilder<'a, S> {
    /// Set the `steps` field (optional)
    pub fn steps(mut self, value: impl Into<Option<i64>>) -> Self {
        self._fields.8 = value.into();
        self
    }
    /// Set the `steps` field to an Option value (optional)
    pub fn maybe_steps(mut self, value: Option<i64>) -> Self {
        self._fields.8 = value;
        self
    }
}

impl<'a, S> ActivityBuilder<'a, S>
where
    S: activity_state::State,
    S::Type: activity_state::IsUnset,
{
    /// Set the `type` field (required)
    pub fn r#type(
        mut self,
        value: impl Into<ActivityType<'a>>,
    ) -> ActivityBuilder<'a, activity_state::SetType<S>> {
        self._fields.9 = Option::Some(value.into());
        ActivityBuilder {
            _state: PhantomData,
            _fields: self._fields,
            _lifetime: PhantomData,
        }
    }
}

impl<'a, S> ActivityBuilder<'a, S>
where
    S: activity_state::State,
    S::StartedAt: activity_state::IsSet,
    S::Type: activity_state::IsSet,
    S::EndedAt: activity_state::IsSet,
    S::CreatedAt: activity_state::IsSet,
{
    /// Build the final struct
    pub fn build(self) -> Activity<'a> {
        Activity {
            calories: self._fields.0,
            created_at: self._fields.1.unwrap(),
            distance: self._fields.2,
            distance_units: self._fields.3,
            ended_at: self._fields.4.unwrap(),
            route: self._fields.5,
            splits: self._fields.6,
            started_at: self._fields.7.unwrap(),
            steps: self._fields.8,
            r#type: self._fields.9.unwrap(),
            extra_data: Default::default(),
        }
    }
    /// Build the final struct with custom extra_data
    pub fn build_with_data(
        self,
        extra_data: BTreeMap<
            jacquard_common::deps::smol_str::SmolStr,
            jacquard_common::types::value::Data<'a>,
        >,
    ) -> Activity<'a> {
        Activity {
            calories: self._fields.0,
            created_at: self._fields.1.unwrap(),
            distance: self._fields.2,
            distance_units: self._fields.3,
            ended_at: self._fields.4.unwrap(),
            route: self._fields.5,
            splits: self._fields.6,
            started_at: self._fields.7.unwrap(),
            steps: self._fields.8,
            r#type: self._fields.9.unwrap(),
            extra_data: Some(extra_data),
        }
    }
}

fn lexicon_doc_social_pace_feed_activity() -> LexiconDoc<'static> {
    #[allow(unused_imports)]
    use jacquard_common::{CowStr, deps::smol_str::SmolStr, types::blob::MimeType};
    use jacquard_lexicon::lexicon::*;
    use alloc::collections::BTreeMap;
    LexiconDoc {
        lexicon: Lexicon::Lexicon1,
        id: CowStr::new_static("social.pace.feed.activity"),
        defs: {
            let mut map = BTreeMap::new();
            map.insert(
                SmolStr::new_static("main"),
                LexUserType::Record(LexRecord {
                    description: Some(
                        CowStr::new_static(
                            "A recording of an activity. Like running, walking, lifting weights, etc. Helpful to create the rkey tid from the start time and clock id 23 so you can upsert easily.",
                        ),
                    ),
                    key: Some(CowStr::new_static("tid")),
                    record: LexRecordRecord::Object(LexObject {
                        required: Some(
                            vec![
                                SmolStr::new_static("startedAt"),
                                SmolStr::new_static("endedAt"), SmolStr::new_static("type"),
                                SmolStr::new_static("createdAt")
                            ],
                        ),
                        properties: {
                            #[allow(unused_mut)]
                            let mut map = BTreeMap::new();
                            map.insert(
                                SmolStr::new_static("calories"),
                                LexObjectProperty::Integer(LexInteger {
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("createdAt"),
                                LexObjectProperty::String(LexString {
                                    description: Some(
                                        CowStr::new_static("When the activity was created"),
                                    ),
                                    format: Some(LexStringFormat::Datetime),
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("distance"),
                                LexObjectProperty::String(LexString {
                                    description: Some(
                                        CowStr::new_static(
                                            "The distance covered during the activity, if any. This is a string to allow for float values. pace.social support is in feet and meters.",
                                        ),
                                    ),
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("distanceUnits"),
                                LexObjectProperty::String(LexString {
                                    description: Some(
                                        CowStr::new_static(
                                            "The units used for distance measurement.",
                                        ),
                                    ),
                                    max_length: Some(10usize),
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("endedAt"),
                                LexObjectProperty::String(LexString {
                                    description: Some(
                                        CowStr::new_static("When the activity ended."),
                                    ),
                                    format: Some(LexStringFormat::Datetime),
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("route"),
                                LexObjectProperty::Blob(LexBlob { ..Default::default() }),
                            );
                            map.insert(
                                SmolStr::new_static("splits"),
                                LexObjectProperty::Array(LexArray {
                                    description: Some(
                                        CowStr::new_static("Array of splits if any."),
                                    ),
                                    items: LexArrayItem::Ref(LexRef {
                                        r#ref: CowStr::new_static("social.pace.feed.defs#split"),
                                        ..Default::default()
                                    }),
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("startedAt"),
                                LexObjectProperty::String(LexString {
                                    description: Some(
                                        CowStr::new_static("When the activity was started."),
                                    ),
                                    format: Some(LexStringFormat::Datetime),
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("steps"),
                                LexObjectProperty::Integer(LexInteger {
                                    ..Default::default()
                                }),
                            );
                            map.insert(
                                SmolStr::new_static("type"),
                                LexObjectProperty::Ref(LexRef {
                                    r#ref: CowStr::new_static(
                                        "social.pace.feed.defs#activityType",
                                    ),
                                    ..Default::default()
                                }),
                            );
                            map
                        },
                        ..Default::default()
                    }),
                    ..Default::default()
                }),
            );
            map
        },
        ..Default::default()
    }
}