twblue/src/controller/buffers/blueski/timeline.py

# -*- coding: utf-8 -*-
import logging
import output
from .base import BaseBuffer
from wxUI.buffers.blueski import panels as BlueskiPanels

log = logging.getLogger("controller.buffers.blueski.timeline")


class HomeTimeline(BaseBuffer):
    """Discover feed buffer."""

    def __init__(self, *args, **kwargs):
        super(HomeTimeline, self).__init__(*args, **kwargs)
        self.type = "home_timeline"
        self.feed_uri = None
        self.next_cursor = None
        self.sound = "tweet_received.ogg"

    def create_buffer(self, parent, name):
        self.buffer = BlueskiPanels.HomePanel(parent, name)
        self.buffer.session = self.session

    def start_stream(self, mandatory=False, play_sound=True):
        count = self.get_max_items()
        api = self.session._ensure_client()
        if not self.feed_uri:
            self.feed_uri = self._resolve_discover_feed(api)
        try:
            if self.feed_uri:
                res = api.app.bsky.feed.get_feed({"feed": self.feed_uri, "limit": count})
            else:
                res = api.app.bsky.feed.get_timeline({"limit": count})
            items = list(getattr(res, "feed", []))
            self.next_cursor = getattr(res, "cursor", None)
        except Exception as e:
            log.error("Error fetching home timeline: %s", e)
            return 0
        return self.process_items(items, play_sound)

    def get_more_items(self):
        if not self.next_cursor:
            return
        count = self.get_max_items()
        api = self.session._ensure_client()
        try:
            if self.feed_uri:
                res = api.app.bsky.feed.get_feed({"feed": self.feed_uri, "limit": count, "cursor": self.next_cursor})
            else:
                res = api.app.bsky.feed.get_timeline({"limit": count, "cursor": self.next_cursor})
            items = list(getattr(res, "feed", []))
            self.next_cursor = getattr(res, "cursor", None)
            added = self.process_items(items, play_sound=False)
            if added:
                output.speak(_(u"%s items retrieved") % added, True)
        except Exception as e:
            log.error("Error fetching more home timeline: %s", e)

    def _resolve_discover_feed(self, api):
        cached = self.session.db.get("discover_feed_uri")
        if cached:
            return cached
        try:
            res = api.app.bsky.feed.get_suggested_feeds({"limit": 50})
            for feed in getattr(res, "feeds", []):
                dn = getattr(feed, "displayName", "") or getattr(feed, "display_name", "")
                if "discover" in dn.lower():
                    uri = getattr(feed, "uri", "")
                    self.session.db["discover_feed_uri"] = uri
                    return uri
        except Exception:
            pass
        return None


class FollowingTimeline(BaseBuffer):
    """Following-only timeline (reverse-chronological)."""

    def __init__(self, *args, **kwargs):
        super(FollowingTimeline, self).__init__(*args, **kwargs)
        self.type = "following_timeline"
        self.next_cursor = None
        self.sound = "tweet_received.ogg"

    def create_buffer(self, parent, name):
        self.buffer = BlueskiPanels.HomePanel(parent, name)
        self.buffer.session = self.session

    def start_stream(self, mandatory=False, play_sound=True):
        count = self.get_max_items()
        api = self.session._ensure_client()
        try:
            res = api.app.bsky.feed.get_timeline({"limit": count, "algorithm": "reverse-chronological"})
            items = list(getattr(res, "feed", []))
            self.next_cursor = getattr(res, "cursor", None)
        except Exception as e:
            log.error("Error fetching following timeline: %s", e)
            return 0
        return self.process_items(items, play_sound)

    def get_more_items(self):
        if not self.next_cursor:
            return
        count = self.get_max_items()
        api = self.session._ensure_client()
        try:
            res = api.app.bsky.feed.get_timeline({"limit": count, "algorithm": "reverse-chronological", "cursor": self.next_cursor})
            items = list(getattr(res, "feed", []))
            self.next_cursor = getattr(res, "cursor", None)
            added = self.process_items(items, play_sound=False)
            if added:
                output.speak(_(u"%s items retrieved") % added, True)
        except Exception as e:
            log.error("Error fetching more following timeline: %s", e)


