atproto_teq / src / types.rs

//! Structs, enums, and impls.
use std::str::FromStr;
use base64::Engine;
use chrono::{DateTime as Datetime, Datelike};
use jetstream_oxide::exports::Did;
use serde::{ser::{Serialize, Serializer}, Deserialize};

// /// How should a client visually convey this label?
// enum LabelDefinitionSeverity {
//     /// 'inform' means neutral and informational
//     Inform,
//     /// 'alert' means negative and warning
//     Alert,
//     /// 'none' means show nothing.
//     None,
// }
// impl LabelDefinitionSeverity {
//     fn to_string(&self) -> String {
//         match self {
//             Self::Inform => "inform".to_owned(),
//             Self::Alert => "alert".to_owned(),
//             Self::None => "none".to_owned(),
//         }
//     }
// }
// /// What should this label hide in the UI, if applied?
// enum LabelDefinitionBlurs {
//     /// 'content' hides all of the target
//     Content,
//     /// 'media' hides the images/video/audio
//     Media,
//     /// 'none' hides nothing.
//     None,
// }
// impl LabelDefinitionBlurs {
//     fn to_string(&self) -> String {
//         match self {
//             Self::Content => "content".to_owned(),
//             Self::Media => "media".to_owned(),
//             Self::None => "none".to_owned(),
//         }
//     }
// }
// /// The default setting for this label.
// enum LabelDefinitionDefaultSetting {
//     Hide,
//     Warn,
//     Ignore,
// }
// impl LabelDefinitionDefaultSetting {
//     fn to_string(&self) -> String {
//         match self {
//             Self::Hide => "hide".to_owned(),
//             Self::Warn => "warn".to_owned(),
//             Self::Ignore => "ignore".to_owned(),
//         }
//     }
// }
// /// Strings which describe the label in the UI, localized into a specific language.
// struct LabelValueDefinitionStrings {
//     /// The code of the language these strings are written in.
//     lang: String,
//     /// A short human-readable name for the label.
//     name: String,
//     /// A longer description of what the label means and why it might be applied.
//     description: String,
// }
// /// Labels.
// struct LabelDefinition {
//     /// The value of the label being defined. Must only include lowercase ascii and the '-' character (a-z-+).
//     identifier: String,
//     /// How should a client visually convey this label? 'inform' means neutral and informational; 'alert' means negative and warning; 'none' means show nothing.
//     severity: LabelDefinitionSeverity,
//     /// What should this label hide in the UI, if applied? 'content' hides all of the target; 'media' hides the images/video/audio; 'none' hides nothing.
//     blurs: LabelDefinitionBlurs,
//     /// The default setting for this label.
//     default_setting: LabelDefinitionDefaultSetting,
//     /// Does the user need to have adult content enabled in order to configure this label?
//     adult_content: Option<bool>,
//     /// Strings which describe the label in the UI, localized into a specific language.
//     locales: Vec<LabelValueDefinitionStrings>,
// }
// impl LabelDefinition {
//     fn new(identifier: String) -> Self {
//         let locales = vec![LabelValueDefinitionStrings {
//             lang: "en".to_owned(),
//             name: identifier.replace("joined-", "Joined "),
//             description: format!("Profile created {}", identifier.replace("joined-", "").replace("-", " ")),
//         }];
//         Self {
//             identifier,
//             severity: LabelDefinitionSeverity::Inform,
//             blurs: LabelDefinitionBlurs::None,
//             default_setting: LabelDefinitionDefaultSetting::Warn,
//             adult_content: Some(false),
//             locales,
//         }
//     }
// }


