import os
from webpicdownloader.controller.Frames import Frames


class MainController:
    """
        Controller - MainController

    This controller manages all the main interaction, change of windows,
    dialogs, stop... It is the main controller.

    @author     Jérémi Nihart / EndMove
    @link       https://git.endmove.eu/EndMove/WebPicDownloader
    @version    1.0.0
    @since      2022-08-30
    """
    # Variables
    __config: dict = None
    __view = None
    __quite_event_subscribers: list = None

    # Constructor
    def __init__(self, config: dict) -> None:
        """
            Constructor

        * :config: -> The application configuration (a dictionary).
        """
        # Setup variables
        self.__config = config
        self.__quite_event_subscribers = []

    # START View methods
    def set_view(self, view) -> None:
        """
            [function for view]
        => Allow to define the controller view.

        * :view: -> The view that this controller manage and setup it.
        """
        self.__view = view
        view.set_window_title(self.get_config('app_name'))

    def on_open_folder(self) -> None:
        """
            [event function for view]
        => Event launch when you ask to open the current folder.
        """
        os.startfile(self.get_config('app_folder'))  # Open the file explorer on working dir

    def on_quite(self) -> None:
        """
            [event function for view]
        => Event launch when you ask to quit the program. This event is propagated
        to the subscribers, they can eventually cancel the event
        """
        for callback in self.__quite_event_subscribers:
            if callback():
                return
        self.__view.close_window()  # End the program

    def on_check_for_update(self) -> None:
        """
            [event function for view]
        => Event launched when a check for available updates is requested.
        """
        # TODO write the function
        self.show_information_dialog(self.get_config('app_name'), "Oupss, this functionality isn't available yet!\nTry it again later.")

    def on_about(self) -> None:
        """
            [event function for view]
        => Event launched when a request for more information arise.
        """
        self.change_frame(Frames.INFO)
    # END View methods

    # START Controller methods
    def change_frame(self, frame: Frames) -> None:
        """
            [function for controller]
        => Allows you to request a frame change in the main window.

        * :frame: -> The frame we want to display on the window instead of the current frame.
        """
        self.__view.show_frame(frame)

    def get_config(self, name: str) -> str|int:
        """
            [function for controller]
        => Allows controllers to access the application's configuration.

        * :name: -> The name of the configuration parameter for which we want to access the configured value.
        """
        if self.__config.get(name):
            return self.__config.get(name)
        else:
            raise ValueError("Unable to find a configuration with this name")

    def show_question_dialog(self, title: str='title', message: str='question?', icon: str='question') -> bool:
        """
            [function for controller]
        => Ask a question to the user and block until he answers with yes or no.

        * :title: -> Title of the dialogue.
        * :message: -> Message of the dialogue.
        * :icon: -> Icon of the dialogue
        """
        return self.__view.show_question_dialog(title, message, icon)

    def show_information_dialog(self, title: str='title', message: str='informations!', icon: str='info') -> bool:
        """
            [function for controller]
        => Display a pop-up information dialog to the user.

        * :title: -> Title of the dialogue.
        * :message: -> Message of the dialogue.
        * :icon: -> Icon of the dialogue
        """
        return self.__view.show_information_dialog(title, message, icon)
    # END Controller methods

    # START Controller events
    def subscribe_to_quite_event(self, callback) -> None:
        """
            [function for controller]
        => Subscription function allowing to be warned if a request to quit occurs.
        In the case where the callback function returns False the process continues
        but if the callback returns True the process is aborted.

        * :callback: -> Callback function that will be called when a request to exit occurs.
        """
        self.__quite_event_subscribers.append(callback)
    # END Controller events