class NotificationBuffer(BaseBuffer):
    """Notifications buffer."""

    def __init__(self, *args, **kwargs):
        kwargs["compose_func"] = "compose_notification"
        super(NotificationBuffer, self).__init__(*args, **kwargs)
        self.type = "notifications"
        self.sound = "notification_received.ogg"
        self.next_cursor = None

    def create_buffer(self, parent, name):
        self.buffer = BlueskiPanels.NotificationPanel(parent, name)
        self.buffer.session = self.session

    def start_stream(self, mandatory=False, play_sound=True):
        count = self.get_max_items()
        api = self.session._ensure_client()
        if not api:
            return 0
        try:
            res = api.app.bsky.notification.list_notifications({"limit": count})
            notifications = list(getattr(res, "notifications", []))
            self.next_cursor = getattr(res, "cursor", None)
            if not notifications:
                return 0
            return self.process_items(notifications, play_sound)
        except Exception as e:
            log.error("Error fetching notifications: %s", e)
            return 0

    def get_more_items(self):
        if not self.next_cursor:
            return
        count = self.get_max_items()
        api = self.session._ensure_client()
        if not api:
            return
        try:
            res = api.app.bsky.notification.list_notifications({"limit": count, "cursor": self.next_cursor})
            notifications = list(getattr(res, "notifications", []))
            self.next_cursor = getattr(res, "cursor", None)
            added = self.process_items(notifications, play_sound=False)
            if added:
                output.speak(_(u"%s items retrieved") % added, True)
        except Exception as e:
            log.error("Error fetching more notifications: %s", e)

    def add_new_item(self, notification):
        return self.process_items([notification], play_sound=True)


class Conversation(BaseBuffer):
    """Thread/conversation view."""

    def __init__(self, *args, **kwargs):
        super(Conversation, self).__init__(*args, **kwargs)
        self.type = "conversation"
        self.root_uri = kwargs.get("uri")
        self.sound = "search_updated.ogg"

    def create_buffer(self, parent, name):
        self.buffer = BlueskiPanels.HomePanel(parent, name)
        self.buffer.session = self.session

    def start_stream(self, mandatory=False, play_sound=True):
        if not self.root_uri:
            return 0
        api = self.session._ensure_client()
        try:
            res = api.app.bsky.feed.get_post_thread({"uri": self.root_uri, "depth": 100, "parentHeight": 100})
            thread = getattr(res, "thread", None)
            if not thread:
                return 0

            def g(obj, key, default=None):
                return obj.get(key, default) if isinstance(obj, dict) else getattr(obj, key, default)

            final_items = []
            # Add ancestors
            ancestors = []
            parent = g(thread, "parent")
            while parent:
                ppost = g(parent, "post")
                if ppost:
                    ancestors.insert(0, ppost)
                parent = g(parent, "parent")
            final_items.extend(ancestors)

            # Traverse thread
            def traverse(node):
                if not node:
                    return
                post = g(node, "post")
                if post:
                    final_items.append(post)
                for r in (g(node, "replies") or []):
                    traverse(r)

            traverse(thread)
            self.session.db[self.name] = []
            self.buffer.list.clear()
            return self.process_items(final_items, play_sound)
        except Exception as e:
            log.error("Error fetching thread: %s", e)
            return 0


class LikesBuffer(BaseBuffer):
    """User's liked posts."""

    def __init__(self, *args, **kwargs):
        super(LikesBuffer, self).__init__(*args, **kwargs)
        self.type = "likes"
        self.next_cursor = None
        self.sound = "favourite.ogg"

    def create_buffer(self, parent, name):
        self.buffer = BlueskiPanels.HomePanel(parent, name)
        self.buffer.session = self.session

    def start_stream(self, mandatory=False, play_sound=True):
        count = self.get_max_items()
        api = self.session._ensure_client()
        try:
            res = api.app.bsky.feed.get_actor_likes({"actor": api.me.did, "limit": count})
            items = list(getattr(res, "feed", None) or getattr(res, "items", None) or [])
            self.next_cursor = getattr(res, "cursor", None)
        except Exception as e:
            log.error("Error fetching likes: %s", e)
            return 0
        return self.process_items(items, play_sound)

    def get_more_items(self):
        if not self.next_cursor:
            return
        count = self.get_max_items()
        api = self.session._ensure_client()
        if not api:
            return
        try:
            res = api.app.bsky.feed.get_actor_likes({"actor": api.me.did, "limit": count, "cursor": self.next_cursor})
            items = list(getattr(res, "feed", None) or getattr(res, "items", None) or [])
            self.next_cursor = getattr(res, "cursor", None)
            added = self.process_items(items, play_sound=False)
            if added:
                output.speak(_(u"%s items retrieved") % added, True)
        except Exception as e:
            log.error("Error fetching more likes: %s", e)


