main.py

import os
from pathlib import Path

from PIL import Image, ImageDraw
from pynput import keyboard
import pystray

from app_info import APP_DESCRIPTION, APP_NAME, APP_VERSION
from corrector import correct, update_runtime_settings
from injector import AutoCorrectEngine
from settings import AppSettings, SettingsManager, get_app_dir
from ui import SettingsWindowManager


settings_manager = SettingsManager()
app_settings = settings_manager.load()
update_runtime_settings(
    ignored_words=app_settings.ignored_words,
    custom_replacements=app_settings.custom_replacements,
)
engine = AutoCorrectEngine(enabled=app_settings.enabled)
icon_ref: pystray.Icon | None = None


def create_icon_image(enabled: bool) -> Image.Image:
    outer_color = "#3FA9F5" if enabled else "#8EA1B2"
    inner_color = "#D9F1FF" if enabled else "#E5EBF0"
    image = Image.new("RGBA", (64, 64), (255, 255, 255, 0))
    draw = ImageDraw.Draw(image)
    draw.ellipse((6, 6, 58, 58), fill=outer_color)
    draw.ellipse((12, 12, 52, 52), fill=inner_color)
    draw.text((23, 14), "A", fill=outer_color)
    draw.line((20, 40, 28, 47, 42, 30), fill=outer_color, width=4)
    return image


def save_settings() -> None:
    settings_manager.save(app_settings)


def sync_runtime_settings() -> None:
    update_runtime_settings(
        ignored_words=app_settings.ignored_words,
        custom_replacements=app_settings.custom_replacements,
    )


def update_icon(icon: pystray.Icon) -> None:
    enabled = engine.is_enabled()
    icon.icon = create_icon_image(enabled)
    icon.title = f"AutoCorrect: {'On' if enabled else 'Off'}"
    icon.menu = build_menu()
    icon.update_menu()


def refresh_icon() -> None:
    if icon_ref is not None:
        update_icon(icon_ref)


def set_enabled(icon: pystray.Icon, value: bool) -> None:
    app_settings.enabled = engine.set_enabled(value)
    save_settings()
    update_icon(icon)
    state = "enabled" if value else "disabled"
    print(f"[autocorrect] Real-time autocorrect {state}.")


def on_toggle(icon: pystray.Icon, item) -> None:
    set_enabled(icon, not engine.is_enabled())


def on_toggle_startup(icon: pystray.Icon, item) -> None:
    app_settings.launch_at_startup = not app_settings.launch_at_startup
    settings_manager.ensure_startup_state(app_settings.launch_at_startup)
    save_settings()
    update_icon(icon)
    state = "enabled" if app_settings.launch_at_startup else "disabled"
    print(f"[autocorrect] Launch at startup {state}.")


def open_data_folder(icon: pystray.Icon, item) -> None:
    open_data_folder_path()


def on_quit(icon: pystray.Icon, item) -> None:
    save_settings()
    print("[autocorrect] Shutting down.")
    icon.stop()


def open_data_folder_path() -> None:
    path = get_app_dir()
    path.mkdir(parents=True, exist_ok=True)
    os.startfile(path)
    print(f"[autocorrect] Settings folder: {path}")


def get_current_settings() -> AppSettings:
    return AppSettings(
        enabled=app_settings.enabled,
        launch_at_startup=app_settings.launch_at_startup,
        ignored_words=list(app_settings.ignored_words),
        custom_replacements=dict(app_settings.custom_replacements),
    )


def apply_settings(updated: AppSettings) -> None:
    app_settings.enabled = engine.set_enabled(updated.enabled)
    app_settings.launch_at_startup = updated.launch_at_startup
    app_settings.ignored_words = settings_manager._normalize_words(updated.ignored_words)
    app_settings.custom_replacements = settings_manager._normalize_replacements(
        updated.custom_replacements
    )
    settings_manager.ensure_startup_state(app_settings.launch_at_startup)
    sync_runtime_settings()
    save_settings()
    refresh_icon()
    print("[autocorrect] Settings updated.")


def export_settings(target_path: str, settings: AppSettings) -> Path:
    return settings_manager.export_to(target_path, settings)


def import_settings(source_path: str) -> AppSettings:
    return settings_manager.import_from(source_path)


settings_window = SettingsWindowManager(
    load_settings=get_current_settings,
    save_settings=apply_settings,
    open_folder=open_data_folder_path,
    preview_text=correct,
    export_settings=export_settings,
    import_settings=import_settings,
)


def open_settings_window(icon: pystray.Icon, item) -> None:
    settings_window.show()


def build_menu() -> pystray.Menu:
    return pystray.Menu(
        pystray.MenuItem(
            lambda item: f"Status: {'On' if engine.is_enabled() else 'Off'}",
            None,
            enabled=False,
        ),
        pystray.MenuItem(
            lambda item: "Turn autocorrect off" if engine.is_enabled() else "Turn autocorrect on",
            on_toggle,
        ),
        pystray.MenuItem(
            "Open settings",
            open_settings_window,
            default=True,
        ),
        pystray.MenuItem(
            lambda item: (
                "Disable launch at startup"
                if app_settings.launch_at_startup
                else "Enable launch at startup"
            ),
            on_toggle_startup,
        ),
        pystray.MenuItem("Open settings folder", open_data_folder),
        pystray.MenuItem("Quit", on_quit),
    )


def on_press(key) -> None:
    engine.handle_press(key)


def start_keyboard_listener() -> keyboard.Listener:
    listener = keyboard.Listener(on_press=on_press)
    listener.start()
    return listener


def seed_default_files() -> None:
    path = get_app_dir()
    path.mkdir(parents=True, exist_ok=True)
    save_settings()


def main() -> None:
    global icon_ref
    seed_default_files()
    sync_runtime_settings()
    settings_manager.ensure_startup_state(app_settings.launch_at_startup)

    print("=" * 40)
    print(f" {APP_NAME} {APP_VERSION} is running")
    print(f" {APP_DESCRIPTION}")
    print(f" Real-time correction: {'On' if app_settings.enabled else 'Off'}")
    print(f" Settings folder: {get_app_dir()}")
    print(" Use the tray icon to enable, disable, or quit")
    print("=" * 40)

    listener = start_keyboard_listener()

    icon = pystray.Icon(
        "autocorrect",
        create_icon_image(enabled=app_settings.enabled),
        f"AutoCorrect: {'On' if app_settings.enabled else 'Off'}",
        menu=build_menu(),
    )
    icon_ref = icon
    update_icon(icon)

    try:
        icon.run()
    finally:
        listener.stop()


if __name__ == "__main__":
    main()