Bavarder/src/main.py

# main.py
#
# Copyright 2023 Me
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program 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 General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see <http://www.gnu.org/licenses/>.
#
# SPDX-License-Identifier: GPL-3.0-or-later

import sys
import gi
import sys
import threading
import json

gi.require_version("Gtk", "4.0")
gi.require_version("Adw", "1")
gi.require_version("Gdk", "4.0")
gi.require_version("Gst", "1.0")
gi.require_version('WebKit', '6.0')

from gi.repository import Gtk, Gio, Adw, Gdk, GLib, Gst, WebKit
from .views.main_window import BavarderWindow
from .views.preferences_window import Preferences
from .views.about_window import BavarderAboutWindow
from enum import auto, IntEnum

from .constants import app_id, version, build_type

from tempfile import NamedTemporaryFile

from .providers import PROVIDERS
import platform
import os
import markdown
import tempfile
import re
import requests

from .threading import KillableThread

from enum import auto, IntEnum

class Step(IntEnum):
    CONVERT_HTML = auto()
    LOAD_WEBVIEW = auto()
    RENDER = auto()

ANNOUCEMENT_URL = "https://bavarder.codeberg.page/annoucements.json"


class BavarderApplication(Adw.Application):
    """The main application singleton class."""

    annoucements = {}

    def __init__(self):
        super().__init__(
            application_id=app_id,
            flags=Gio.ApplicationFlags.DEFAULT_FLAGS,
        )
        self.create_action("quit_all", self.on_close_all, ["<primary>q"])
        self.create_action("quit", self.on_quit, ["<primary>w"])
        self.create_action("about", self.on_about_action)
        self.create_action(
            "preferences", self.on_preferences_action, ["<primary>comma"]
        )
        self.create_action("copy_prompt", self.on_copy_prompt_action)
        self.create_action("copy_bot", self.on_copy_bot_action, ["<primary><shift>c"])
        self.create_action("ask", self.on_ask_action, ["<primary>Return"])
        self.create_action("clear", self.on_clear_action, ["<primary><shift>BackSpace"])
        self.create_action("stop", self.on_stop_action, ["<primary>Escape"])
        self.create_action("new", self.on_new_window, ["<primary>n"])
        self.create_action("open_help", self.on_open_help, ["F1"])
        # self.create_action("speak", self.on_speak_action, ["<primary>S"])
        # self.create_action("listen", self.on_listen_action, ["<primary>L"])

        self.settings = Gio.Settings(schema_id=app_id)

        self.clear_after_send = self.settings.get_boolean("clear-after-send")
        self.use_text_view = self.settings.get_boolean("use-text-view")

        self.enabled_providers = sorted(
            set(self.settings.get_strv("enabled-providers"))
        )
        self.latest_provider = self.settings.get_string("latest-provider")
        self.provider = self.latest_provider
        self.close_all_without_dialog = self.settings.get_boolean(
            "close-all-without-dialog"
        )
        self.create_stateful_action(
            "set_provider",
            GLib.VariantType.new("s"),
            GLib.Variant("s", self.latest_provider),
            self.on_set_provider_action
        )
        self.allow_remote_fetching = self.settings.get_boolean("allow-remote-fetching")
        self.use_theme = False
        self.providers = {}

    def load_annoucements(self):
        try:
            self.annoucements = requests.get(ANNOUCEMENT_URL).json()
        except:
            pass
        else:
            try:
                self.latest = self.annoucements["latest"]
                del self.annoucements["latest"]
            except:
                pass
            else:
                if not self.latest in version:
                    self.win.banner.set_title(_("New version available!"))
                    self.win.banner.set_revealed(True)



    def on_open_help(self, action, *args):
        GLib.spawn_command_line_async(
            f"xdg-open https://bavarder.codeberg.page"
        )

    def on_set_provider_action(self, action, *args):
        self.provider = args[0].get_string()
        Gio.SimpleAction.set_state(self.lookup_action("set_provider"), args[0])


    def quitting(self, *args, **kwargs):
        """Called before closing main window."""
        self.settings.set_strv("enabled-providers", list(self.enabled_providers))
        self.settings.set_string("latest-provider", self.provider)


        print("Saving providers data...")

        self.save_providers()

    @property
    def win(self):
        return self.props.active_window

    def on_new_window(self, action, *args):
        self.new_window()

    def new_window(self, window=None):
        if window:
            win = self.props.active_window
        else:
            win = BavarderWindow(application=self)
        win.connect("close-request", self.quitting)
        self.load_dropdown(win)
        self.load()
        win.web_view = None
        win.web_view_pending_html = None
        win.loading = False
        win.shown = False
        win.preview_visible = False

        win.present()

    def close_all(self):
        self.quitting()
        for w in self.get_windows():
            w.close()


    def on_close_all(self, action, param):
        print("Closing all windows...")

        
        if len(self.get_windows()) == 1:
            self.on_quit(action, param)
        elif self.close_all_without_dialog:
            self.close_all()
        else:
            dialog = Adw.MessageDialog(
                heading="Close all windows?",
                body="Closing all windows will lead to chat data loss",
                transient_for=self.props.active_window,
            )
            dialog.add_response("cancel", "Cancel")
            dialog.add_response("close", "Close")
            dialog.set_response_appearance("close", Adw.ResponseAppearance.DESTRUCTIVE)
            dialog.set_default_response("cancel")
            dialog.set_close_response("cancel")
            dialog.connect("response", self.on_close_all_response)
            dialog.present()

    def on_close_all_response(self, dialog, response):
        if response == "close":
            self.close_all()
        dialog.close()
        

    def on_quit(self, action, param):
        """Called when the user activates the Quit action."""
        print("Closing active window...")
        self.quitting()
        self.win.close()

    def save_providers(self):
        r = {}
        for k, p in self.providers.items():
            r[p.slug] = json.dumps(p.save())
        data = GLib.Variant("a{ss}", r)
        self.settings.set_value("providers-data", data)

    def on_clear_action(self, action, param):
        self.win.bot_text_view.get_buffer().set_text("")
        self.win.prompt_text_view.get_buffer().set_text("")
        self.win.prompt_text_view.grab_focus()

    def do_activate(self):
        """Called when the application is activated.

        We raise the application's main window, creating it if
        necessary.
        """
        self.new_window()
        if self.allow_remote_fetching:
            self.load_annoucements()
        self.win.prompt_text_view.grab_focus()

    def load_dropdown(self, window=None):
        if window is None:
            window = self.props.active_window

        self.menu_model = Gio.Menu()
        self.menu_model.append_item(Gio.MenuItem.new(label=_("New Window"), detailed_action="app.new"))

        section_menu = Gio.Menu()

        provider_menu = Gio.Menu()


        self.providers = {}
        self.providers_data = self.settings.get_value("providers-data")

        for provider in self.enabled_providers:
            if provider in self.providers:
                p = self.providers[provider]
                name = p.name
                slug = p.slug
            else:
                try:
                    p = PROVIDERS[provider]
                    name = p.name
                    slug = p.slug
                except KeyError:
                    continue
                else:
                    self.providers[slug] = PROVIDERS[provider](window, self)

            item_model = Gio.MenuItem()
            item_model.set_label(name)
            item_model.set_action_and_target_value(
                "app.set_provider",
                GLib.Variant("s", slug))
            provider_menu.append_item(item_model)
        section_menu.append_submenu(_("Providers"), provider_menu)

        section_menu.append_item(Gio.MenuItem.new(label=_("Preferences"), detailed_action="app.preferences"))
        section_menu.append_item(Gio.MenuItem.new(label=_("Keyboard Shortcuts"), detailed_action="win.show-help-overlay"))
        section_menu.append_item(Gio.MenuItem.new(label=_("About Bavarder"), detailed_action="app.about"))

        self.menu_model.append_section(None, section_menu)

        window.menu.set_menu_model(self.menu_model)

    def load(self):
        for p in self.providers.values():
            try:
                p.load(data=json.loads(self.providers_data[p.slug]))
            except KeyError:  # provider not in data
                pass

    def on_provider_selector_notify(self, _unused, pspec):
        try:
            self.win.banner.set_revealed(False)
        except AttributeError:
            pass

    def on_about_action(self, widget, _):
        """Callback for the app.about action."""
        about = BavarderAboutWindow(self.win)
        about.show_about()

    def on_preferences_action(self, widget, *args, **kwargs):
        """Callback for the app.preferences action."""
        preferences = Preferences(
            parent=self.win
        )
        preferences.present()

    def on_copy_prompt_action(self, widget, _):
        """Callback for the app.copy_prompt action."""

        toast = Adw.Toast()

        text = self.win.prompt_text_view.get_buffer()
        toast.set_title("Text copied")

        (start, end) = text.get_bounds()
        text = text.get_text(start, end, False)

        if len(text) == 0:
            return

        Gdk.Display.get_default().get_clipboard().set(text)

        self.win.toast_overlay.add_toast(toast)

    def on_copy_bot_action(self, widget, _):
        """Callback for the app.copy_bot action."""

        toast = Adw.Toast()
        toast.set_title("Text copied")
        
        try: 
            text = self.response 
        except AttributeError:
            return
        else:
            if len(text) == 0:
                return
            else:
                Gdk.Display.get_default().get_clipboard().set(text)

                self.win.toast_overlay.add_toast(toast)

    @staticmethod
    def on_click_link(web_view, decision, _decision_type):
        if web_view.get_uri().startswith(("http://", "https://", "www.")):
            Glib.spawn_command_line_async(f"xdg-open {web_view.get_uri()}")
            decision.ignore()
            return True

    @staticmethod
    def on_right_click(web_view, context_menu, _event, _hit_test):
        # disable some context menu option
        for item in context_menu.get_items():
            if item.get_stock_action() in [WebKit.ContextMenuAction.RELOAD,
                                           WebKit.ContextMenuAction.GO_BACK,
                                           WebKit.ContextMenuAction.GO_FORWARD,
                                           WebKit.ContextMenuAction.STOP]:
                context_menu.remove(item)


    def show(self, html=None, step=Step.LOAD_WEBVIEW):
        if step == Step.LOAD_WEBVIEW:
            self.win.loading = True
            if not self.win.web_view:
                self.win.web_view = WebKit.WebView()
                self.win.web_view.get_settings().set_allow_universal_access_from_file_urls(True)

                self.win.web_view.get_settings().set_enable_developer_extras(True)

                # Show preview once the load is finished
                self.win.web_view.connect("load-changed", self.on_load_changed)

                # All links will be opened in default browser, but local files are opened in apps.
                self.win.web_view.connect("decide-policy", self.on_click_link)

                self.win.web_view.connect("context-menu", self.on_right_click)

                self.win.web_view.set_hexpand(True)
                self.win.web_view.set_vexpand(True)

                self.win.scrolled_response_window.set_child(self.win.web_view)
            
            if self.win.web_view.is_loading():
                self.win.web_view_pending_html = html
            else:
                try:
                    self.win.web_view.load_html(html, "file://localhost/")
                except TypeError: # Argument 1 does not allow None as a value
                    pass


        elif step == Step.RENDER:
            if not self.win.preview_visible:
                self.win.preview_visible = True
                self.show()

    def reload(self, *_widget, reshow=False):
        if self.win.preview_visible:
            if reshow:
                self.hide()
            self.show()

    def on_load_changed(self, _web_view, event):
        if event == WebKit.LoadEvent.FINISHED:
            self.win.loading = False
            if self.win.web_view_pending_html:
                self.show(html=self.win.web_view_pending_html, step=Step.LOAD_WEBVIEW)
                self.win.web_view_pending_html = None
            else:
                # we only lazyload the webview once
                self.show(step=Step.RENDER)

    def parse_css(self, path):

        adw_palette_prefixes = [
            "blue_",
            "green_",
            "yellow_",
            "orange_",
            "red_",
            "purple_",
            "brown_",
            "light_",
            "dark_"
        ]

        # Regular expressions
        not_define_color = re.compile(r"(^(?:(?!@define-color).)*$)")
        define_color = re.compile(r"(@define-color .*[^\s])")
        css = ""
        variables = {}
        palette = {}

        for color in adw_palette_prefixes:
            palette[color] = {}

        with open(path, "r", encoding="utf-8") as sheet:
            for line in sheet:
                cdefine_match = re.search(define_color, line)
                not_cdefine_match = re.search(not_define_color, line)
                if cdefine_match != None: # If @define-color variable declarations were found
                    palette_part = cdefine_match.__getitem__(1) # Get the second item of the re.Match object
                    name, color = palette_part.split(" ", 1)[1].split(" ", 1)
                    if name.startswith(tuple(adw_palette_prefixes)): # Palette colors
                        palette[name[:-1]][name[-1:]] = color[:-1]
                    else: # Other color variables
                        variables[name] = color[:-1]
                elif not_cdefine_match != None: # If CSS rules were found
                    css_part = not_cdefine_match.__getitem__(1)
                    css += f"{css_part}\n"

            sheet.close()
            return variables, palette, css
            
    def update_response(self, response):
        """Update the response text view with the response."""
        self.response = response

        if not self.use_text_view:
            response = markdown.markdown(response, extensions=["markdown.extensions.extra", 'pymdownx.arithmatex', 'pymdownx.highlight'])

            TEMPLATE = """
            <html>
                <head>
                    <style>
                        @font-face {
                        font-family: 'Cantarell';
                        src: local("Cantarell")
                        }

                        @font-face {
                        font-family: 'Monospace';
                        src: local("Monospace")
                        }

                        @font-face {
                        font-family: color-emoji;
                        src: local("Noto Color Emoji"), local("Apple Color Emoji"), local("Segoe UI Emoji"), local("Segoe UI Symbol");
                        }

                        {theme_css}

                        * {
                        box-sizing: border-box;
                        }

                        html {
                        font-size: 11pt;
                        }

                        body {
                        color: var(--text-color);
                        background-color: var(--background-color);
                        font-family: "Cantarell", "Monospace", sans-serif, color-emoji;
                        line-height: 1.5;
                        word-wrap: break-word;
                        max-width: 980px;
                        margin: 0;
                        //padding: 4em;
                        }

                        a {
                        background-color: transparent;
                        color: var(--link-color);
                        text-decoration: none;
                        }

                        a:active,
                        a:hover {
                        outline-width: 0;
                        }

                        a:hover {
                        text-decoration: underline;
                        }

                        strong {
                        font-weight: bold;
                        }

                        img {
                        border-style: none;
                        }

                        hr {
                        box-sizing: content-box;
                        height: 0.25em;
                        padding: 0;
                        margin: 1.5em 0;
                        overflow: hidden;
                        background-color: var(--hr-background-color);
                        border: 0;
                        }

                        hr::before {
                        display: table;
                        content: "";
                        }

                        hr::after {
                        display: table;
                        clear: both;
                        content: "";
                        }

                        input {
                        font-family: inherit;
                        font-size: inherit;
                        line-height: inherit;
                        margin: 0;
                        overflow: visible;
                        }

                        [type="checkbox"] {
                        box-sizing: border-box;
                        padding: 0;
                        }

                        table {
                        border-spacing: 0;
                        border-collapse: collapse;
                        }

                        td,
                        th {
                        padding: 0;
                        }

                        h1,
                        h2,
                        h3,
                        h4,
                        h5,
                        h6 {
                        font-weight: bold;
                        margin: 0;
                        }

                        h1 {
                        font-size: 24pt;
                        }

                        h2 {
                        font-size: 18pt;
                        }

                        h3 {
                        font-size: 14pt;
                        }

                        h4 {
                        font-size: 12pt;
                        }

                        h5 {
                        font-size: 10pt;
                        }

                        h6 {
                        font-size: 8pt;
                        }

                        p {
                        margin-top: 0;
                        margin-bottom: 0.625em;
                        }

                        blockquote {
                        margin: 0;
                        }

                        ul,
                        ol {
                        padding-left: 0;
                        margin-top: 0;
                        margin-bottom: 0;
                        }

                        ol ol,
                        ul ol {
                        list-style-type: lower-roman;
                        }

                        ul ul ol,
                        ul ol ol,
                        ol ul ol,
                        ol ol ol {
                        list-style-type: lower-alpha;
                        }

                        dd {
                        margin-left: 0;
                        }

                        code,
                        kbd,
                        pre {
                        font-family: "Monospace", monospace, color-emoji;
                        font-size: 12pt;
                        word-wrap: normal;
                        }

                        code {
                        border-radius: 0.1875em;
                        font-size: 10pt;
                        padding: 0.2em 0.4em;
                        margin: 0;
                        }

                        pre {
                        margin-top: 0;
                        margin-bottom: 0;
                        font-size: 8pt;
                        }

                        pre>code {
                        padding: 0;
                        margin: 0;
                        font-size: 12pt;
                        word-break: normal;
                        white-space: pre;
                        background: transparent;
                        border: 0;
                        }

                        .highlight {
                        margin-bottom: 1em;
                        }

                        .highlight pre {
                        margin-bottom: 0;
                        word-break: normal;
                        }

                        .highlight pre,
                        pre {
                        padding: 1em;
                        overflow: auto;
                        font-size: 10pt;
                        line-height: 1.5;
                        background-color: var(--alt-background-color);
                        border-radius: 0.1875em;
                        }

                        pre code {
                        background-color: transparent;
                        border: 0;
                        display: inline;
                        padding: 0;
                        margin: 0;
                        overflow: visible;
                        line-height: inherit;
                        word-wrap: normal;
                        }

                        .pl-0 {
                        padding-left: 0 !important;
                        }

                        .pl-1 {
                        padding-left: 0.25em !important;
                        }

                        .pl-2 {
                        padding-left: 0.5em !important;
                        }

                        .pl-3 {
                        padding-left: 1em !important;
                        }

                        .pl-4 {
                        padding-left: 1.5em !important;
                        }

                        .pl-5 {
                        padding-left: 2em !important;
                        }

                        .pl-6 {
                        padding-left: 2.5em !important;
                        }

                        .markdown-body::before {
                        display: table;
                        content: "";
                        }

                        .markdown-body::after {
                        display: table;
                        clear: both;
                        content: "";
                        }

                        .markdown-body>*:first-child {
                        margin-top: 0 !important;
                        }

                        .markdown-body>*:last-child {
                        margin-bottom: 0 !important;
                        }

                        a:not([href]) {
                        color: inherit;
                        text-decoration: none;
                        }

                        .anchor {
                        float: left;
                        padding-right: 0.25em;
                        margin-left: -1.25em;
                        line-height: 1;
                        }

                        .anchor:focus {
                        outline: none;
                        }

                        p,
                        blockquote,
                        ul,
                        ol,
                        dl,
                        table,
                        pre {
                        margin-top: 0;
                        margin-bottom: 1em;
                        }

                        blockquote {
                        padding: 0 1em;
                        color: var(--blockquote-text-color);
                        border-left: 0.25em solid var(--blockquote-border-color);
                        }

                        blockquote>:first-child {
                        margin-top: 0;
                        }

                        blockquote>:last-child {
                        margin-bottom: 0;
                        }

                        kbd {
                        display: inline-block;
                        padding: 0.1875em 0.3125em;
                        font-size: 8pt;
                        line-height: 1;
                        color: var(--kbd-text-color);
                        vertical-align: middle;
                        background-color: var(--kbd-background-color);
                        border: solid 1px var(--kbd-border-color);
                        border-bottom-color: var(--kbd-shadow-color);
                        border-radius: 3px;
                        box-shadow: inset 0 -1px 0 var(--kbd-shadow-color);;
                        }

                        h1,
                        h2,
                        h3,
                        h4,
                        h5,
                        h6 {
                        margin-top: 1.5em;
                        margin-bottom: 1em;
                        font-weight: 600;
                        line-height: 1.25;
                        }

                        h1:hover .anchor,
                        h2:hover .anchor,
                        h3:hover .anchor,
                        h4:hover .anchor,
                        h5:hover .anchor,
                        h6:hover .anchor {
                        text-decoration: none;
                        }

                        h1 {
                        padding-bottom: 0.3em;
                        font-size: 24pt;
                        border-bottom: 1px solid var(--header-border-color);
                        }

                        h2 {
                        padding-bottom: 0.3em;
                        font-size: 18pt;
                        border-bottom: 1px solid var(--header-border-color);
                        }

                        h3 {
                        font-size: 14pt;
                        }

                        h4 {
                        font-size: 12pt;
                        }

                        h5 {
                        font-size: 10pt;
                        }

                        h6 {
                        font-size: 8pt;
                        opacity: 0.67;
                        }

                        ul,
                        ol {
                        padding-left: 2em;
                        }

                        ul ul,
                        ul ol,
                        ol ol,
                        ol ul {
                        margin-top: 0;
                        margin-bottom: 0;
                        }

                        li {
                        overflow-wrap: break-word;
                        }

                        li>p {
                        margin-top: 1em;
                        }

                        li+li {
                        margin-top: 0.25em;
                        }

                        dl {
                        padding: 0;
                        }

                        dl dt {
                        padding: 0;
                        margin-top: 1em;
                        font-size: 12pt;
                        font-style: italic;
                        font-weight: 600;
                        }

                        dl dd {
                        padding: 0 1em;
                        margin-bottom: 1em;
                        }

                        table {
                        display: block;
                        width: 100%;
                        overflow: auto;
                        }

                        table th {
                        font-weight: 600;
                        }

                        table th,
                        table td {
                        padding: 0.375em 0.8125em;
                        border: 1px solid var(--table-td-border-color);
                        }

                        table tr {
                        background-color: var(--background-color);
                        border-top: 1px solid var(--table-tr-border-color);
                        }

                        table tr:nth-child(2n) {
                        background-color: var(--alt-background-color);
                        }

                        img {
                        max-width: 100%;
                        box-sizing: content-box;
                        }

                        img[align=right] {
                        padding-left: 1.25em;
                        }

                        img[align=left] {
                        padding-right: 1.25em;
                        }

                        .task-list-item {
                        list-style-type: none;
                        }

                        .task-list-item+.task-list-item {
                        margin-top: 0.1875em;
                        }

                        .task-list-item input {
                        margin: 0 0.2em 0.25em -1.6em;
                        vertical-align: middle;
                        }
                    </style>

                    <script src="https://polyfill.io/v3/polyfill.min.js?features=es6"></script>
                    <script src="https://cdn.jsdelivr.net/npm/mathjax@3/es5/tex-chtml.js"></script>

                    <script>
                    window.MathJax = {
                        tex: {
                            inlineMath: [ ["\\(","\\)"] ],
                            displayMath: [ ["\\[","\\]"] ],
                            processEscapes: true,
                            processEnvironments: true
                        },
                        options: {
                            ignoreHtmlClass: ".*",
                            processHtmlClass: "arithmatex"
                        }
                        };
                    </script>

                </head>
                <body>
                    {response}
                </body>
            </html>
            """

            ADWAITA_STYLE = """:root {
                            --text-color: rgba(0, 0, 0, 0.8);
                            --background-color: #ffffff;
                            --alt-background-color: #ebebeb;
                            --link-color: #1c71d8;
                            --blockquote-text-color: rgba(0, 0, 0, 0.8);
                            --blockquote-border-color: #dbdbdb;
                            --header-border-color: #dbdbdb;
                            --hr-background-color: #dbdbdb;
                            --table-tr-border-color: #dcdcdc;
                            --table-td-border-color: #dcdcdc;
                            --kbd-text-color: rgba(0, 0, 0, 0.8);
                            --kbd-background-color: #ffffff;
                            --kbd-border-color: #dcdcdc;
                            --kbd-shadow-color: #dddddd;
                        }

                        @media (prefers-color-scheme: dark) {
                            :root {
                                --text-color: #ffffff;
                                --background-color: #363636;
                                --alt-background-color: #4a4a4a;
                                --link-color: #78aeed;
                                --blockquote-text-color: #ffffff;
                                --blockquote-border-color: #454545;
                                --header-border-color: #454545;
                                --hr-background-color: #505050;
                                --table-tr-border-color: #6e6e6e;
                                --table-td-border-color: #6e6e6e;
                                --kbd-text-color: #ffffff;
                                --kbd-background-color: #4a4a4a;
                                --kbd-border-color: #6e6e6e;
                                --kbd-shadow-color: #575757;
                            }
                        }"""
            CUSTOM_STYLE = """
                --text-color: {view_fg_color};
                --background-color: {view_bg_color};
                --alt-background-color: {view_bg_color};
                --link-color: {accent_fg_color};
                --blockquote-text-color: {card_fg_color};
                --blockquote-border-color: {card_bg_color};
                --header-border-color: {headerbar_border_color};
                --hr-background-color: {headerbar_bg_color};
                --table-tr-border-color: {headerbar_border_color};
                --table-td-border-color: {headerbar_border_color};
                --kbd-text-color: #4e585e;
                --kbd-background-color: #f1f1f1;
                --kbd-border-color: #bdc1c6;
                --kbd-shadow-color: #8c939a;
            """
            DARK_CUSTOM_STYLE = """
                --text-color: {view_fg_color};
                --background-color: {view_bg_color};
                --alt-background-color: {view_bg_color};
                --link-color: {accent_fg_color};
                --blockquote-text-color: {card_fg_color};
                --blockquote-border-color: {card_bg_color};
                --header-border-color: {headerbar_border_color};
                --hr-background-color: {headerbar_bg_color};
                --table-tr-border-color: {headerbar_border_color};
                --table-td-border-color: {headerbar_border_color};
                --kbd-text-color: #ffffff;
                --kbd-background-color: #4a4a4a;
                --kbd-border-color: #1f1f1f;
                --kbd-shadow-color: #1e1e1e;
            """

            if os.path.exists(os.path.expanduser("~/.config/gtk-4.0/gtk.css")):
                self.use_theme = True
                variables, palette, css = self.parse_css(os.path.expanduser("~/.config/gtk-4.0/gtk.css"))
                variables["card_fg_color"] = variables.get("card_fg_color", "#2e3436")
                variables["view_fg_color"] = variables.get("view_fg_color", "#2e3436")
                variables["dark_3"] = variables.get("dark_3", "#3d3846")
                variables["card_bg_color"] = variables.get("card_bg_color", "#f6f5f4")
                variables["view_bg_color"] = variables.get("view_bg_color", "#edeeef")
                variables["accent_fg_color"] = variables.get("accent_fg_color", "#0d71de")
                variables["headerbar_border_color"] = variables.get("headerbar_border_color", "#e1e2e4")
                variables["headerbar_bg_color"] = variables.get("headerbar_bg_color", "#d8dadd")
                theme_css = ":root {\n" + CUSTOM_STYLE.format(**variables) + " \n}\n" + "@media (prefers-color-scheme: dark) {\n:root {\n" + \
                     DARK_CUSTOM_STYLE.format(**variables) + "\n}\n}\n" 
                print(theme_css)
                theme_css += css
            else:
                self.use_theme = False
                theme_css = ADWAITA_STYLE
            self.show(TEMPLATE.replace("{response}", response).replace("{theme_css}", theme_css), Step.LOAD_WEBVIEW)
        else:
            self.win.bot_text_view.get_buffer().props.text = response

    def on_ask_action(self, widget, _):
        """Callback for the app.ask action."""

        self.win.banner.set_revealed(False)

        for key, an in self.annoucements.items():
            if an["provider"] == self.provider:
                if an["status"] == "open":
                    match an["action"]:
                        case "error": # show an error banner with a button to open settings
                            self.win.banner.set_title(an["message"])
                            self.win.banner.props.button_label = "Open settings"
                            self.win.banner.connect("button-clicked", self.on_preferences_action)
                            self.win.banner.set_revealed(True)
                        case _:
                            self.win.banner.set_title(an["message"])
                            self.win.banner.set_revealed(True)
                del self.annoucements[key]
                break

        self.prompt = self.win.prompt_text_view.get_buffer().props.text.strip()

        if self.prompt == "" or self.prompt is None:  # empty prompt
            return
        else:
            self.win.spinner = Gtk.Spinner()
            self.win.spinner.set_margin_top(8)
            self.win.spinner.set_margin_bottom(8)
            self.win.spinner.set_margin_start(8)
            self.win.spinner.set_margin_end(8)
            self.win.ask_button.set_child(self.win.spinner)
            self.win.spinner.start()
            self.win.stop_button.set_visible(True)

            def thread_run():
                try:
                    response = self.providers[self.provider].ask(self.prompt)
                except GLib.Error as e:
                    response = e.message
                except KeyError:
                    del self.providers[self.provider]
                GLib.idle_add(cleanup, response)

            def cleanup(response):
                self.win.spinner.stop()
                self.win.ask_button.set_icon_name("paper-plane-symbolic")
                self.win.stop_button.set_visible(False)
                GLib.idle_add(self.update_response, response)
                self.t.join()
                if self.clear_after_send:
                    self.win.prompt_text_view.get_buffer().set_text("")

            self.t = KillableThread(target=thread_run)
            self.t.start()

    def on_stop_action(self, widget, _):
        """Callback for the app.stop action."""
        self.win.spinner.stop()
        self.win.ask_button.set_visible(True)
        self.win.wait_button.set_visible(False)
        self.win.stop_button.set_visible(False)
        self.t.kill()
        self.t.join()

    # def on_speak_action(self, widget, _):
    #     """Callback for the app.speak action."""
    #     print("app.speak action activated")
    #
    #     try:
    #
    #         with NamedTemporaryFile() as file_to_play:
    #
    #             tts = gTTS(self.win.bot_text_view.get_buffer().props.text)
    #             tts.write_to_fp(file_to_play)
    #             file_to_play.seek(0)
    #             self._play_audio(file_to_play.name)
    #     except Exception as exc:
    #         print(exc)
    #
    # def _play_audio(self, path):
    #     uri = "file://" + path
    #     self.player.set_property("uri", uri)
    #     self.pipeline.add(self.player)
    #     self.pipeline.set_state(Gst.State.PLAYING)
    #     self.player.set_state(Gst.State.PLAYING)
    #
    # def on_listen_action(self, widget, _):
    #     """Callback for the app.listen action."""
    #     print("app.listen action activated")

    def create_action(self, name, callback, shortcuts=None):
        """Add an application action.

        Args:
            name: the name of the action
            callback: the function to be called when the action is
              activated
            shortcuts: an optional list of accelerators
        """
        action = Gio.SimpleAction.new(name, None)
        action.connect("activate", callback)
        self.add_action(action)
        if shortcuts:
            self.set_accels_for_action(f"app.{name}", shortcuts)

    def create_stateful_action(self, name, parameter_type, initial_state, callback, shortcuts=None):
        """Add a stateful application action."""

        action = Gio.SimpleAction.new_stateful(
            name, parameter_type, initial_state)
        action.connect("activate", callback)
        self.add_action(action)
        if shortcuts:
            self.parent.set_accels_for_action(f"app.{name}", shortcuts)


def main(version):
    """The application's entry point."""
    app = BavarderApplication()
    return app.run(sys.argv)