#[derive(Debug)]
/// Signature bytes.
pub struct SignatureBytes([u8; 64]);
impl FromStr for SignatureBytes {
    type Err = std::io::Error;
    fn from_str(s: &str) -> Result<Self, Self::Err> {
        let bytes = base64::engine::GeneralPurpose::new(
            &base64::alphabet::STANDARD,
            base64::engine::general_purpose::NO_PAD).decode(s).expect("Expected to be able to decode the base64 string as bytes but failed.");
        let mut array = [0; 64];
        array.copy_from_slice(&bytes);
        Ok(Self(array))
    }
}
impl SignatureBytes {
    /// Create a new signature from a vector of bytes.
    pub fn from_vec(vec: Vec<u8>) -> Self {
        let mut array = [0; 64];
        array.copy_from_slice(&vec);
        Self(array)
    }
    /// Create a new signature from a slice of bytes.
    pub const fn from_bytes(bytes: [u8; 64]) -> Self {
        Self(bytes)
    }
    /// Create a new signature from a JSON value in the format of a $bytes object.
    pub fn from_json(json: serde_json::Value) -> Self {
        let byte_string = json["$bytes"].as_str().expect("Expected to be able to get the $bytes field from the JSON object as a string but failed.");
        let bytes = base64::engine::GeneralPurpose::new(
            &base64::alphabet::STANDARD,
            base64::engine::general_purpose::NO_PAD).decode(byte_string).expect("Expected to be able to decode the base64 string as bytes but failed.");
        Self::from_vec(bytes)
    }
    /// Get the signature as a vector of bytes.
    pub fn as_vec(&self) -> Vec<u8> {
        self.0.to_vec()
    }
    /// Get the signature as a base64 string.
    pub fn as_base64(&self) -> String {
        base64::engine::GeneralPurpose::new(
            &base64::alphabet::STANDARD,
            base64::engine::general_purpose::NO_PAD).encode(self.0)
    }
    /// Get the signature as a JSON object in the format of a $bytes object.
    pub fn as_json_object(&self) -> serde_json::Value {
        serde_json::json!({
            "$bytes": self.as_base64()
        })
    }
}
impl Serialize for SignatureBytes {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        serializer.serialize_bytes(&self.0)
    }
}
#[derive(Debug)]
/// Signature bytes or JSON value.
pub enum SignatureEnum {
    /// Signature bytes.
    Bytes(SignatureBytes),
    /// Signature JSON value.
    Json(serde_json::Value),
}
impl Serialize for SignatureEnum {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        match self {
            Self::Bytes(bytes) => bytes.serialize(serializer),
            Self::Json(json) => json.serialize(serializer),
        }
    }
}

