#### Jade Application Kit
# * https://codesardine.github.io/Jade-Application-Kit
# * Vitor Lopes Copyright (c) 2016 - 2020
# * https://vitorlopes.me

import os
import re
import subprocess
from pathlib import Path
from PyQt5.QtWidgets import QApplication

register = {}


def create_desktop_entry(url, title, description, icon):
    entry_name = title.replace(" ", "-")
    filename = f"{entry_name}.desktop"
    user_entry_path = f"{str(Path.home())}/.local/share/applications"
    # system_entry_path = f"/usr/share/applications/{file}"

    template = f"""
# Created with JAK url:https://github.com/codesardine/Jade-Application-Kit
[Desktop Entry]
Type=Application
Version=1.0
Name={title}
Comment={description}
Path=/usr/bin
Exec=jak-cli --url {url} --title {title} --icon {icon} --online true
Icon={icon}
Terminal=false
Categories=Network;
""".strip()

    with open(f"{user_entry_path}/{filename}", 'w+') as file:
        file.write(template)
        print(f"Desktop entry created in:{user_entry_path}/{filename}")

    update_database = "update-desktop-database"
    if os.path.isfile(f"/usr/bin/{update_database}"):
        proc = subprocess.run(f"{update_database} {user_entry_path}", shell=True, check=True)
        if proc.returncode == 0:
            print("Database updated.")
    else:
        print("desktop-file-utils:Not installed\nDatabase not updated.")


def getScreenGeometry():
    return QApplication.instance().desktop().screenGeometry()


def bindings():
    environment_var = "JAK_PREFERRED_BINDING"
    try:
        preferred_bindings = os.environ[environment_var]
        return preferred_bindings
    except KeyError:
        user_config_path = f"{str(Path.home())}/.config/jak.conf"
        if os.path.isfile(user_config_path):
            config_file = user_config_path
        else:
            system_config_path = "/etc/jak.conf"
            config_file = system_config_path
        try:
            import configparser
            config = configparser.ConfigParser()
            config.read(config_file)
            preferred_bindings = config["bindings"][environment_var]
            return preferred_bindings
        except Exception as error:
            print(error)


def get_current_path():
    return str(Path('.').absolute())


def check_url_rules(request_type: str, url_request: str, url_rules: tuple) -> bool:
    """
    * Search logic for url rules, we can use regex or simple match the beginning of the domain.
    * :param request_type: WebWindowType
    * :return: function, checks against a list of urls
    """
    SCHEME = "https://"

    if request_type == "Block":
        url_rules=url_rules

    elif request_type == "WebBrowserTab":
        try:
            url_rules = url_rules["WebBrowserTab"]
        except KeyError:
            url_rules = ""

    elif request_type == "WebBrowserWindow":
        try:
            url_rules = url_rules["WebBrowserWindow"]
        except KeyError:
            url_rules = ""

    for rule in url_rules:
        pattern = re.compile(f"{SCHEME}{rule}")
        if url_request.startswith(f"{SCHEME}{rule}"):
            print(f"{SCHEME}{rule}:Method:startswith")
            return True
        elif re.search(pattern, url_request):
                print(f"{SCHEME}{rule}:Method:regex")
                return True
    return False


class Instance:
    """
    #### :Imports: from JAK.Utils import Instance
    Add object instances in a dictionary, it can be used to point
    to references we don,t want to be garbage collected, for usage later
    """

    @staticmethod
    def get_instances() -> dict:
        """
        * :Usage: Instance.get_instances()
        """
        return register

    @staticmethod
    def record(name: str, _type: object) -> None:
        """
        * :Usage: Instance.record("name", object)
        * Should only be used once per instance
        """
        register[name] = _type
        print(f"Registering ['{name}'] Instance")

    @staticmethod
    def retrieve(name: str) -> object or str:
        """
        * :Usage: Instance.retrieve("name")
        """
        try:
            return register[name]
        except KeyError:
            print(f"Instance: ['{name}'] Not Present, to add it use -> Instance.record(['{name}', object])")
            return ""

    @staticmethod
    def auto(name: str, _type: object) -> object:
        """
        * :Usage: Instance.auto("name", object)
        * Automatically detects if an instance is active with that name and retrieves it.
        If not present, creates it creates a new one and retrieves it.
        * Should only be used once per instance
        """
        try:
            return register[name]
        except KeyError:
            register[name] = _type
        finally:
            print(f"Registering and Retrieving ['{name}'] Instance")
            return register[name]


class JavaScript:
    """
    * Run javascript in the webview after load is complete Injects will be logged in the inspector
    * :Imports: from Jak.Utils import JavaScript
    * :Usage: JavaScript.log(msg)
    """
    @staticmethod
    def log(message: str) -> None:
        """
        * Outputs console.log() messages in the inspector
        * :param message: Log message
        """
        JavaScript.send(f"console.log('JAK log:{message}');")

    @staticmethod
    def css(styles: str, _type) -> None:
        """
        * Insert custom styles
        * :param styles: CSS -> a { color: red; }
        """
        javascript = f"""
             var style = document.createElement('style');
             style.type = 'text/css';
             style.classList.add('{_type}-custom-style');
             style.innerHTML = `{JavaScript._is_file_or_string(styles)}`;
             document.getElementsByTagName('head')[0].appendChild(style);
        """
        view = Instance.retrieve("view")
        view.page().loadFinished.connect(
            lambda: view.page().runJavaScript(javascript)
        )

    @staticmethod
    def alert(message: str) -> None:
        """
        * Triggers an alert message
        * :param message: your popcorn is ready enjoy
        """
        JavaScript.send(f"alert('{message}');")
        JavaScript.log(f"JAK Alert:[{message}]")

    @staticmethod
    def send(script: str) -> None:
        """
        * Send custom JavaScript
        """
        try:
            view = Instance.retrieve("view")
            view.page().runJavaScript(f"{JavaScript._is_file_or_string(script)}")
        except Exception as err:
            print(err)

    @staticmethod
    def inject(page, options: dict) -> None:
        if bindings() == "PyQt5":
            from PyQt5.QtWebEngineWidgets import QWebEngineScript
        else:
            from PySide2.QtWebEngineWidgets import QWebEngineScript

        script = QWebEngineScript()
        script.setName(options["name"])
        script.setWorldId(QWebEngineScript.MainWorld)
        script.setInjectionPoint(QWebEngineScript.DocumentCreation)
        script.setRunsOnSubFrames(True)
        script.setSourceCode(options["JavaScript"])
        print(f"Injecting JavaScript {options['name']}")
        page.profile().scripts().insert(script)

    @staticmethod
    def _is_file_or_string(script) -> str:
        """
        * Detect if is file or string, convert to string
        * :param script: file or string
        """
        if os.path.exists(script) and os.path.isfile(script):
            try:
                with open(script, "r") as file:
                    string = file.read()
                    return string
            except Exception as err:
                print(err)
        elif isinstance(script, str):
            return script
