Plugin Class

__name__ = "Better Previews"
__description__ = "Modifies specific URLs (Twitter, TikTok, Reddit, Instagram, Pixiv) for better previews"
__version__ = "1.0.0"
__id__ = "better_previews"
__author__ = "@immat0x1"
__icon__ = "exteraPlugins/1"
__min_version__ = "11.12.0"

class DebugPlugin(BasePlugin):
    def on_plugin_load(self):
        # e.g. register hooks, initialize resources
        self.log("Plugin loaded!")
        pass
 
    def on_plugin_unload(self):
        # e.g. unregister hooks, clean up resources
        self.log("Plugin unloaded!")
        pass

from base_plugin import AppEvent
 
class DebugPlugin(BasePlugin):
    def on_app_event(self, event_type: AppEvent):
        if event_type == AppEvent.START:
            self.log("App is starting")
        elif event_type == AppEvent.STOP:
            self.log("App is stopping")
        elif event_type == AppEvent.PAUSE:
            self.log("App is being paused")
        elif event_type == AppEvent.RESUME:
            self.log("App is resuming")

from base_plugin import BasePlugin, MenuItemData, MenuItemType
from typing import Dict, Any
 
class MyMenuPlugin(BasePlugin):
    def on_plugin_load(self):
        self.log("Adding custom menu items...")
        self.add_menu_item(
            MenuItemData(
                menu_type=MenuItemType.MESSAGE_CONTEXT_MENU,
                text="Log Message Info",
                on_click=self.handle_message_click,
                icon="msg_info" # Example icon
            )
        )
        self.add_menu_item(
            MenuItemData(
                menu_type=MenuItemType.PROFILE_ACTION_MENU,
                text="Log User Info",
                on_click=self.handle_profile_click,
                icon="user_search" # Example icon
            )
        )
 
    def on_plugin_unload(self):
        # Menu items are removed automatically, no need for manual cleanup.
        self.log("MyMenuPlugin unloaded.")
 
    def handle_message_click(self, context: Dict[str, Any]):
        self.log(f"Message menu item clicked! Context keys: {list(context.keys())}")
 
        message = context.get("message")
        if message:
            self.log(f"Clicked on message ID: {message.getId()} from user: {message.getSenderId()}")
            self.log(f"Message text: {message.messageText}")
 
    def handle_profile_click(self, context: Dict[str, Any]):
        self.log(f"Profile menu item clicked! Context keys: {list(context.keys())}")
 
        user = context.get("user")
        if user:
            self.log(f"Profile menu clicked for user: {user.first_name} (ID: {user.id})")

self.remove_menu_item("my_unique_item_id")

from base_plugin import BasePlugin, HookResult, HookStrategy
from ui.settings import Switch
from typing import Any
 
# A list of request names that indicate the user is typing.
TYPING_REQUESTS = ["TL_messages_setTyping", "TL_messages_setEncryptedTyping"]
 
class GhostModePlugin(BasePlugin):
    def on_plugin_load(self):
        # Hook all typing-related requests
        for req_name in TYPING_REQUESTS:
            self.add_hook(req_name)
        
        # Hook the request that updates the user's online status
        self.add_hook("TL_account_updateStatus")
 
    def pre_request_hook(self, request_name: str, account: int, request: Any) -> HookResult:
        # This method is called for every request we've hooked.
 
        # 1. Block "typing..." status
        if request_name in TYPING_REQUESTS:
            if self.get_setting("dont_send_typing", True):
                self.log(f"Blocking request: {request_name}")
                # By returning CANCEL, we prevent the request from being sent.
                return HookResult(strategy=HookStrategy.CANCEL)
 
        # 2. Force offline status
        if request_name == "TL_account_updateStatus":
            if self.get_setting("force_offline", True):
                self.log("Forcing offline status in TL_account_updateStatus request.")
                # Modify the request object directly
                request.offline = True
                # Return MODIFY with the modified request object.
                return HookResult(strategy=HookStrategy.MODIFY, request=request)
 
        # For any other hooked requests we don't handle, do nothing.
        return HookResult(strategy=HookStrategy.DEFAULT)
    
    def post_request_hook(self, request_name: str, account: int, response: Any, error: Any) -> HookResult:
        # You can also intercept responses from the server.
        # For example, you could log when a message is successfully sent.
        if request_name == "TL_messages_sendMessage":
            if not error:
                self.log("Successfully sent a message!")
        return HookResult(strategy=HookStrategy.DEFAULT)
 
    def create_settings(self) -> list:
        return [
            Switch(key="dont_send_typing", text="Don't send typing status", default=True),
            Switch(key="force_offline", text="Always appear offline", default=True)
        ]

def on_update_hook(self, update_name: str, account: int, update: Any) -> HookResult:
    # Called when the app receives an individual update (e.g., TL_updateNewMessage)
    result = HookResult()
 
    if update_name == "TL_updateNewMessage":
        self.log(f"Intercepted on_update_hook for {update_name}")
        # Example: Process or modify the update
        # if hasattr(update, 'message') and hasattr(update.message, 'message'):
        #     if "secret" in update.message.message:
        #         update.message.message = "[REDACTED]"
        #         result.strategy = HookStrategy.MODIFY
        #         result.update = update # Assign the modified update back
        pass
 
    return result
 
def on_updates_hook(self, container_name: str, account: int, updates: Any) -> HookResult:
    # Called when the app receives a container of updates (e.g., TL_updates, TL_updatesCombined)
    result = HookResult()
 
    if container_name == "TL_updates" and hasattr(updates, 'updates'):
        self.log(f"Intercepted on_updates_hook for {container_name} with {len(updates.updates)} inner updates.")
        # Example: Filter updates
        # filtered_inner_updates = [upd for upd in updates.updates if not isinstance(upd, TLRPC.TL_updateUserStatus)]
        # if len(filtered_inner_updates) < len(updates.updates):
        #    updates.updates = ArrayList(filtered_inner_updates) # Assuming ArrayList is needed
        #    result.strategy = HookStrategy.MODIFY
        #    result.updates = updates # Assign the modified container back
        pass
 
    return result

def on_send_message_hook(self, account: int, params: Any) -> HookResult:
    # Called when a message is about to be sent by the client
    # `params` is an object (SendMessagesHelper.SendMessageParams) containing message details
    result = HookResult()
 
    if hasattr(params, 'message') and isinstance(params.message, str):
        self.log(f"Intercepted on_send_message_hook for message: {params.message[:30]}")
        # Example: Modify message parameters
        # if params.message.startswith(".shrug"):
        #     params.message = params.message.replace(".shrug", "¯\\_(ツ)_/¯")
        #     result.strategy = HookStrategy.MODIFY
        #     result.params = params # Assign the modified params object back
        pass
 
    return result