#[derive(serde::Serialize, Debug)]
/// Label response content.
pub struct AssignedLabelResponse {
    // /// Timestamp at which this label expires (no longer applies, is no longer valid).
    // exp: Option<DateTime<FixedOffset>>,
    // /// Optionally, CID specifying the specific version of 'uri' resource this label applies to. \
    // /// If provided, the label applies to a specific version of the subject uri
    // cid: Option<String>,
    /// Timestamp when this label was created.
    /// Note that timestamps in a distributed system are not trustworthy or verified by default.
    pub cts: String, // DateTime<Utc>,
    /// If true, this is a negation label, indicates that this label "negates" an earlier label with the same src, uri, and val.
    /// If the neg field is false, best practice is to simply not include the field at all.
    #[serde(skip_serializing_if = "bool_is_false")]
    pub neg: bool,
    /// Signature of dag-cbor encoded label. \
    /// cryptographic signature bytes. \
    /// Uses the bytes type from the [Data Model](https://atproto.com/specs/data-model), which encodes in JSON as a $bytes object with base64 encoding
    /// When labels are being transferred as full objects between services, the ver and sig fields are required.
    pub sig: Option<SignatureEnum>,
    /// DID of the actor authority (account) which generated this label.  \
    pub src: Did,
    /// AT URI of the record, repository (account), or other resource that this label applies to. \
    /// For a specific record, an `at://` URI. For an account, the `did:`.
    pub uri: String,
    /// The short (<=128 character) string name of the value or type of this label.
    pub val: String,
    /// The AT Protocol version of the label object schema version. \
    /// Current version is always 1.
    /// When labels are being transferred as full objects between services, the ver and sig fields are required.
    pub ver: u64,
}
impl AssignedLabelResponse {
    /// Create a new label.
    pub fn generate(
        src: Did,
        uri: String,
        val: String,
    ) -> Self {
        let sig = SignatureEnum::Bytes(SignatureBytes([0; 64]));
        Self::reconstruct(src, uri, val, false, chrono::Utc::now().to_rfc3339_opts(chrono::SecondsFormat::Millis, true), sig)
    }
    /// Reconstruct a label from parts.
    pub const fn reconstruct(
        src: Did,
        uri: String,
        val: String,
        neg: bool,
        cts: String,
        sig: SignatureEnum,
    ) -> Self {
        Self {
            ver: 1,
            src,
            uri,
            // cid: None,
            val,
            neg,
            sig: Some(sig),
            cts,
            // exp: None,
        }
    }
    // The process to sign or verify a signature is to construct a complete version of the label, using only the specified schema fields, and not including the sig field. 
    // This means including the ver field, but not any $type field or other un-specified fields which may have been included in a Lexicon representation of the label. This data object is then encoded in CBOR, following the deterministic IPLD/DAG-CBOR normalization rules. 
    // The CBOR bytes are hashed with SHA-256, and then the direct hash bytes (not a hex-encoded string) are signed (or verified) using the appropriate cryptographic key. The signature bytes are stored in the sig field as bytes (see Data Model for details representing bytes).
    /// Generate signature.
    pub fn sign(mut self) -> Self {
        crate::crypto::Crypto::new().sign(&mut self);
        self
    }

}
#[derive(serde::Serialize)]
/// A label response wrapper.
pub struct AssignedLabelResponseWrapper {
    /// The cursor to find the sequence number of this label. \
    /// Returned as a string.
    pub cursor: String,
    /// Vector of labels.
    pub labels: Vec<AssignedLabelResponse>,
}
#[derive(serde::Serialize, Debug)]
/// A label response wrapper.
pub struct SubscribeLabelsLabels {
    /// The sequence number of this label. \
    /// The seq field is a monotonically increasing integer, starting at 1 for the first label.
    /// Returned as a long.
    pub seq: i64,
    /// Vector of labels.
    pub labels: Vec<AssignedLabelResponse>,
}
#[derive(Deserialize)]
#[expect(non_snake_case, reason = "Name matches URI parameter literally.")]
/// URI parameters.
pub struct UriParams {
    /// URI patterns.
    pub uriPatterns: Option<String>,
    /// The DID of sources.
    pub sources: Option<String>,
    /// The limit of labels to fetch. Default is (50?).
    pub limit: Option<i64>,
    /// The cursor to use for seq.
    pub cursor: Option<String>,
    /// The actor to lookup.
    pub actor: Option<String>,
}
const fn neg_default() -> bool {
    false
}