class MentionsBuffer(BaseBuffer):
    """Mentions, replies and quotes."""

    def __init__(self, *args, **kwargs):
        kwargs["compose_func"] = "compose_notification"
        super(MentionsBuffer, self).__init__(*args, **kwargs)
        self.type = "mentions"
        self.sound = "mention_received.ogg"
        self.next_cursor = None

    def create_buffer(self, parent, name):
        self.buffer = BlueskiPanels.NotificationPanel(parent, name)
        self.buffer.session = self.session

    def start_stream(self, mandatory=False, play_sound=True):
        count = self.get_max_items()
        api = self.session._ensure_client()
        if not api:
            return 0
        try:
            res = api.app.bsky.notification.list_notifications({"limit": count})
            notifications = getattr(res, "notifications", [])
            self.next_cursor = getattr(res, "cursor", None)
            mentions = [n for n in notifications if getattr(n, "reason", "") in ("mention", "reply", "quote")]
            if not mentions:
                return 0
            return self.process_items(mentions, play_sound)
        except Exception as e:
            log.error("Error fetching mentions: %s", e)
            return 0

    def get_more_items(self):
        if not self.next_cursor:
            return
        count = self.get_max_items()
        api = self.session._ensure_client()
        if not api:
            return
        try:
            res = api.app.bsky.notification.list_notifications({"limit": count, "cursor": self.next_cursor})
            notifications = getattr(res, "notifications", [])
            self.next_cursor = getattr(res, "cursor", None)
            mentions = [n for n in notifications if getattr(n, "reason", "") in ("mention", "reply", "quote")]
            if mentions:
                added = self.process_items(mentions, play_sound=False)
                if added:
                    output.speak(_(u"%s items retrieved") % added, True)
        except Exception as e:
            log.error("Error fetching more mentions: %s", e)

    def add_new_item(self, notification):
        if getattr(notification, "reason", "") in ("mention", "reply", "quote"):
            return self.process_items([notification], play_sound=True)
        return 0


class SentBuffer(BaseBuffer):
    """User's sent posts."""

    def __init__(self, *args, **kwargs):
        super(SentBuffer, self).__init__(*args, **kwargs)
        self.type = "sent"
        self.next_cursor = None

    def create_buffer(self, parent, name):
        self.buffer = BlueskiPanels.HomePanel(parent, name)
        self.buffer.session = self.session

    def start_stream(self, mandatory=False, play_sound=True):
        count = self.get_max_items()
        api = self.session._ensure_client()
        if not api or not api.me:
            return 0
        try:
            res = api.app.bsky.feed.get_author_feed({"actor": api.me.did, "limit": count, "filter": "posts_no_replies"})
            items = list(getattr(res, "feed", []))
            self.next_cursor = getattr(res, "cursor", None)
            if not items:
                return 0
            return self.process_items(items, play_sound)
        except Exception as e:
            log.error("Error fetching sent posts: %s", e)
            return 0

    def get_more_items(self):
        if not self.next_cursor:
            return
        count = self.get_max_items()
        api = self.session._ensure_client()
        if not api or not api.me:
            return
        try:
            res = api.app.bsky.feed.get_author_feed({"actor": api.me.did, "limit": count, "filter": "posts_no_replies", "cursor": self.next_cursor})
            items = list(getattr(res, "feed", []))
            self.next_cursor = getattr(res, "cursor", None)
            added = self.process_items(items, play_sound=False)
            if added:
                output.speak(_(u"%s items retrieved") % added, True)
        except Exception as e:
            log.error("Error fetching more sent posts: %s", e)


