utils.py

import os
from typing import Optional

import sublime

from .constants import SETTINGS_FILE


def claudette_chat_status_message(
    window, message: str, prefix: str = "ℹ️", copy_path: Optional[str] = None
) -> int:
    """
    Display a status message in the active chat view.

    Args:
        window: The Sublime Text window
        message (str): Status text to display
        prefix (str, optional): Prefix icon/text (default "ℹ️")
        copy_path (str, optional): If set, show a Copy Path phantom

    Returns:
        int: End position of the message in the view, or -1 if missing
    """
    if not window:
        return -1

    # Find the active chat view
    current_chat_view = None
    for view in window.views():
        if view.settings().get(
            "claudette_is_chat_view", False
        ) and view.settings().get("claudette_is_current_chat", False):
            current_chat_view = view
            break

    if not current_chat_view:
        return -1

    if current_chat_view.size() > 0:
        view_size = current_chat_view.size()
        last_chars = current_chat_view.substr(
            sublime.Region(max(0, view_size - 2), view_size)
        )
        if last_chars == "\n\n":
            # Two trailing newlines: do not add another before the message
            formatted_message = f"{prefix + ' ' if prefix else ''}{message}"
        elif last_chars.endswith("\n"):
            # Content ends with one newline, add one more for spacing
            formatted_message = f"\n{prefix + ' ' if prefix else ''}{message}"
        else:
            # Content doesn't end with newline, add two for spacing
            formatted_message = (
                f"\n\n{prefix + ' ' if prefix else ''}{message}"
            )
    else:
        formatted_message = f"{prefix + ' ' if prefix else ''}{message}"

    current_chat_view.set_read_only(False)
    current_chat_view.run_command(
        "append",
        {
            "characters": formatted_message,
            "force": True,
            "scroll_to_end": True,
        },
    )

    # Add "Copy Path" button as phantom if path is provided
    if copy_path:
        button_position = current_chat_view.size()
        _add_copy_path_phantom(current_chat_view, button_position, copy_path)

    # Add trailing newline
    current_chat_view.run_command(
        "append", {"characters": "\n", "force": True, "scroll_to_end": True}
    )

    end_point = current_chat_view.size()

    current_chat_view.sel().clear()
    current_chat_view.sel().add(sublime.Region(end_point, end_point))

    current_chat_view.set_read_only(True)

    return end_point


# Store phantom sets for copy path buttons per view
_copy_path_phantom_sets = {}


def claudette_cleanup_copy_path_phantoms_for_view(view):
    """Remove copy-path phantom state when a view is closed."""
    view_id = view.id()
    if view_id not in _copy_path_phantom_sets:
        return
    _copy_path_phantom_sets[view_id].update([])
    del _copy_path_phantom_sets[view_id]


def claudette_clear_copy_path_phantom_registry():
    """Clear all copy-path phantom registry entries (e.g. on plugin unload)."""
    _copy_path_phantom_sets.clear()


