# main.py — application entry point
#
# SPDX-License-Identifier: GPL-3.0-or-later

import locale
import sys
from gettext import gettext as _
from pathlib import Path

import gi

gi.require_version("Gtk", "4.0")
gi.require_version("Adw", "1")
gi.require_version("PangoCairo", "1.0")

from gi.repository import Adw, Gdk, Gio, GLib, Gtk  # noqa: E402

from . import __version__  # noqa: E402
from .cache import QuoteCache  # noqa: E402
from .keystore import KeyStore  # noqa: E402
from .model import Portfolio  # noqa: E402
from .providers import PROVIDER_CLASSES, create_providers  # noqa: E402
from .quotes import QuoteService  # noqa: E402

APP_ID = "org.gnome.PortfolioManager"
PACKAGE_DIR = Path(__file__).resolve().parent


def _dispatch(callback, *args):
    """Run callback(*args) on the GTK main loop, once."""
    def idle():
        callback(*args)
        return GLib.SOURCE_REMOVE
    GLib.idle_add(idle)


class PortfolioApplication(Adw.Application):
    def __init__(self, version=__version__):
        super().__init__(application_id=APP_ID,
                         flags=Gio.ApplicationFlags.DEFAULT_FLAGS)
        self.version = version
        self.portfolio = Portfolio().load()
        settings = self.portfolio.settings
        self.keystore = KeyStore(settings, self.portfolio.save)
        keys = self.keystore.get_all([cls.id for cls in PROVIDER_CLASSES if cls.needs_key])
        self.service = QuoteService(dispatch=_dispatch, providers=create_providers(keys),
                                    cache=QuoteCache())
        self.service.configure(primary=settings.get("data_source"),
                               use_fallbacks=settings.get("use_fallbacks", True))
        GLib.set_application_name(_("Portfolio"))

    def do_startup(self):
        Adw.Application.do_startup(self)
        display = Gdk.Display.get_default()

        provider = Gtk.CssProvider()
        provider.load_from_path(str(PACKAGE_DIR / "style.css"))
        Gtk.StyleContext.add_provider_for_display(
            display, provider, Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION)

        # When running from a source checkout, find the app icons in data/
        icons = PACKAGE_DIR.parent / "data" / "icons"
        if icons.is_dir():
            Gtk.IconTheme.get_for_display(display).add_search_path(str(icons))

        self._add_actions()

    def _add_actions(self):
        settings = self.portfolio.settings

        base = Gio.SimpleAction.new_stateful(
            "base-currency", GLib.VariantType.new("s"),
            GLib.Variant("s", settings["base_currency"]))
        base.connect("change-state", self._on_base_currency)
        self.add_action(base)

        auto = Gio.SimpleAction.new_stateful(
            "auto-refresh", None, GLib.Variant("b", bool(settings["auto_refresh"])))
        auto.connect("change-state", self._on_auto_refresh)
        self.add_action(auto)

        for name, callback in (("about", self._on_about),
                               ("preferences", self._on_preferences),
                               ("quit", lambda *_: self.quit())):
            action = Gio.SimpleAction.new(name, None)
            action.connect("activate", callback)
            self.add_action(action)

        self.set_accels_for_action("app.quit", ["<Control>q"])
        self.set_accels_for_action("window.close", ["<Control>w"])
        self.set_accels_for_action("win.add", ["<Control>n"])
        self.set_accels_for_action("win.refresh", ["<Control>r", "F5"])
        self.set_accels_for_action("win.export", ["<Control>e"])
        self.set_accels_for_action("win.import", ["<Control>o"])
        self.set_accels_for_action("app.preferences", ["<Control>comma"])

    def do_activate(self):
        window = self.props.active_window
        if window is None:
            from .window import PortfolioWindow
            window = PortfolioWindow(self)
        window.present()

    def do_shutdown(self):
        self.service.shutdown()
        Adw.Application.do_shutdown(self)

    def _on_base_currency(self, action, value):
        action.set_state(value)
        window = self.props.active_window
        if window:
            window.set_base_currency(value.get_string())
        else:
            self.portfolio.settings["base_currency"] = value.get_string()
            self.portfolio.save()

    def _on_auto_refresh(self, action, value):
        action.set_state(value)
        self.portfolio.settings["auto_refresh"] = value.get_boolean()
        self.portfolio.save()
        window = self.props.active_window
        if window:
            window.reschedule()

    def _on_preferences(self, *_args):
        window = self.props.active_window
        if window is None:
            return
        from .preferences import PreferencesDialog
        PreferencesDialog(window).present(window)

    def _on_about(self, *_args):
        about = Adw.AboutDialog(
            application_name=_("Portfolio"),
            application_icon=APP_ID,
            developer_name="Ole Aamot",
            developers=["Ole Aamot <ole.aamot@gmail.com>"],
            version=self.version,
            comments=_("Track your shares on the New York Stock Exchange, "
                       "Nasdaq Stockholm and Oslo Børs."),
            website="https://www.aamot.org/ole/ole.html",
            release_notes_version="0.2.0",
            release_notes=_("<p>Prices are marked as delayed, with the time they were "
                            "fetched.</p><p>When a source fails or limits requests, the last "
                            "saved prices are shown and Portfolio retries with backoff.</p>"
                            "<p>Data sources are pluggable: Yahoo! Finance, Alpha Vantage, "
                            "Finnhub and Stooq (experimental).</p><p>Import portfolios from "
                            "CSV.</p>"),
            license_type=Gtk.License.GPL_3_0,
            copyright="© 2026 Ole Aamot",
        )
        about.add_legal_section(
            _("Market Data"), None, Gtk.License.CUSTOM,
            _("Quotes come from the data source chosen in Preferences (Yahoo! Finance by "
              "default) and may be delayed. Each source's own terms of use apply. "
              "This application does not give investment advice."))
        about.present(self.props.active_window)


def main(version=__version__):
    try:
        locale.setlocale(locale.LC_ALL, "")
    except locale.Error:
        pass
    return PortfolioApplication(version).run(sys.argv)
