# preferences.py — general settings and data sources
#
# SPDX-License-Identifier: GPL-3.0-or-later

from gettext import gettext as _

from gi.repository import Adw, GLib, Gtk

from .exchanges import BASE_CURRENCIES, EXCHANGES
from .providers import PROVIDER_CLASSES


class PreferencesDialog(Adw.PreferencesDialog):
    def __init__(self, window):
        super().__init__(search_enabled=False)
        self.window = window
        self.app = window.app
        self.settings = window.portfolio.settings
        self.service = window.service
        self.keystore = window.app.keystore
        self._sources_changed = False

        self.add(self._general_page())
        self.add(self._sources_page())
        self.connect("closed", self._on_closed)

    # ---- general -----------------------------------------------------------

    def _general_page(self):
        page = Adw.PreferencesPage(title=_("General"), icon_name="preferences-system-symbolic")

        display = Adw.PreferencesGroup(title=_("Display"))
        self.currency_row = Adw.ComboRow(title=_("Show Totals In"),
                                         model=Gtk.StringList.new(list(BASE_CURRENCIES)))
        self.currency_row.set_selected(BASE_CURRENCIES.index(self.settings["base_currency"]))
        self.currency_row.connect("notify::selected", self._on_currency)
        display.add(self.currency_row)
        page.add(display)

        updates = Adw.PreferencesGroup(title=_("Updates"))
        self.auto_row = Adw.SwitchRow(title=_("Refresh Automatically"),
                                      active=bool(self.settings["auto_refresh"]))
        self.auto_row.connect("notify::active", self._on_auto_refresh)
        updates.add(self.auto_row)
        self.interval_row = Adw.SpinRow.new_with_range(1, 60, 1)
        self.interval_row.set_title(_("Refresh Every"))
        self.interval_row.set_subtitle(_("Minutes. Sources with a daily limit are asked less "
                                         "often."))
        self.interval_row.set_value(max(1, round(self.settings["refresh_interval"] / 60)))
        self.interval_row.set_sensitive(bool(self.settings["auto_refresh"]))
        self.interval_row.connect("notify::value", self._on_interval)
        updates.add(self.interval_row)
        page.add(updates)
        return page

    def _on_currency(self, row, _pspec):
        code = BASE_CURRENCIES[row.get_selected()]
        self.app.activate_action("base-currency", GLib.Variant("s", code))

    def _on_auto_refresh(self, row, _pspec):
        action = self.app.lookup_action("auto-refresh")
        action.change_state(GLib.Variant("b", row.get_active()))
        self.interval_row.set_sensitive(row.get_active())

    def _on_interval(self, row, _pspec):
        self.settings["refresh_interval"] = int(row.get_value()) * 60
        self.window.portfolio.save()
        self.window.reschedule()

    # ---- data sources ------------------------------------------------------

    def _sources_page(self):
        page = Adw.PreferencesPage(title=_("Data Sources"), icon_name="network-server-symbolic")

        primary = Adw.PreferencesGroup(
            title=_("Price Data"),
            description=_("Quotes from free sources are usually delayed. When a source fails "
                          "or limits requests, Portfolio shows the last saved prices."))
        self.classes = [cls for cls in PROVIDER_CLASSES if cls.id in self.service.providers]
        names = [cls.name + (" " + _("(experimental)") if cls.experimental else "")
                 for cls in self.classes]
        self.primary_row = Adw.ComboRow(title=_("Primary Source"),
                                        model=Gtk.StringList.new(names))
        ids = [cls.id for cls in self.classes]
        current = self.settings.get("data_source", ids[0])
        self.primary_row.set_selected(ids.index(current) if current in ids else 0)
        self.primary_row.connect("notify::selected", self._on_primary)
        primary.add(self.primary_row)

        self.fallback_row = Adw.SwitchRow(
            title=_("Use Other Sources as Fallback"),
            subtitle=_("Try other configured sources that cover the stock's market"),
            active=bool(self.settings.get("use_fallbacks", True)))
        self.fallback_row.connect("notify::active", self._on_fallbacks)
        primary.add(self.fallback_row)

        self.coverage_note = Adw.ActionRow(use_markup=False, subtitle_lines=3,
                                           css_classes=["property"])
        self.coverage_note.add_prefix(Gtk.Image(icon_name="dialog-information-symbolic"))
        primary.add(self.coverage_note)
        page.add(primary)

        for cls in PROVIDER_CLASSES:
            if cls.id in self.service.providers:
                page.add(self._provider_group(cls))
        self._update_coverage_note()
        return page

    def _provider_group(self, cls):
        provider = self.service.providers[cls.id]
        title = cls.name + (" " + _("(experimental)") if cls.experimental else "")
        group = Adw.PreferencesGroup(title=title, description=cls.description)

        markets = [e.short_name for e in EXCHANGES if cls.markets and e.id in cls.markets]
        features = [", ".join(markets)]
        if cls.supports_history:
            features.append(_("price history"))
        if cls.supports_fx:
            features.append(_("exchange rates"))
        covers = Adw.ActionRow(title=_("Covers"), subtitle=" · ".join(features),
                               use_markup=False, css_classes=["property"])
        group.add(covers)

        if cls.needs_key:
            key_row = Adw.PasswordEntryRow(title=_("API Key"), show_apply_button=True)
            key_row.set_text(provider.api_key)
            key_row.connect("apply", self._on_key_applied, cls.id)
            group.add(key_row)

            link = Adw.ActionRow(title=_("Get a Free API Key"), activatable=True,
                                 use_markup=False, subtitle=cls.key_url)
            link.add_suffix(Gtk.Image(icon_name="adw-external-link-symbolic"))
            link.connect("activated", self._on_open_link, cls.key_url)
            group.add(link)

        if cls.daily_limit:
            used = Adw.ActionRow(title=_("Requests Used Today"), use_markup=False,
                                 css_classes=["property"],
                                 subtitle=_("{used} of {limit}").format(
                                     used=self.service.budget_used(cls.id),
                                     limit=cls.daily_limit))
            group.add(used)
        return group

    def _update_coverage_note(self):
        primary = self.service.primary_provider
        uncovered = [e.short_name for e in EXCHANGES
                     if not any(p.covers(e.id) for p in self.service.chain())]
        if not primary.configured:
            text = _("{source} needs an API key before it can be used.").format(
                source=primary.name)
        elif uncovered:
            text = _("No configured source covers {markets}; those stocks will show saved "
                     "prices only.").format(markets=_(" and ").join(uncovered))
        else:
            sources = [p.name for p in self.service.chain()]
            text = _("Prices are fetched from {sources}, in that order.").format(
                sources=", ".join(sources))
        self.coverage_note.set_title(text)
        if not self.keystore.uses_keyring:
            self.coverage_note.set_subtitle(
                _("The keyring is not available, so API keys are kept in the settings file."))

    def _on_primary(self, row, _pspec):
        pid = self.classes[row.get_selected()].id
        self.settings["data_source"] = pid
        self.window.portfolio.save()
        self.service.configure(primary=pid)
        self._sources_changed = True
        self._update_coverage_note()

    def _on_fallbacks(self, row, _pspec):
        self.settings["use_fallbacks"] = row.get_active()
        self.window.portfolio.save()
        self.service.configure(use_fallbacks=row.get_active())
        self._sources_changed = True
        self._update_coverage_note()

    def _on_key_applied(self, row, provider_id):
        key = row.get_text().strip()
        self.keystore.set(provider_id, key)
        self.service.configure(keys={provider_id: key})
        self._sources_changed = True
        self._update_coverage_note()
        self.add_toast(Adw.Toast(title=_("API key saved") if key else _("API key removed"),
                                 timeout=2))

    def _on_open_link(self, _row, uri):
        Gtk.UriLauncher.new(uri).launch(self.window, None, None)

    def _on_closed(self, *_args):
        if self._sources_changed:
            self.window.refresh(force=True)