def _add_copy_path_phantom(view, position: int, path: str):
    """
    Add a "Copy Path" phantom button at the specified position.

    Args:
        view: The Sublime Text view
        position: The position in the view to add the phantom
        path: The path to copy when the button is clicked
    """
    view_id = view.id()

    if view_id not in _copy_path_phantom_sets:
        _copy_path_phantom_sets[view_id] = sublime.PhantomSet(
            view, f"copy_path_buttons_{view_id}"
        )

    phantom_set = _copy_path_phantom_sets[view_id]

    # Escape the path for use in HTML
    escaped_path = (
        path.replace("&", "&")
        .replace('"', """)
        .replace("<", "&lt;")
        .replace(">", "&gt;")
    )

    button_html = (
        ' <span class="copy-path-button" style="padding-left: 8px">'
        f'<a href="copy:{escaped_path}">Copy Path</a></span>'
    )

    def on_navigate(href):
        if href.startswith("copy:"):
            path_to_copy = href[5:]
            sublime.set_clipboard(path_to_copy)
            sublime.status_message("File path copied to clipboard")

    region = sublime.Region(position, position)
    phantom = sublime.Phantom(
        region, button_html, sublime.LAYOUT_INLINE, on_navigate
    )

    # Get existing phantoms and add the new one
    existing_phantoms = list(phantom_set.phantoms)
    existing_phantoms.append(phantom)
    phantom_set.update(existing_phantoms)


def claudette_estimate_api_tokens(text):
    """Rough token estimate from character count (chars / 4)."""
    return len(text) // 4


def claudette_detect_encoding(sample):
    """
    Detect file encoding using BOMs and content analysis.
    Similar to how Sublime Text handles encodings.
    """
    # Check for BOMs
    if sample.startswith(b"\xef\xbb\xbf"):
        return "utf-8-sig"
    elif sample.startswith(b"\xfe\xff"):
        return "utf-16be"
    elif sample.startswith(b"\xff\xfe"):
        return "utf-16le"
    elif sample.startswith(b"\x00\x00\xfe\xff"):
        return "utf-32be"
    elif sample.startswith(b"\xff\xfe\x00\x00"):
        return "utf-32le"

    # Try UTF-8
    try:
        sample.decode("utf-8")
        return "utf-8"
    except UnicodeDecodeError:
        return "latin-1"  # Fallback encoding


def claudette_is_text_file(
    file_path, sample_size=4096, max_size=1024 * 1024 * 10
):
    """
    More complete implementation of Sublime Text's text file detection.

    Args:
        file_path: Path to the file to check
        sample_size: Number of bytes to sample
        max_size: Maximum file size to consider (10MB default)

    Returns:
        tuple: (is_text, encoding, reason)
    """
    try:
        file_size = os.path.getsize(file_path)

        # Size check
        if file_size > max_size:
            return False, None, "File too large"

        # Empty file check
        if file_size == 0:
            return True, "utf-8", "Empty file"

        with open(file_path, "rb") as f:
            sample = f.read(min(sample_size, file_size))

        # Binary check
        if b"\x00" in sample:
            null_percentage = sample.count(b"\x00") / len(sample)
            if null_percentage > 0.01:  # More than 1% nulls
                return False, None, "Binary file (contains NULL bytes)"

        # Encoding detection
        encoding = claudette_detect_encoding(sample)

        # Verification check
        try:
            with open(file_path, "r", encoding=encoding) as f:
                f.read(sample_size)
            return True, encoding, "Valid text file"
        except UnicodeDecodeError:
            return False, None, "Unable to decode with detected encoding"

    except IOError as e:
        return False, None, f"IO Error: {str(e)}"


def claudette_get_api_key():
    """
    Get the currently active API key.

    Returns:
        dict or None: Active key dict with 'key' and 'name', else None
    """
    settings = sublime.load_settings(SETTINGS_FILE)
    api_key = settings.get("api_key")

    # For string API key, return a dict format
    if isinstance(api_key, str) and api_key.strip():
        return {"key": api_key, "name": "Default"}

    # For dict with multiple keys, get the current one
    elif (
        isinstance(api_key, dict)
        and api_key.get("keys")
        and isinstance(api_key["keys"], list)
    ):
        keys = api_key["keys"]
        current_index = api_key.get("active_key", 0)

        # If there's a valid current index, return that key
        if isinstance(current_index, int) and 0 <= current_index < len(keys):
            key_entry = keys[current_index]
            if isinstance(key_entry, dict) and key_entry.get("key"):
                return key_entry

        # Otherwise return the first valid key
        for key_entry in keys:
            if isinstance(key_entry, dict) and key_entry.get("key"):
                return key_entry

    return None


def claudette_get_api_key_value():
    """
    Extract the API key value from the API key dictionary.

    Returns:
        str: The API key value, or an empty string if not available
    """
    api_key = claudette_get_api_key()

    if isinstance(api_key, dict):
        return api_key.get("key", "")

    return ""


def claudette_get_api_key_name():
    """
    Get the API key name from the API key dictionary.

    Returns:
        str: The API key name, 'Default' if the key has no name, or 'Undefined'
    """
    api_key = claudette_get_api_key()

    if isinstance(api_key, dict):
        return api_key.get("name", "Default")

    return "Undefined"