pharos_native/runtime/event_discovery/

social_announcements.rs

//! Extracts bounded date-only performances from attributed public artist announcements without inventing time or venue.
use super::{DiscoveredEvent, Value, json, public_link, social_evidence};

const INTENTS: [&str; 9] = [
    "next stop",
    "next gig",
    "upcoming show",
    "playing at",
    "playing in",
    "see you at",
    "catch me at",
    "will be playing",
    "performing at",
];

/// Separates a forward-looking performance announcement from an earlier retrospective in the same post.
pub(super) fn prospective_text(text: &str) -> Option<&str> {
    let lower = text.to_ascii_lowercase();
    INTENTS
        .iter()
        .filter_map(|intent| lower.rfind(intent))
        .max()
        .map(|index| &text[index..])
}

/// Derives a year only from verified publication metadata and an explicitly forward-looking month/day announcement.
pub(super) fn event_day(value: &Value) -> Option<u64> {
    let body = value
        .get("description")
        .and_then(Value::as_str)
        .unwrap_or("");
    let text = prospective_text(body).unwrap_or(body);
    if let Some(date) = social_evidence::date(text) {
        return Some(date);
    }
    if let Some(date) = value
        .get("image_text")
        .and_then(Value::as_str)
        .and_then(social_evidence::date)
    {
        return Some(date);
    }
    prospective_text(body)?;
    let posted = social_evidence::publication(value)?;
    let published = pharos_runtime_core::time::timestamp_from_epoch_seconds(posted);
    let year = published.get(..4)?.parse::<u32>().ok()?;
    let tokens = text
        .split(|c: char| !c.is_ascii_alphanumeric())
        .filter(|token| !token.is_empty())
        .take(512)
        .collect::<Vec<_>>();
    for (index, token) in tokens.iter().enumerate() {
        let lower = token.to_ascii_lowercase();
        let Some(month) = [
            ("jan", "january"),
            ("feb", "february"),
            ("mar", "march"),
            ("apr", "april"),
            ("may", "may"),
            ("jun", "june"),
            ("jul", "july"),
            ("aug", "august"),
            ("sep", "september"),
            ("oct", "october"),
            ("nov", "november"),
            ("dec", "december"),
        ]
        .iter()
        .position(|(short, long)| {
            lower == *short || lower == *long || lower == "sept" && *short == "sep"
        }) else {
            continue;
        };
        let day = tokens
            .get(index + 1)
            .or_else(|| {
                index
                    .checked_sub(1)
                    .and_then(|previous| tokens.get(previous))
            })
            .and_then(|day| {
                day.trim_end_matches(|c: char| c.is_ascii_alphabetic())
                    .parse::<u32>()
                    .ok()
            })
            .filter(|day| (1..=31).contains(day));
        let Some(day) = day else {
            continue;
        };
        for year in [year, year + 1] {
            let Some(date) = super::runtime_timestamp_seconds(&format!(
                "{year:04}-{:02}-{day:02}T00:00:00Z",
                month + 1
            )) else {
                continue;
            };
            if date >= posted.saturating_sub(86400) && date <= posted.saturating_add(366 * 86400) {
                return Some(date);
            }
        }
    }
    None
}

/// Recognizes an explicit named next stop before organizer credits; generic same-day posts never imply one performance.
pub(super) fn performance_title(value: &str) -> Option<String> {
    let lower = value.to_ascii_lowercase();
    let tail = lower
        .strip_prefix("next stop")?
        .trim_start_matches([' ', ':']);
    let (title, _) = tail.split_once(" by ")?;
    let title = title
        .split(|ch: char| !ch.is_alphanumeric())
        .filter(|word| !word.is_empty())
        .collect::<Vec<_>>();
    (title.len() >= 3 && title.iter().map(|word| word.len()).sum::<usize>() >= 12)
        .then(|| title.join(" "))
}

