#!/usr/bin/env python3
#
# Copyright (c) 2024 Stormux
# Copyright (c) 2010-2012 The Orca Team
# Copyright (c) 2012 Igalia, S.L.
# Copyright (c) 2005-2010 Sun Microsystems Inc.
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
# License as published by the Free Software Foundation; either
# version 2.1 of the License, or (at your option) any later version.
#
# This library is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
# Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public
# License along with this library; if not, write to the
# Free Software Foundation, Inc., Franklin Street, Fifth Floor,
# Boston MA  02110-1301 USA.
#
# Forked from Orca screen reader.
# Cthulhu project: https://git.stormux.org/storm/cthulhu

"""Clipboard plugin for Cthulhu."""

import os
import logging
import gettext
import gi

gi.require_version("Gtk", "3.0")
from gi.repository import Gtk, Gdk

from cthulhu.plugin import Plugin, cthulhu_hookimpl

# Set up translation function
_ = gettext.gettext

logger = logging.getLogger(__name__)

class Clipboard(Plugin):
    """Plugin to read the clipboard contents."""
    
    def __init__(self, *args, **kwargs):
        """Initialize the plugin."""
        super().__init__(*args, **kwargs)
        logger.info("Clipboard plugin initialized")
        self._signal_handler_id = None
        
    @cthulhu_hookimpl
    def activate(self, plugin=None):
        """Activate the plugin."""
        # Skip if this activation call isn't for us
        if plugin is not None and plugin is not self:
            return
            
        logger.info("Activating Clipboard plugin")
        try:
            # Register keyboard shortcut
            self.registerGestureByString(self.speakClipboard, _('clipboard'), 'kb:cthulhu+shift+c')
            logger.debug("Registered shortcut for clipboard")
        except Exception as e:
            logger.error(f"Error activating Clipboard plugin: {e}")
            
    @cthulhu_hookimpl
    def deactivate(self, plugin=None):
        """Deactivate the plugin."""
        # Skip if this deactivation call isn't for us
        if plugin is not None and plugin is not self:
            return
            
        logger.info("Deactivating Clipboard plugin")
        # Note: Currently no unregister method needed as keybindings are managed by APIHelper
            
    def speakClipboard(self, script=None, inputEvent=None):
        """Present the contents of the clipboard."""
        try:
            message = self.getClipboard()
            
            state = self.app.getDynamicApiManager().getAPI('CthulhuState')
            if state and state.activeScript:
                state.activeScript.presentMessage(message, resetStyles=False)
                logger.debug("Presented clipboard contents")
            else:
                logger.warning("Could not present clipboard: no active script")
                
            return True
        except Exception as e:
            logger.error(f"Error in speakClipboard: {e}")
            return False
            
    def getClipboard(self):
        """Get the contents of the clipboard."""
        try:
            message = ""
            found_clipboard_content = False
            
            # Get Clipboard
            clipboard_obj = Gtk.Clipboard.get(Gdk.SELECTION_CLIPBOARD)

            clipboard_text = clipboard_obj.wait_for_text()
            clipboard_image = clipboard_obj.wait_for_image()
            clipboard_uri = clipboard_obj.wait_for_uris()
            
            if clipboard_text is not None:
                found_clipboard_content = True
                
                if clipboard_obj.wait_is_uris_available():
                    no_of_objects = 0
                    no_of_folder = 0
                    no_of_files = 0
                    no_of_disks = 0
                    no_of_links = 0
                    
                    for uri in clipboard_uri:
                        if uri == '':
                            continue
                            
                        no_of_objects += 1
                        uri_without_protocol = uri[uri.find('://') + 3:]
                        message += " " + uri[uri.rfind('/') + 1:] + " "
                        
                        if os.path.isdir(uri_without_protocol):
                            no_of_folder += 1
                            message = message + _("Folder")
                            
                        if os.path.isfile(uri_without_protocol):
                            no_of_files += 1
                            message = message + _("File")
                            
                        if os.path.ismount(uri_without_protocol):
                            no_of_disks += 1
                            message = message + _("Disk")
                            
                        if os.path.islink(uri_without_protocol):
                            no_of_links += 1
                            message = message + _("Link")
                            
                    if no_of_objects > 1:
                        message = str(no_of_objects) + _(" Objects in clipboard ") + message
                    else:
                        message = str(no_of_objects) + _(" Object in clipboard ") + message
                else:
                    message = _("Text in clipboard ") + clipboard_text

            if clipboard_image is not None:
                found_clipboard_content = True
                message = _("The clipboard contains a image")

            if not found_clipboard_content:
                message = _("The clipboard is empty")
                
            return message
        except Exception as e:
            logger.error(f"Error getting clipboard content: {e}")
            return _("Error accessing clipboard")
