import gi
import os
import copy
import re
import mtgsdk
import time

gi.require_version('Gtk', '3.0')
from gi.repository import Gtk, GObject, Pango
from typing import Type, Dict, List
from cardvault import handlers
from cardvault import util
from cardvault import database


class Application:
    # ---------------------------------Initialize the Application----------------------------------------------
    def __init__(self):
        # Load configuration file
        self.config = self.load_config()
        util.LOG_LEVEL = self.config["log_level"]
        util.log("Start using config file: '{}'".format(util.get_root_filename("config.json")), util.LogLevel.Info)

        self.ui = Gtk.Builder()
        self.ui.add_from_file(util.get_ui_filename("mainwindow.glade"))
        self.ui.add_from_file(util.get_ui_filename("overlays.glade"))
        self.ui.add_from_file(util.get_ui_filename("search.glade"))
        self.ui.add_from_file(util.get_ui_filename("library.glade"))
        self.ui.add_from_file(util.get_ui_filename("wants.glade"))
        self.ui.add_from_file(util.get_ui_filename("dialogs.glade"))

        self.current_page = None
        self.current_lib_tag = "Untagged"

        self.db = database.CardVaultDB(util.get_root_filename(util.DB_NAME))
        # Create database tables if they do not exist
        self.db.db_create()

        not_found = self.ui.get_object("pageNotFound")
        self.pages = {
            "search": self.ui.get_object("searchView"),
            "library": self.ui.get_object("libraryView"),
            "wants": self.ui.get_object("wantsView")
        }

        # Load data from cache path
        util.log("Loading image cache...", util.LogLevel.Info)
        self.image_cache = util.reload_image_cache(util.CACHE_PATH + "images/")
        self.precon_icons = util.reload_preconstructed_icons(util.CACHE_PATH + "icons/")
        self.mana_icons = util.load_mana_icons(os.path.dirname(__file__) + "/resources/mana/")

        self.library = Dict[str, Type[mtgsdk.Card]]
        self.tags = Dict[str, str]
        self.wants = Dict[str, List[Type[mtgsdk.Card]]]
        self.load_user_data()

        self.ui.get_object('statusbar_icon').set_from_icon_name(util.online_icons[self.is_online()],
                                                                Gtk.IconSize.BUTTON)
        self.ui.get_object('statusbar_icon').set_tooltip_text(util.online_tooltips[self.is_online()])

        self.handlers = handlers.Handlers(self)
        self.ui.connect_signals(self.handlers)

        self.ui.get_object("mainWindow").connect('delete-event', Gtk.main_quit)
        self.ui.get_object("mainWindow").show_all()
        self.push_status("Card Vault ready.")

        view_menu = self.ui.get_object("viewMenu")
        view = self.config["start_page"] if not self.config["start_page"] == "dynamic" else self.config["last_viewed"]
        start_page = [page for page in view_menu.get_children() if page.get_name() == view]
        start_page[0].activate()

        util.log("Launching Card Vault version {}".format(util.VERSION), util.LogLevel.Info)

        if self.config.get('first_run'):
            ref = '<a href="' + util.MANUAL_LOCATION + '">' + util.MANUAL_LOCATION + '</a>'
            s = "Welcome to Card Vault.\n\nIf you need help using the application please refer to the manual at\n{}\n\n" \
                "To increase search performance and to be able to search while offline it is advised to use the " \
                "offline mode.\nDo you want to start the download?".format(ref)
            response = self.show_dialog_yn("Welcome", s)
            if response == Gtk.ResponseType.YES:
                self.handlers.do_download_card_data(Gtk.MenuItem())
                self.config['first_run'] = False
                self.save_config()

    def push_status(self, msg):
        status_bar = self.ui.get_object("statusBar")
        status_bar.pop(0)
        status_bar.push(0, msg)

    def show_card_details(self, card):
        builder = Gtk.Builder()
        builder.add_from_file(util.get_ui_filename("detailswindow.glade"))
        builder.add_from_file(util.get_ui_filename("overlays.glade"))
        window = builder.get_object("cardDetails")
        window.set_title(card.get('name'))
        # Card Image
        container = builder.get_object("imageContainer")
        pixbuf = util.load_card_image(card, 63 * 5, 88 * 5, self.image_cache)
        image = Gtk.Image().new_from_pixbuf(pixbuf)
        container.add(image)
        # Name
        builder.get_object("cardName").set_text(card.get('name'))
        # Types
        supertypes = ""
        if card.get('subtypes'):
            supertypes = " - " + " ".join(card.get('subtypes'))
        types = " ".join(card.get('types')) + supertypes
        builder.get_object("cardTypes").set_text(types)
        # Rarity
        builder.get_object("cardRarity").set_text(card.get('rarity') or "")
        # Release
        builder.get_object("cardReleaseDate").set_text(card.get('release_date') or "")
        # Set
        builder.get_object("cardSet").set_text(card.get('set_name'))
        # Printings
        all_sets = self.get_all_sets()
        prints = [all_sets[set_name].get('name') for set_name in card.get('printings')]
        builder.get_object("cardPrintings").set_text(", ".join(prints))
        # Legalities
        grid = builder.get_object("legalitiesGrid")
        rows = 1
        for legality in card.get('legalities') or {}:
            date_label = Gtk.Label()
            date_label.set_halign(Gtk.Align.END)
            text_label = Gtk.Label()
            text_label.set_line_wrap_mode(Pango.WrapMode.WORD)
            text_label.set_line_wrap(True)
            text_label.set_halign(Gtk.Align.END)
            color = util.LEGALITY_COLORS[legality["legality"]]
            date_label.set_markup("<span fgcolor=\"" + color + "\">" + legality["format"] + ":" + "</span>")
            text_label.set_markup("<span fgcolor=\"" + color + "\">" + legality["legality"] + "</span>")
            grid.attach(date_label, 0, rows + 2, 1, 1)
            grid.attach(text_label, 1, rows + 2, 1, 1)

            rows += 1
        grid.show_all()

        # Rulings
        if card.get('rulings'):
            store = builder.get_object("rulesStore")
            for rule in card.get('rulings'):
                store.append([rule["date"], rule["text"]])
        else:
            builder.get_object("ruleBox").set_visible(False)

        window.show_all()

        def eval_key_pressed(widget, event):
            key, modifier = Gtk.accelerator_parse('Escape')
            keyval = event.keyval
            if keyval == key:
                window.destroy()

        window.connect("key-press-event", eval_key_pressed)

    def show_dialog_ync(self, title: str, message: str) -> Gtk.ResponseType:
        """Display a simple Yes/No Question dialog and return the result"""
        dialog = self.ui.get_object("ync_dialog")
        dialog.set_transient_for(self.ui.get_object("mainWindow"))
        dialog.set_title(title)
        self.ui.get_object("ync_label").set_markup(message)
        response = dialog.run()
        dialog.hide()
        return response

    def show_dialog_yn(self, title: str, message: str) -> Gtk.ResponseType:
        """Display a simple Yes/No Question dialog and return the result"""
        dialog = self.ui.get_object("yn_dialog")
        dialog.set_transient_for(self.ui.get_object("mainWindow"))
        dialog.set_title(title)
        self.ui.get_object("yn_label").set_markup(message)
        response = dialog.run()
        dialog.hide()
        return response

    def show_message(self, title, message):
        dialog = Gtk.MessageDialog(self.ui.get_object("mainWindow"), 0, Gtk.MessageType.INFO,
                                   Gtk.ButtonsType.OK, title)
        dialog.format_secondary_text(message)
        dialog.run()
        dialog.destroy()

    def show_name_enter_dialog(self, title: str, value: str) -> str:
        dialog = self.ui.get_object("nameEnterDialog")  # type: Gtk.Dialog
        dialog.set_transient_for(self.ui.get_object("mainWindow"))
        dialog.set_title(title)
        entry = self.ui.get_object("nameEnterEntry")
        entry.set_text(value)
        entry.grab_focus()

        result = dialog.run()
        dialog.hide()

        if result == Gtk.ResponseType.OK:
            return entry.get_text()
        else:
            return value

    def show_preferences_dialog(self):
        """Show a dialog to adjust user preferences"""
        dialog = self.ui.get_object("pref_dialog")  # type: Gtk.Dialog
        dialog.set_transient_for(self.ui.get_object("mainWindow"))

        store = Gtk.ListStore(str, str)
        for page in self.pages.keys():
            store.append([page.title(), page])
        store.append(["Continue where you left", "dynamic"])
        page_map = {"search": 0,
                    "library": 1,
                    "decks": 2,
                    "wants": 3,
                    "dynamic": 4}
        self.ui.get_object("pref_start_view_combo").set_model(store)
        self.ui.get_object("pref_start_view_combo").set_active(page_map[self.config["start_page"]])

        self.ui.get_object("pref_show_all_check").set_active(self.config["show_all_in_search"])

        result = dialog.run()
        dialog.hide()

        if not result == Gtk.ResponseType.OK:
            return

        tree_iter = self.ui.get_object("pref_start_view_combo").get_active_iter()
        value = self.ui.get_object("pref_start_view_combo").get_model().get_value(tree_iter, 1)
        self.config["start_page"] = value

        self.config["show_all_in_search"] = self.ui.get_object("pref_show_all_check").get_active()

        self.save_config()
        self.config = self.load_config()

    def unsaved_changes(self) -> bool:
        """Check if database is in transaction"""
        return self.db.db_unsaved_changes()

    def save_config(self):
        cf = util.get_root_filename("config.json")
        util.save_config(self.config, cf)

    @staticmethod
    def load_config() -> dict:
        configfile = util.get_root_filename("config.json")
        return util.parse_config(configfile, util.DEFAULT_CONFIG)

    def save_data(self):
        util.log("Saving Data to database", util.LogLevel.Info)
        start = time.time()
        self.db.db_save_changes()
        end = time.time()
        util.log("Finished in {}s".format(str(round(end - start, 3))), util.LogLevel.Info)
        self.push_status("All data saved.")
        pass

    def load_user_data(self):
        util.log("Loading User Data from form '{}'".format(util.get_root_filename(util.DB_NAME)), util.LogLevel.Info)
        start = time.time()
        self.library = self.db.lib_get_all()
        self.tags = self.db.tag_get_all()
        self.wants = self.db.wants_get_all()
        end = time.time()
        util.log("Finished in {}s".format(str(round(end - start, 3))), util.LogLevel.Info)
        self.push_status("All data loaded.")

    def set_online(self, status: bool):
        """Online status of the application. True if no local card data is present."""
        self.ui.get_object('statusbar_icon').set_from_icon_name(util.online_icons[status], Gtk.IconSize.BUTTON)
        self.ui.get_object('statusbar_icon').set_tooltip_text(util.online_tooltips[status])
        self.config['local_db'] = not status
        self.save_config()

    def is_online(self) -> bool:
        """Return the online status of the application. True if no local data present."""
        return not self.config['local_db']

    def get_untagged_cards(self):
        lib = copy.copy(self.library)
        for ids in self.tags.values():
            for card_id in ids:
                try:
                    del lib[card_id]
                except KeyError:
                    pass
        return lib

    def get_tagged_cards(self, tag):
        if not tag:
            return self.library
        else:
            lib = {}
            for card_id in self.tags[tag]:
                lib[card_id] = self.library[card_id]
            return lib

    def tag_card(self, card, tag: str):
        """Add a card to tag"""
        list = self.tags[tag]
        list.append(card.multiverse_id)
        self.db.tag_card_add(tag, card.multiverse_id)

    def untag_card(self, card, tag: str):
        list = self.tags[tag]
        list.remove(card.multiverse_id)
        self.db.tag_card_remove(tag, card.multiverse_id)

    def tag_new(self, tag: str):
        self.tags[tag] = []
        self.db.tag_new(tag)
        util.log("Tag '" + tag + "' added", util.LogLevel.Info)
        self.push_status("Added Tag \"" + tag + "\"")

    def tag_delete(self, tag: str):
        del self.tags[tag]
        self.db.tag_delete(tag)
        util.log("Tag '" + tag + "' removed", util.LogLevel.Info)
        self.push_status("Removed Tag \"" + tag + "\"")

    def tag_rename(self, old, new):
        if old == new:
            return
        self.tags[new] = self.tags[old]
        del self.tags[old]
        self.db.tag_rename(old, new)
        util.log("Tag '" + old + "' renamed to '" + new + "'", util.LogLevel.Info)

    def get_wanted_card_ids(self) -> List[str]:
        all_ids = []
        for cards in self.wants.values():
            next_ids = [card['multiverse_id'] for card in cards]
            all_ids = list(set(all_ids) | set(next_ids))
        return all_ids

    def get_wanted_cards(self, list_name: str = None) -> Dict[str, Type[mtgsdk.Card]]:
        if list_name:
            out = {card.multiverse_id: card for card in self.wants[list_name]}
            return out

    def wants_new(self, name):
        """Add a empty wants list"""
        self.wants[name] = []
        self.db.wants_new(name)
        util.log("Want list  '" + name + "' created", util.LogLevel.Info)
        self.push_status("Created want list '" + name + "'")

    def wants_delete(self, name: str):
        """Delete an wants list an all cards in it"""
        del self.wants[name]
        self.db.wants_delete(name)
        util.log("Deleted Wants List '{}'".format(name), util.LogLevel.Info)
        self.push_status("Deleted Wants List '{}'".format(name))

    def wants_rename(self, old: str, new: str):
        if old == new:
            return
        self.wants[new] = self.wants[old]
        del self.wants[old]
        self.db.wants_rename(old, new)
        util.log("Want List '" + old + "' renamed to '" + new + "'", util.LogLevel.Info)

    def wants_card_add(self, list_name: str, card: 'mtgsdk.Card'):
        self.wants[list_name].append(card)
        self.db.wants_card_add(list_name, card.multiverse_id)
        util.log(card.name + " added to want list " + list_name, util.LogLevel.Info)

    def wants_card_remove(self, card: mtgsdk.Card, list: str):
        """Remove a card from a wants list"""
        l = self.wants[list]
        l.remove(card)
        self.db.wants_card_remove(list, card.multiverse_id)
        util.log("Removed '{}' from wants list '{}'".format(card.name, list), util.LogLevel.Info)

    def lib_card_add(self, card, tag=None):
        if tag is not None:
            self.tag_card(card, tag)
            self.db.tag_card_add(tag, card.multiverse_id)
        self.library[card.multiverse_id] = card
        self.db.lib_card_add(card)
        self.push_status(card.name + " added to library")

    def lib_card_add_bulk(self, cards: list, tag: str = None):
        for card in cards:
            if tag is not None:
                self.tag_card(card, tag)
                self.db.tag_card_add(tag, card.multiverse_id)
            self.lib_card_add(card, tag)
            self.db.lib_card_add(card)
        util.log("Added {} cards to library.".format(str(len(cards))), util.LogLevel.Info)
        self.push_status("Added {} cards to library.".format(str(len(cards))))

    def lib_card_remove(self, card):
        # Check if card is tagged
        is_tagged, tags = self.db.tag_card_check_tagged(card)
        if is_tagged:
            for tag in tags:
                self.tags[tag].remove(card.multiverse_id)
                self.db.tag_card_remove(tag, card.multiverse_id)

        del self.library[card.multiverse_id]
        self.db.lib_card_remove(card)
        util.log("Removed {} from library".format(card.name), util.LogLevel.Info)
        self.push_status(card.name + " removed from library")

    def db_override_user_data(self):
        """Called after import of user data. Overrides existing user data in database"""
        util.log("Clearing old user data", util.LogLevel.Info)
        self.db.db_clear_data_user()
        util.log("Attempt loading user data to database", util.LogLevel.Info)
        start = time.time()
        # Library
        for card in self.library.values():
            self.db.lib_card_add(card)
        # Tags
        for tag, card_ids in self.tags.items():
            self.db.tag_new(tag)
            for card_id in card_ids:
                self.db.tag_card_add(tag, card_id)
        # Wants
        for list_name, cards in self.wants.items():
            self.db.wants_new(list_name)
            for card in cards:
                self.db.wants_card_add(list_name, card.multiverse_id)
        end = time.time()
        util.log("Finished in {}s".format(str(round(end - start, 3))), util.LogLevel.Info)
        self.push_status("User data imported")

    def db_delete_card_data(self):
        """Called before before rebuilding local data storage"""
        util.log("Clearing local card data", util.LogLevel.Info)
        self.db.db_clear_data_card()
        self.set_online(True)
        util.log("Done", util.LogLevel.Info)

    def db_delete_user_data(self):
        """Delete all user data"""
        util.log("Clearing all user data", util.LogLevel.Info)
        self.db.db_clear_data_user()
        util.log("Done", util.LogLevel.Info)

    def get_all_sets(self) -> dict:
        if not self.is_online():
            out = {s['code']: s for s in self.db.set_get_all()}
        else:
            out = util.load_sets(util.get_root_filename('sets'))
        return out

    def get_mana_icons(self, mana_string):
        if not mana_string:
            util.log("No mana string provided", util.LogLevel.Info)
            return
        icon_list = re.findall("{(.*?)}", mana_string.replace("/", "-"))
        icon_name = "_".join(icon_list)
        try:
            icon = self.precon_icons[icon_name]
        except KeyError:
            icon = util.create_mana_icons(self.mana_icons, mana_string)
            self.precon_icons[icon_name] = icon
        return icon

    def filter_lib_func(self, model, iter, data):
        filter_text = self.ui.get_object("searchLibEntry").get_text()
        if filter_text == "":
            return True
        else:
            return filter_text.lower() in model[iter][1].lower()


def main():
    GObject.threads_init()
    Application()
    Gtk.main()