/// Removes provider tracking from a direct post URL while retaining the resource identity required by Facebook photo links.
pub(super) fn canonical_post_url(value: &str) -> Option<String> {
    let mut url = url::Url::parse(&public_link(value)?).ok()?;
    let host = match url.host_str()? {
        "facebook.com" | "www.facebook.com" | "m.facebook.com" | "mbasic.facebook.com" => {
            "www.facebook.com"
        }
        "instagram.com" | "www.instagram.com" => "www.instagram.com",
        "x.com" | "www.x.com" | "twitter.com" | "www.twitter.com" => "x.com",
        _ => return None,
    };
    if url
        .query_pairs()
        .any(|(key, _)| matches!(key.as_ref(), "comment_id" | "reply_comment_id"))
    {
        return None;
    }
    let mut query = std::collections::BTreeMap::new();
    for (key, value) in url
        .query_pairs()
        .filter(|(key, _)| matches!(key.as_ref(), "id" | "story_fbid" | "fbid"))
    {
        if value.is_empty()
            || value.len() > 512
            || !value.bytes().all(|ch| ch.is_ascii_alphanumeric())
            || query.insert(key.into_owned(), value.into_owned()).is_some()
        {
            return None;
        }
    }
    let post_path = url
        .path()
        .split('/')
        .any(|part| matches!(part, "posts" | "status" | "videos" | "reel" | "p"));
    if !post_path
        && !(matches!(
            url.path(),
            "/photo/" | "/photo.php" | "/story.php" | "/permalink.php"
        ) && (query.contains_key("fbid") || query.contains_key("story_fbid")))
    {
        return None;
    }
    url.set_host(Some(host)).ok()?;
    url.set_fragment(None);
    url.set_query(None);
    if !query.is_empty() {
        url.query_pairs_mut().extend_pairs(query);
    }
    Some(url.to_string())
}

/// Reuses an existing same-artist/day post identity when an older record retained provider tracking parameters.
pub(super) fn retain_existing_identities(
    store: &super::super::database::LogicalAppStore,
    artist: i64,
    events: &mut [DiscoveredEvent],
) -> Result<(), pharos_runtime_social::SocialError> {
    use pharos_runtime_database::operations::{Predicate, Query};
    if events.is_empty() {
        return Ok(());
    }
    let rows = store
        .adapter
        .query(
            &store.config,
            &store.schema,
            &Query {
                entity: "gig_event".into(),
                fields: vec![
                    "event_key".into(),
                    "event_url".into(),
                    "starts_at".into(),
                    "title".into(),
                    "id".into(),
                    "status".into(),
                ],
                filter: Some(Predicate::All(vec![
                    Predicate::Equal("artist_row_id".into(), json!(artist)),
                    Predicate::In(
                        "starts_at".into(),
                        events.iter().map(|event| json!(event.starts_at)).collect(),
                    ),
                ])),
                order: vec![],
                limit: 1000,
                offset: 0,
            },
        )
        .map_err(|_| pharos_runtime_social::SocialError::Transport)?;
    if rows.len() >= 1000 {
        return Err(pharos_runtime_social::SocialError::Capacity);
    }
    let mut identities = std::collections::BTreeMap::new();
    let mut performances: std::collections::BTreeMap<(String, u64), (bool, i64, String)> =
        std::collections::BTreeMap::new();
    for row in rows {
        let Some(url) = row
            .get("event_url")
            .and_then(Value::as_str)
            .and_then(canonical_post_url)
        else {
            continue;
        };
        let start = row
            .get("starts_at")
            .and_then(Value::as_str)
            .and_then(super::runtime_timestamp_seconds)
            .ok_or(pharos_runtime_social::SocialError::InvalidResponse)?;
        let key = row
            .get("event_key")
            .and_then(Value::as_str)
            .ok_or(pharos_runtime_social::SocialError::InvalidResponse)?
            .to_owned();
        if let Some(title) = row
            .get("title")
            .and_then(Value::as_str)
            .and_then(performance_title)
        {
            let id = row
                .get("id")
                .and_then(Value::as_i64)
                .ok_or(pharos_runtime_social::SocialError::InvalidResponse)?;
            let archived = row.get("status").and_then(Value::as_str) == Some("archived");
            let entry = performances
                .entry((title, start))
                .or_insert((archived, id, key.clone()));
            if (archived, id) < (entry.0, entry.1) {
                *entry = (archived, id, key.clone());
            }
        }
        match identities.entry((url, start)) {
            std::collections::btree_map::Entry::Vacant(entry) => {
                entry.insert(Some(key));
            }
            std::collections::btree_map::Entry::Occupied(mut entry) => {
                entry.insert(None);
            }
        }
    }
    for event in events {
        let start = super::runtime_timestamp_seconds(&event.starts_at)
            .ok_or(pharos_runtime_social::SocialError::InvalidResponse)?;
        if let Some(existing) =
            performance_title(&event.title).and_then(|title| performances.get(&(title, start)))
        {
            event.key = existing.2.clone();
        } else if let Some(key) = identities.get(&(event.event_url.clone(), start)) {
            event.key = key
                .as_ref()
                .ok_or(pharos_runtime_social::SocialError::Busy)?
                .clone();
        }
    }
    Ok(())
}

