thoughts/crates/application/src/use_cases/feed.rs

use domain::{
    errors::DomainError,
    models::{
        feed::{FeedEntry, PageParams, Paginated, UserSummary},
        user::User,
    },
    ports::{FeedRepository, FollowRepository, TagRepository, UserRepository},
    value_objects::UserId,
};

pub async fn get_home_feed(
    feed: &dyn FeedRepository,
    follows: &dyn FollowRepository,
    user_id: &UserId,
    page: PageParams,
) -> Result<Paginated<FeedEntry>, DomainError> {
    let mut following_ids = follows.get_accepted_following_ids(user_id).await?;
    following_ids.push(user_id.clone()); // include own thoughts in home feed
    feed.home_feed(&following_ids, &page, Some(user_id)).await
}

pub async fn get_public_feed(
    feed: &dyn FeedRepository,
    viewer_id: Option<&UserId>,
    page: PageParams,
) -> Result<Paginated<FeedEntry>, DomainError> {
    feed.public_feed(&page, viewer_id).await
}

pub async fn get_user_feed(
    feed: &dyn FeedRepository,
    user_id: &UserId,
    page: PageParams,
    viewer_id: Option<&UserId>,
) -> Result<Paginated<FeedEntry>, DomainError> {
    feed.user_feed(user_id, &page, viewer_id).await
}

pub async fn get_followers(
    follows: &dyn FollowRepository,
    user_id: &UserId,
    page: PageParams,
) -> Result<Paginated<User>, DomainError> {
    follows.list_followers(user_id, &page).await
}

pub async fn get_following(
    follows: &dyn FollowRepository,
    user_id: &UserId,
    page: PageParams,
) -> Result<Paginated<User>, DomainError> {
    follows.list_following(user_id, &page).await
}

pub async fn get_by_tag(
    feed: &dyn FeedRepository,
    tag_name: &str,
    page: PageParams,
    viewer_id: Option<&UserId>,
) -> Result<Paginated<FeedEntry>, DomainError> {
    feed.tag_feed(tag_name, &page, viewer_id).await
}

pub async fn search(
    feed: &dyn FeedRepository,
    query: &str,
    page: PageParams,
    viewer_id: Option<&UserId>,
) -> Result<Paginated<FeedEntry>, DomainError> {
    feed.search(query, &page, viewer_id).await
}

pub async fn list_users(users: &dyn UserRepository) -> Result<Vec<UserSummary>, DomainError> {
    users.list_with_stats().await
}

pub async fn get_popular_tags(
    tags: &dyn TagRepository,
    limit: usize,
) -> Result<Vec<(String, i64)>, DomainError> {
    tags.popular_tags(limit).await
}