#[derive(serde::Serialize, serde::Deserialize, Debug)]
/// A label retrieved from the atproto API.
pub struct RetrievedLabelResponse {
    /// The creation timestamp.
    pub cts: String,
    /// Whether the label is negative.
    #[serde(skip_serializing_if = "bool_is_false", default = "neg_default")]
    pub neg: bool,
    /// The source DID.
    pub src: Did,
    /// The URI.
    pub uri: String,
    /// The value.
    pub val: String,
    /// The version.
    pub ver: u64,
}
#[derive(serde::Serialize, serde::Deserialize, Debug)]
/// A label retrieved from the atproto API.
pub struct SignedRetrievedLabelResponse {
    /// The creation timestamp.
    pub cts: String,
    /// Whether the label is negative.
    #[serde(skip_serializing_if = "bool_is_false")]
    pub neg: bool,
    /// The source DID.
    pub sig: serde_json::Value,
    /// The source DID.
    pub src: Did,
    /// The URI.
    pub uri: String,
    /// The value.
    pub val: String,
    /// The version.
    pub ver: u64,
}
fn bool_is_false(b: &bool) -> bool {
    !b
}
#[derive(serde::Serialize, serde::Deserialize, Debug)]
/// A label retrieved from the atproto API.
pub struct SignedRetrievedLabelResponseWs {
    /// The creation timestamp.
    pub cts: String,
    /// Whether the label is negative.
    #[serde(skip_serializing_if = "bool_is_false")]
    pub neg: bool,
    /// The signature.
    #[serde(with = "serde_bytes")]
    pub sig: [u8; 64],
    /// The source DID.
    pub src: Did,
    /// The URI.
    pub uri: String,
    /// The value.
    pub val: String,
    /// The version.
    pub ver: u64,
}
#[derive(serde::Serialize, serde::Deserialize, Debug)]
/// Labels with a sequence number.
pub struct LabelsVecWithSeq {
    /// The sequence number.
    pub seq: u64,
    /// The labels.
    pub labels: Vec<SignedRetrievedLabelResponseWs>,
}
#[derive(Debug)]
/// Profile stats.
pub struct ProfileStats {
    /// The number of followers.
    pub follower_count: i32,
    /// The number of posts.
    pub post_count: i32,
    /// The creation timestamp, as reported by actor.
    pub created_at: Datetime<chrono::Utc>,
    /// The timestamp at which the stats were checked.
    pub checked_at: Datetime<chrono::Utc>,
}
impl ProfileStats {
    fn new(
        follower_count: i32,
        post_count: i32,
        created_at: Datetime<chrono::Utc>,
    ) -> Self {
        Self {
            follower_count,
            post_count,
            created_at,
            checked_at: chrono::Utc::now(),
        }
    }
    /// Given a AT uri, lookup the profile and return the stats.
    pub async fn from_at_url(
        uri: String,
        agent: &mut crate::webrequest::Agent,
    ) -> Result<Self, Box<dyn std::error::Error>> {
        let uri = uri.replace("at://","").replace("/app.bsky.actor.profile/self", "");
        if let Ok(profile) = agent.get_profile(uri.as_str()).await {
            tracing::debug!("{:?}", profile);

            // Begin enforce reasonable limits on the number of follows.
            // https://jazco.dev/2025/02/19/imperfection/
            let follows_count = profile["followsCount"].as_i64().expect("Expected to be able to parse an integer, but failed") as i32;
            const MAX_FOLLOWS: i32 = 4_000;
            if follows_count > MAX_FOLLOWS {
                tracing::warn!("Profile {:?} has a suspicious number of follows: {:?}", uri, follows_count);
                return Err(Box::new(std::io::Error::new(
                    std::io::ErrorKind::Other,
                    "Profile has a suspicious number of follows",
                )));
            }
            // End

            let followers_count = profile["followersCount"].as_i64().expect("Expected to be able to parse an integer, but failed") as i32;
            let posts_count = profile["postsCount"].as_i64().expect("Expected to be able to parse an integer, but failed") as i32;
            let created_at = Datetime::parse_from_rfc3339(profile["createdAt"].as_str().expect("Expected to be able to parse a string, but failed"))?;
            Ok(Self::new(followers_count, posts_count, created_at.into()))
        } else {
            Err(Box::new(std::io::Error::new(
                std::io::ErrorKind::Other,
                "Failed to get profile",
            )))
        }
    }
}
#[derive(Debug, Clone, Copy, serde::Deserialize)]
enum Year {
    _2022,
    _2023,
    _2024,
    _2025,
}
impl std::fmt::Display for Year {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        write!(
            f,
            "{}",
            match self {
                Self::_2022 => "a",
                Self::_2023 => "b",
                Self::_2024 => "c",
                Self::_2025 => "d",
            }
        )
    }
}
impl Serialize for Year {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        let val: char = self.to_string().chars().next().expect("Expected to be able to get the first character, but failed");
        serializer.serialize_char(val)        
    }
}
#[derive(Debug, Clone, Copy, serde::Deserialize)]
enum Month {
    January,
    February,
    March,
    April,
    May,
    June,
    July,
    August,
    September,
    October,
    November,
    December,
}
impl Serialize for Month {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        let val = self.to_string().to_lowercase();
        serializer.serialize_str(&val)
    }
}
impl std::fmt::Display for Month {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        write!(
            f,
            "{}",
            match self {
                Self::January => "jan",
                Self::February => "feb",
                Self::March => "mar",
                Self::April => "apr",
                Self::May => "may",
                Self::June => "jun",
                Self::July => "jul",
                Self::August => "aug",
                Self::September => "sep",
                Self::October => "oct",
                Self::November => "nov",
                Self::December => "dec",
            }
        )
    }
}
/// Profile labels for month+year.
#[derive(Debug, Clone, Copy, serde::Deserialize, serde::Serialize)]
pub struct ProfileLabel {
    year: Year,
    month: Month,
}
impl ProfileLabel {
    /// Create a new profile label from a datetime.
    #[allow(clippy::cognitive_complexity)]
    pub fn from_datetime(datetime: Datetime<chrono::Utc>) -> Option<Self> {
        Some(Self {
            year: match datetime.year() {
                2023 => Year::_2023,
                2024 => Year::_2024,
                2025 => Year::_2025,
                _ => {
                    tracing::debug!("Invalid year");
                    return None;
                }
            },
            month: match datetime.month() {
                1 => Month::January,
                2 => Month::February,
                3 => Month::March,
                4 => Month::April,
                5 => Month::May,
                6 => Month::June,
                7 => Month::July,
                8 => Month::August,
                9 => Month::September,
                10 => Month::October,
                11 => Month::November,
                12 => Month::December,
                _ => {
                    tracing::debug!("Invalid month");
                    return None;
                }
            },
        })
    }
    /// Convert a profile label to a string.
    pub fn to_label_val(self) -> String {
        format!("joined-{}-{}", self.month, self.year)
            .to_lowercase()
    }
}
/// Profile with optional stats and label.
#[derive(Debug)]
pub struct Profile {
    did: String,
    /// Stats for a profile.
    pub stats: Option<ProfileStats>,
    label: Option<String>,
}
impl Profile {
    /// Create a new profile, given a DID.
    pub fn new(did: &str) -> Self {
        Self {
            did: {
                // if did.starts_with("did:") {
                //     format!("at://{}{}", did, "/app.bsky.actor.profile/self")
                // } else {
                    did.to_owned()
                // }
            },
            stats: None,
            label: None,
        }
    }
    /// Fetch stats for a profile.
    pub async fn determine_stats(&mut self, agent: &mut crate::webrequest::Agent, pool: &sqlx::sqlite::SqlitePool) -> &mut Self {
        if let Ok(stats) = ProfileStats::from_at_url(self.did.clone(), agent).await {
            self.stats = Some(stats);
        } else {
            tracing::warn!("Failed to get stats for profile {}", self.did);
        }
        self.insert_profile_stats(pool).await.expect("Expected to be able to insert profile stats, but failed");
        self
    }
    /// Determine if stats exist for a profile.
    pub async fn determine_stats_exist(&mut self, pool: &sqlx::Pool<sqlx::Sqlite>) -> Result<Option<&mut Self>, Box<dyn std::error::Error + Sync + Send>> {
        if self.stats.is_some() {
            return Ok(Some(self));
        }
        let profile_stats = sqlx::query!(
            r#"
            SELECT created_at "created_at: String", follower_count, post_count, checked_at "checked_at: String" FROM profile_stats WHERE did = ?
            "#,
            self.did
        )
        .fetch_one(pool)
        .await;
        if profile_stats.is_ok() {
            let profile_stats = profile_stats.expect("Expected to be able to unwrap a profile_checked_at, but failed");
            let created_at = Datetime::parse_from_rfc3339(profile_stats.created_at.as_str()).expect("Expected to be able to parse a string as a datetime, but failed").to_utc();
            let follower_count = profile_stats.follower_count as i32;
            let post_count = profile_stats.post_count as i32;
            let checked_at = Datetime::parse_from_rfc3339(profile_stats.checked_at.as_str()).expect("Expected to be able to parse a string as a datetime, but failed").to_utc();
            const TIMEPERIOD: i64 = 60 * 60 * 24 * 7 * 1000 * 4; // 4 weeks in milliseconds
            if chrono::Utc::now().timestamp_millis() - checked_at.timestamp_millis() < TIMEPERIOD {
                tracing::debug!("Stats exist for: {:?}", self.did);
                self.stats = Some(ProfileStats {
                    follower_count,
                    post_count,
                    created_at,
                    checked_at,
                });
                return Ok(Some(self));
            }
            tracing::info!("Refetching stats for: {:?}", self.did);
            return Ok(None);
        }
        tracing::info!("Stats do not exist for: {:?}", self.did);
        Ok(None)
    }
    /// Determine the label of a profile.
    pub async fn determine_label(&mut self, pool: &sqlx::sqlite::SqlitePool) -> &mut Self {
        if self.stats.is_none() {
            return self;
        }
        const MIN_POSTS: i32 = 30;
        const SOME_POSTS: i32 = 200;
        const MIN_FOLLOWERS: i32 = 400;
        const SOME_FOLLOWERS: i32 = 2_500;
        let post_count = self.stats.as_ref().expect("Expected stats to exist, but failed").post_count;
        let follower_count = self.stats.as_ref().expect("Expected stats to exist, but failed").follower_count;
        if (post_count >= MIN_POSTS && follower_count >= MIN_FOLLOWERS) && (post_count >= SOME_POSTS || follower_count >= SOME_FOLLOWERS)
        {
            match ProfileLabel::from_datetime(self.stats.as_ref().expect("Expected stats to exist, but failed").created_at) {
                Some(label) => self.label = Some(label.to_label_val()),
                None => {
                    tracing::debug!("Invalid datetime");
                }
            }
        }
        self.insert_profile_labels(pool).await.expect("Expected to be able to insert profile labels, but failed");
        self
    }
    /// Determine the label of a profile, and insert it without checking stats reqs.
    pub async fn determine_label_agnostic(&mut self, pool: &sqlx::sqlite::SqlitePool) -> &mut Self {
        if self.stats.is_none() {
            return self;
        }
        match ProfileLabel::from_datetime(self.stats.as_ref().expect("Expected stats to exist, but failed").created_at) {
            Some(label) => self.label = Some(label.to_label_val()),
            None => {
                tracing::debug!("Invalid datetime");
            }
        }
        self.insert_profile_labels(pool).await.expect("Expected to be able to insert profile labels, but failed");
        self
    }
    /// Insert a profile into the database.
    pub async fn insert_profile(self, pool: &sqlx::sqlite::SqlitePool) -> Result<Self, sqlx::Error> {
        if (sqlx::query(&format!(
            "INSERT INTO profile (did) VALUES ('{}')",
            self.did
        ))
        .execute(pool)
        .await).is_ok() {
            tracing::debug!("Inserted profile {:?}", self.did);
        } else {
            tracing::debug!("Duplicate profile: {:?}", self.did);
        }
        Ok(self)
    }
    /// Insert profile stats into the database.
    pub async fn insert_profile_stats(
        &self,
        pool: &sqlx::sqlite::SqlitePool,
    ) -> Result<(), sqlx::Error> {
        if self.stats.is_none() {
            return Ok(());
        }
        // if sqlx::query!(
        //     r#"SELECT did "did: String" FROM profile_stats WHERE did = ? LIMIT 1"#,
        //     self.did
        // )
        // .fetch_one(pool)
        // .await.is_ok() {
        //     tracing::debug!("Stats already exist for {:?}", self.did);
        //     return Ok(());
        // }
        let created_at = self.stats.as_ref().expect("Expected stats to exist, but failed").created_at.to_rfc3339_opts(chrono::SecondsFormat::Millis, true);
        let follower_count = self.stats.as_ref().expect("Expected stats to exist, but failed").follower_count;
        let post_count = self.stats.as_ref().expect("Expected stats to exist, but failed").post_count;
        let checked_at = self.stats.as_ref().expect("Expected stats to exist, but failed").checked_at.to_rfc3339_opts(chrono::SecondsFormat::Millis, true);
        _ = sqlx::query!(r#"
            INSERT INTO profile_stats (did, created_at, follower_count, post_count, checked_at)
            VALUES (?, ?, ?, ?, ?)
            ON CONFLICT(did) DO UPDATE SET
            created_at = ?,
            follower_count = ?,
            post_count = ?,
            checked_at = ?
            "#,
            self.did,
            created_at,
            follower_count,
            post_count,
            checked_at,
            created_at,
            follower_count,
            post_count,
            checked_at,
        )
                .execute(pool).await.expect("Expected to be able to insert profile stats, but failed");
            tracing::info!("Inserted profile stats for {:?} with {:?} followers", self.did, self.stats.as_ref().expect("Expected stats to exist, but failed").follower_count);
        Ok(())
    }
    /// Negate a profile label.
    pub async fn negate_label(
        &mut self,
        pool: &sqlx::sqlite::SqlitePool,
    ) -> Result<(), sqlx::Error> {
        if self.stats.is_none() {
            tracing::warn!("No stats for {:?}", self.did);
            return Ok(());
        }
        match ProfileLabel::from_datetime(self.stats.as_ref().expect("Expected stats to exist, but failed").created_at) {
            Some(label) => self.label = Some(label.to_label_val()),
            None => {
                tracing::debug!("Invalid datetime");
            }
        }
        let label = self.label.as_ref().expect("Expected label to exist, but failed");
        let uri = self.did.as_str();
        let val: &str = label.as_str();
        drop(dotenvy::dotenv().expect("Failed to load .env file"));
        let self_did = dotenvy::var("SELF_DID").expect("Expected to be able to get the SELF_DID from the environment, but failed");
        let src = Did::new(self_did).expect("Expected to be able to create a valid DID but failed");
        let mut label_response: AssignedLabelResponse = AssignedLabelResponse::generate(src, self.did.clone(), val.to_owned());
        label_response.neg = true;
        label_response = label_response.sign();
        let sig_enum = label_response.sig.expect("Expected a signature, but failed");
        if let SignatureEnum::Bytes(sig) = sig_enum {
            let sig = sig.as_vec();
            _ = sqlx::query!(
                r#"INSERT INTO profile_labels (uri, val, neg, cts, sig) VALUES (?, ?, ?, ?, ?)"#,
                uri,
                val,
                label_response.neg,
                label_response.cts,
                sig,
            )
            .execute(pool)
            .await?;
        }
        tracing::info!("Negated profile label for {:?} with {:?}", self.did, self.label.as_ref().expect("Expected label to exist, but failed"));
        Ok(())
    }
    /// Insert profile labels into the database.
    async fn insert_profile_labels(
        &self,
        pool: &sqlx::sqlite::SqlitePool,
    ) -> Result<(), sqlx::Error> {
        if self.label.is_none() {
            return Ok(());
        }
        if sqlx::query!(
            r#"SELECT seq FROM profile_labels WHERE uri = ? LIMIT 1"#,
            self.did
        )
        .fetch_one(pool)
        .await.is_ok() {
            tracing::debug!("Label already exists for {:?}", self.did);
            return Ok(());
        }
        let label = self.label.as_ref().expect("Expected label to exist, but failed");
        let uri = self.did.as_str();
        let val: &str = label.as_str();
        drop(dotenvy::dotenv().expect("Failed to load .env file"));
        let self_did = dotenvy::var("SELF_DID").expect("Expected to be able to get the SELF_DID from the environment, but failed");
        let src = Did::new(self_did).expect("Expected to be able to create a valid DID but failed");
        let mut label_response: AssignedLabelResponse = AssignedLabelResponse::generate(src, self.did.clone(), val.to_owned());
        label_response = label_response.sign();
        let sig_enum = label_response.sig.expect("Expected a signature, but failed");
        if let SignatureEnum::Bytes(sig) = sig_enum {
            let sig = sig.as_vec();
            let result = sqlx::query!(
                r#"INSERT INTO profile_labels (uri, val, cts, sig) VALUES (?, ?, ?, ?)"#,
                uri,
                val,
                label_response.cts,
                sig,
            )
            .execute(pool)
            .await;
            if result.is_ok() {
                tracing::info!("Inserted profile label for {:?} with {:?}", self.did, self.label.as_ref().expect("Expected label to exist, but failed"));
            } else {
                tracing::debug!("Duplicate profile label for {:?}", self.did);
            }
            return Ok(());
        }
        tracing::warn!("Failed to insert profile label for {:?}", self.did);
        Ok(())
    }
    /// Remove label from profile_labels.
    /// Used when a label needs to be regenerated.
    pub async fn remove_label(
        pool: &sqlx::sqlite::SqlitePool,
        seq: i64,
    ) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
        tracing::debug!("Removing label with seq: {:?}", seq);
        _ = sqlx::query!(
            r#"DELETE FROM profile_labels WHERE seq = ?"#,
            seq,
        )
        .execute(pool)
        .await.expect("Expected to be able to delete a label, but failed.");
        Ok(())
    }
}