/// Publishes only explicitly public, dated artist announcements; missing times, venues and ticket links stay absent.
pub(super) fn extract(value: &Value, artist: &str, now: u64) -> Option<DiscoveredEvent> {
    if value.get("evidence_kind")?.as_str()? != "rendered_post"
        || value.get("audience")?.as_str()? != "public"
        || !social_evidence::eligible(value, now)
    {
        return None;
    }
    let body = value.get("description")?.as_str()?;
    let image = value
        .get("image_text")
        .and_then(Value::as_str)
        .unwrap_or("");
    let forward = prospective_text(body);
    let words = |value: &str| {
        value
            .split(|ch: char| !ch.is_alphanumeric())
            .filter(|word| !word.is_empty())
            .map(str::to_lowercase)
            .collect::<Vec<_>>()
            .join(" ")
    };
    let image_words = words(image);
    let artist_words = words(artist);
    let credited = !artist_words.is_empty()
        && format!(" {image_words} ").contains(&format!(" {artist_words} "));
    let lower_body = body.to_ascii_lowercase();
    let explicit_performance = ["playing", "performing", "my set", "my show", "on stage"]
        .iter()
        .any(|cue| lower_body.contains(cue));
    let poster = credited
        && ["festival", "lineup", "line up", "live", "tickets", "event"]
            .iter()
            .any(|cue| image_words.contains(cue));
    if forward.is_none() && !explicit_performance && !poster {
        return None;
    }
    let text = forward.unwrap_or(
        if body.trim().is_empty() || poster && !explicit_performance {
            image
        } else {
            body
        },
    );
    let lower = text.to_ascii_lowercase();
    if ["cancelled", "canceled", "postponed", "rescheduled"]
        .iter()
        .any(|word| lower.contains(word))
    {
        return None;
    }
    let start = event_day(value)?;
    let posted_day = social_evidence::publication(value)? / 86400 * 86400;
    if start < posted_day {
        return None;
    }
    let url = canonical_post_url(value.get("url")?.as_str()?)?;
    let profile = public_link(value.get("source_profile")?.as_str()?)?;
    let provider =
        pharos_runtime_social::provider::SocialProvider::from_url(&url::Url::parse(&url).ok()?);
    if provider
        != pharos_runtime_social::provider::SocialProvider::from_url(
            &url::Url::parse(&profile).ok()?,
        )
    {
        return None;
    }
    let title = text.split_whitespace().collect::<Vec<_>>().join(" ");
    let title = title[..title.floor_char_boundary(300)].to_owned();
    let day = pharos_runtime_core::time::timestamp_from_epoch_seconds(start)[..10].to_owned();
    let identity = performance_title(&title)
        .map(|title| format!("{}:{title}", super::normalized_name(artist)))
        .unwrap_or_else(|| url.clone());
    let key = pharos_runtime_database::operations::operation_fingerprint(&(
        "artist_announcement",
        identity,
        &day,
    ))
    .ok()?;
    let evidence = json!({"extraction_version":3,"date_precision":"day","artist":artist,"event":{"@type":"MusicEvent","name":title,"startDate":day,"performer":{"name":artist},"url":url},"candidate":value}).to_string();
    if evidence.len() > 7680 || artist.trim().is_empty() {
        return None;
    }
    Some(DiscoveredEvent {
        key,
        title,
        starts_at: pharos_runtime_core::time::timestamp_from_epoch_seconds(start),
        ends_at: String::new(),
        venue: String::new(),
        address: String::new(),
        country: String::new(),
        timezone: String::new(),
        event_state: "scheduled".into(),
        state_explicit: false,
        organizers: vec![],
        event_url: url.clone(),
        ticket_url: String::new(),
        status: "published".into(),
        evidence,
        evidence_source: url,
    })
}