class UserTimeline(BaseBuffer):
    """Timeline for a specific user."""

    def __init__(self, *args, **kwargs):
        self.actor = kwargs.get("actor")
        self.handle = kwargs.get("handle")
        super(UserTimeline, self).__init__(*args, **kwargs)
        self.type = "user_timeline"
        self.next_cursor = None
        self._resolved_actor = None
        self.sound = "tweet_timeline.ogg"

    def create_buffer(self, parent, name):
        self.buffer = BlueskiPanels.HomePanel(parent, name)
        self.buffer.session = self.session

    def start_stream(self, mandatory=False, play_sound=True):
        if not self.actor:
            return 0
        count = self.get_max_items()
        actor = self.actor.strip().lstrip("@") if isinstance(self.actor, str) else self.actor
        api = self.session._ensure_client()
        if not api:
            return 0
        try:
            if isinstance(actor, str) and not actor.startswith("did:"):
                profile = self.session.get_profile(actor)
                if profile:
                    did = profile.get("did") if isinstance(profile, dict) else getattr(profile, "did", None)
                    if did:
                        actor = did
            self._resolved_actor = actor
            res = api.app.bsky.feed.get_author_feed({"actor": actor, "limit": count})
            items = list(getattr(res, "feed", []) or [])
            self.next_cursor = getattr(res, "cursor", None)
        except Exception as e:
            log.error("Error fetching user timeline: %s", e)
            return 0
        return self.process_items(items, play_sound)

    def get_more_items(self):
        if not self.next_cursor or not self._resolved_actor:
            return
        count = self.get_max_items()
        api = self.session._ensure_client()
        if not api:
            return
        try:
            res = api.app.bsky.feed.get_author_feed({"actor": self._resolved_actor, "limit": count, "cursor": self.next_cursor})
            items = list(getattr(res, "feed", []) or [])
            self.next_cursor = getattr(res, "cursor", None)
            added = self.process_items(items, play_sound=False)
            if added:
                output.speak(_(u"%s items retrieved") % added, True)
        except Exception as e:
            log.error("Error fetching more user timeline: %s", e)

    def remove_buffer(self, force=False):
        if not force:
            from wxUI import commonMessageDialogs
            import widgetUtils
            if commonMessageDialogs.remove_buffer() != widgetUtils.YES:
                return False
        self.session.db.pop(self.name, None)
        timelines = self.session.settings["other_buffers"].get("timelines") or []
        if isinstance(timelines, str):
            timelines = [t for t in timelines.split(",") if t]
        for key in (self.actor or "", self.handle or ""):
            if key in timelines:
                timelines.remove(key)
        self.session.settings["other_buffers"]["timelines"] = timelines
        self.session.settings.write()
        return True


class SearchBuffer(BaseBuffer):
    """Search results buffer."""

    def __init__(self, *args, **kwargs):
        self.search_query = kwargs.pop("query", "")
        super(SearchBuffer, self).__init__(*args, **kwargs)
        self.type = "search"
        self.next_cursor = None
        self.sound = "search_updated.ogg"

    def create_buffer(self, parent, name):
        self.buffer = BlueskiPanels.HomePanel(parent, name)
        self.buffer.session = self.session

    def start_stream(self, mandatory=False, play_sound=True):
        if not self.search_query:
            return 0
        count = self.get_max_items()
        api = self.session._ensure_client()
        if not api:
            return 0
        try:
            res = api.app.bsky.feed.search_posts({"q": self.search_query, "limit": count})
            posts = list(getattr(res, "posts", []))
            self.next_cursor = getattr(res, "cursor", None)
            if not posts:
                return 0
            self.session.db[self.name] = []
            self.buffer.list.clear()
            return self.process_items(posts, play_sound)
        except Exception as e:
            log.error("Error searching posts: %s", e)
            return 0

    def get_more_items(self):
        if not self.next_cursor or not self.search_query:
            return
        count = self.get_max_items()
        api = self.session._ensure_client()
        if not api:
            return
        try:
            res = api.app.bsky.feed.search_posts({"q": self.search_query, "limit": count, "cursor": self.next_cursor})
            posts = list(getattr(res, "posts", []))
            self.next_cursor = getattr(res, "cursor", None)
            added = self.process_items(posts, play_sound=False)
            if added:
                output.speak(_(u"%s items retrieved") % added, True)
        except Exception as e:
            log.error("Error fetching more search results: %s", e)

    def remove_buffer(self, force=False):
        if not force:
            from wxUI import commonMessageDialogs
            import widgetUtils
            if commonMessageDialogs.remove_buffer() != widgetUtils.YES:
                return False
        self.session.db.pop(self.name, None)
        searches = self.session.settings["other_buffers"].get("searches") or []
        if isinstance(searches, str):
            searches = [s for s in searches.split(",") if s]
        if self.search_query in searches:
            searches.remove(self.search_query)
            self.session.settings["other_buffers"]["searches"] = searches
            self.session.settings.write()
        return True