#[cfg(test)]
mod tests {
    use super::*;
    /// Models the live artist's retrospective followed by a distinct current announcement.
    fn announcement() -> Value {
        json!({"evidence_kind":"rendered_post","audience":"public","description":"Thank you for the wonderful weekend. Next stop: Intersection in Nagoya by Necorokk Records Official Oct 17","datePublished":"2026-10-16T09:52:00Z","author_url":"https://www.facebook.com/madmaxxmusic","source_profile":"https://www.facebook.com/madmaxxmusic","url":"https://www.facebook.com/photo/?fbid=123"})
    }
    /// Keeps a genuine next stop while rejecting the preceding recap, and does not fabricate venue, time or tickets.
    #[test]
    fn dated_next_stop_is_a_date_only_gig() {
        let now = super::super::runtime_timestamp_seconds("2026-10-24T00:00:00Z").unwrap();
        let event = extract(&announcement(), "Mad Maxx", now).unwrap();
        assert!(event.starts_at.starts_with("2026-10-17T00:00:00"));
        assert!(event.evidence.contains("\"date_precision\":\"day\""));
        assert!(!event.title.contains("Thank you"));
        assert!(event.timezone.is_empty() && event.venue.is_empty() && event.ticket_url.is_empty());
        let mut value = announcement();
        value["description"] = json!("Thank you for the amazing festival October 17 2026");
        assert!(extract(&value, "Mad Maxx", now).is_none());
    }
    /// An explicitly dated flyer must credit this artist, and a post after the event cannot become a new announcement.
    #[test]
    fn dated_artist_flyers_are_distinct_from_after_event_posts() {
        let now = super::super::runtime_timestamp_seconds("2026-10-24T00:00:00Z").unwrap();
        let mut value = announcement();
        value["description"] = json!("Festival announcement");
        value["image_text"] = json!("Festival lineup Mad Maxx October 27 2026");
        assert!(extract(&value, "Mad Maxx", now).is_some());
        value["image_text"] = json!("Festival lineup Another Artist October 27 2026");
        assert!(extract(&value, "Mad Maxx", now).is_none());
        value["description"] = json!("Playing at the festival October 17 2026");
        value["datePublished"] = json!("2026-10-18T00:00:00Z");
        assert!(extract(&value, "Mad Maxx", now).is_none());
    }

    /// The same explicit named next stop on two provider posts is one artist performance, not two calendar rows.
    #[test]
    fn cross_provider_announcements_share_performance_identity() {
        let now = super::super::runtime_timestamp_seconds("2026-10-24T00:00:00Z").unwrap();
        let facebook = extract(&announcement(), "Mad Maxx", now).unwrap();
        let mut value = announcement();
        value["description"] =
            json!("Next stop: Intersection in Nagoya by @necorokkrecords Oct 17");
        value["url"] = json!("https://www.instagram.com/p/AbC123/");
        value["source_profile"] = json!("https://www.instagram.com/madmaxxmusic/");
        value["author_url"] = value["source_profile"].clone();
        let instagram = extract(&value, "Mad Maxx", now).unwrap();
        assert_eq!(facebook.key, instagram.key);
        let accepted =
            super::super::model::write_values(None, &facebook, 1, 2, "2026-10-24T00:00:00Z", None)
                .unwrap();
        assert!(!super::super::model::conflicts(&accepted, &instagram, 1));
        value["description"] = json!("Next stop: Another festival in Osaka by @organizer Oct 17");
        assert_ne!(extract(&value, "Mad Maxx", now).unwrap().key, facebook.key);
    }

    /// Provider tracking and fragments never create distinct performance identities.
    #[test]
    fn post_identity_ignores_tracking() {
        assert_eq!(
            canonical_post_url("https://m.facebook.com/artist/posts/123?__cft__=tracking#more"),
            Some("https://www.facebook.com/artist/posts/123".into())
        );
        assert_eq!(
            canonical_post_url("https://www.facebook.com/photo/?fbid=123&tracking=ignored"),
            Some("https://www.facebook.com/photo/?fbid=123".into())
        );
        assert!(
            canonical_post_url("https://www.facebook.com/photo/?fbid=123&comment_id=456").is_none()
        );
    }

    /// Never publishes private, undated, foreign-author or cancelled announcements or profile-only links.
    #[test]
    fn unsafe_or_incomplete_posts_are_not_published() {
        let now = super::super::runtime_timestamp_seconds("2026-10-24T00:00:00Z").unwrap();
        for (key, invalid) in [
            ("audience", json!("unknown")),
            ("datePublished", json!("")),
            ("author_url", json!("https://www.facebook.com/another")),
            ("url", json!("https://www.facebook.com/madmaxxmusic")),
            ("url", json!("https://unrelated.example/events/123")),
            ("description", json!("Next stop cancelled October 17 2026")),
        ] {
            let mut value = announcement();
            value[key] = invalid;
            assert!(extract(&value, "Mad Maxx", now).is_none(), "{key}");
        }
    }
}