# This file is part of ranger, the console file manager.
# License: GNU GPL version 3, see the file "AUTHORS" for details.

"""The File Manager, putting the pieces together"""

from __future__ import (absolute_import, division, print_function)

import mimetypes
import os.path
import os
import pwd
import signal
import socket
import stat
import sys
from collections import deque
from io import open
from subprocess import Popen
from time import time

import ranger.api
from ranger.container import settings
from ranger.container.bookmarks import Bookmarks
from ranger.container.directory import Directory
from ranger.container.tags import Tags, TagsDummy
from ranger.core.actions import Actions
from ranger.core.loader import Loader
from ranger.core.metadata import MetadataManager
from ranger.core.runner import Runner
from ranger.core.tab import Tab
from ranger.ext import logutils
from ranger.ext.img_display import get_image_displayer
from ranger.ext.posix_signals import call_signal_handler, delay_signal
from ranger.ext.rifle import Rifle
from ranger.ext.signals import SignalDispatcher
from ranger.gui.ui import UI


class ProcessSet(object):

    def __init__(self):
        self.processes = set()
        self.ui = set()

    def add(self, process, toggle_ui=False):
        self.processes.add(process)
        if toggle_ui:
            self.ui.add(process)

    def remove(self, process):
        self.processes.remove(process)
        try:
            self.ui.remove(process)
        except KeyError:
            pass

    def spawn(self, *popen_args, **spawn_kws):
        popen_kws = spawn_kws.copy()
        toggle_ui = popen_kws.pop('toggle_ui', False)
        process = None
        # to avoid breaking the terminal, don't handle certain signals
        # until the process is in the set
        with delay_signal(signal.SIGTSTP, should_delay=toggle_ui):
            # pylint: disable=consider-using-with
            process = Popen(*popen_args, **popen_kws)
            self.add(process, toggle_ui)
        return process

    def __iter__(self):
        return iter(self.processes)

    def __bool__(self):
        return bool(self.processes)


class FM(Actions,  # pylint: disable=too-many-instance-attributes
         SignalDispatcher):
    input_blocked = False
    input_blocked_until = 0
    mode = 'normal'  # either 'normal' or 'visual'.
    search_method = 'ctime'

    _previous_selection = None
    _visual_reverse = False
    _visual_pos_start = None
    _visual_move_cycles = None

    def __init__(self, ui=None, bookmarks=None, tags=None, paths=None):
        """Initialize FM."""
        Actions.__init__(self)
        SignalDispatcher.__init__(self)
        self.ui = ui if ui is not None else UI()
        self.start_paths = paths if paths is not None else ['.']
        self.directories = {}
        self.bookmarks = bookmarks
        self.current_tab = 1
        self.tabs = {}
        self.tags = tags
        self.restorable_tabs = deque([], ranger.MAX_RESTORABLE_TABS)
        self.previews = {}
        self.default_linemodes = deque()
        self.loader = Loader()
        self.copy_buffer = set()
        self.do_cut = False
        self.metadata = MetadataManager()
        self.image_displayer = None
        self.run = None
        self.rifle = None
        self.thistab = None
        self.zombies = ProcessSet()

        try:
            self.username = pwd.getpwuid(os.geteuid()).pw_name
        except KeyError:
            self.username = 'uid:' + str(os.geteuid())
        self.hostname = socket.gethostname()
        self.home_path = os.path.expanduser('~')

        if not mimetypes.inited:
            extra_files = [self.relpath('data/mime.types'), os.path.expanduser("~/.mime.types")]
            mimetypes.init(mimetypes.knownfiles + extra_files)
        self.mimetypes = mimetypes

    def initialize(self):  # pylint: disable=too-many-statements
        """If ui/bookmarks are None, they will be initialized here."""

        self.tabs = dict((n + 1, Tab(path)) for n, path in enumerate(self.start_paths))
        tab_list = self.get_tab_list()
        if tab_list:
            self.current_tab = tab_list[0]
            self.thistab = self.tabs[self.current_tab]
        else:
            self.current_tab = 1
            self.tabs[self.current_tab] = self.thistab = Tab('.')

        if not ranger.args.clean and os.path.isfile(self.confpath('rifle.conf')):
            rifleconf = self.confpath('rifle.conf')
        else:
            rifleconf = self.relpath('config/rifle.conf')
        self.rifle = Rifle(rifleconf)
        self.rifle.reload_config()

        def set_image_displayer():
            if self.image_displayer:
                self.image_displayer.quit()
            self.image_displayer = get_image_displayer(self.settings.preview_images_method)
        set_image_displayer()
        self.settings.signal_bind('setopt.preview_images_method', set_image_displayer,
                                  priority=settings.SIGNAL_PRIORITY_AFTER_SYNC)

        self.settings.signal_bind(
            'setopt.preview_images',
            lambda signal: signal.fm.previews.clear(),
        )

        if ranger.args.clean:
            self.tags = TagsDummy("")
        elif self.tags is None:
            self.tags = Tags(self.datapath('tagged'))

        if self.bookmarks is None:
            if ranger.args.clean:
                bookmarkfile = None
            else:
                bookmarkfile = self.datapath('bookmarks')
            self.bookmarks = Bookmarks(
                bookmarkfile=bookmarkfile,
                bookmarktype=Directory,
                autosave=self.settings.autosave_bookmarks)
            self.bookmarks.load()
            self.bookmarks.enable_saving_backtick_bookmark(
                self.settings.save_backtick_bookmark)

        self.ui.setup_curses()
        self.ui.initialize()

        self.rifle.hook_before_executing = lambda a, b, flags: \
            self.ui.suspend() if 'f' not in flags else None
        self.rifle.hook_after_executing = lambda a, b, flags: \
            self.ui.initialize() if 'f' not in flags else None

        self.rifle.hook_process_open = lambda *popen_args, **popen_kws: \
            self.zombies.spawn(*popen_args, toggle_ui=True, **popen_kws)

        old_process_exit_hook = self.rifle.hook_process_exit

        def hook_process_exit(process, cmd):
            self.zombies.remove(process)
            return old_process_exit_hook(process, cmd)

        self.rifle.hook_process_exit = hook_process_exit

        # By default, Ncurses installs a signal handler for SIGTSTP
        # (when you hit Ctrl-Z). It will, among other things, switch
        # between the shell terminal mode and the curses terminal mode
        # as necessary, when the process has to suspend or resume.
        #
        # But at the time we receive SIGTSTP, we may be executing
        # a subprocess that will also modify the terminal mode
        # in response to the SIGTSTP signal, at the same time as FM.
        # This can lead to a race condition where both FM and the
        # subprocess(es) concurrently modify the terminal mode,
        # resulting in visual glitches and/or an unusable terminal.
        #
        # So instead of relying on the default curses signal handler,
        # we implement a SIGTSTP signal handler that will only switch
        # terminal modes if a subprocess isn't in control of the terminal.
        #
        # Python's `signal` module is not aware of any signals installed
        # by C libraries such as Ncurses, so the new signal handler won't
        # invoke any existing SIGTSTP signal handlers.
        def fm_owns_terminal_mode():
            # Maintenance note: everything that may spawn subprocesses
            # that would modify the terminal mode, must be checked here!
            if self.zombies.ui:
                for zombie in tuple(self.zombies.ui):
                    if zombie.poll() is None:
                        # there is a live UI process
                        return False
            return True

        def sigtstp_handler(signum, frame):
            # sigtstp_handler may be invoked many times
            # before we regain control of the terminal
            # and should be idempotent
            if fm_owns_terminal_mode():
                self.ui.suspend()
            # process is suspended
            call_signal_handler(signal.SIG_DFL, signum, frame)
            # process resumes
            if fm_owns_terminal_mode():
                self.ui.initialize()

        signal.signal(signal.SIGTSTP, sigtstp_handler)

        self.rifle.hook_logger = self.notify
        old_preprocessing_hook = self.rifle.hook_command_preprocessing

        # This hook allows image viewers to open all images in the current
        # directory, keeping the order of files the same as in ranger.
        # The requirements to use it are:
        # 1. set open_all_images to true
        # 2. ensure no files are marked
        # 3. call rifle with a command that starts with "sxiv " or similarly
        #    behaved image viewers
        def sxiv_workaround_hook(command):
            import re
            from ranger.ext.shell_escape import shell_quote

            if self.settings.open_all_images and \
                    not self.thisdir.marked_items and \
                    re.match(r'^(feh|n?sxiv|imv|pqiv) ', command):

                images = [f.relative_path for f in self.thisdir.files if f.image]
                escaped_filenames = " ".join(shell_quote(f) for f in images if "\x00" not in f)

                if images and self.thisfile.relative_path in images and \
                        "$@" in command:
                    new_command = None

                    if command[0:5] == 'sxiv ' or command[0:6] == 'nsxiv ':
                        number = images.index(self.thisfile.relative_path) + 1
                        new_command = command.replace("sxiv ", "sxiv -n %d " % number, 1)

                    if command[0:4] == 'feh ':
                        new_command = command.replace(
                            "feh ",
                            "feh --start-at %s " % shell_quote(self.thisfile.relative_path),
                            1,
                        )

                    if command[0:4] == 'imv ':
                        number = images.index(self.thisfile.relative_path) + 1
                        new_command = command.replace("imv ", "imv -n %d " % number, 1)

                    if command[0:5] == 'pqiv ':
                        number = images.index(self.thisfile.relative_path)
                        new_command = command.replace(
                            "pqiv ", "pqiv --action \"goto_file_byindex(%d)\" " % number, 1)

                    if new_command:
                        command = "set -- %s; %s" % (escaped_filenames, new_command)
            return old_preprocessing_hook(command)

        self.rifle.hook_command_preprocessing = sxiv_workaround_hook

        def mylogfunc(text):
            self.notify(text, bad=True)
        self.run = Runner(ui=self.ui, logfunc=mylogfunc, fm=self, zombies=self.zombies)

        self.settings.signal_bind(
            'setopt.metadata_deep_search',
            lambda signal: setattr(signal.fm.metadata, 'deep_search', signal.value)
        )
        self.settings.signal_bind(
            'setopt.save_backtick_bookmark',
            lambda signal: signal.fm.bookmarks.enable_saving_backtick_bookmark(signal.value)
        )

    def destroy(self):
        debug = ranger.args.debug
        if self.ui:
            try:
                self.ui.destroy()
            except Exception:  # pylint: disable=broad-except
                if debug:
                    raise
        if self.loader:
            try:
                self.loader.destroy()
            except Exception:  # pylint: disable=broad-except
                if debug:
                    raise

    @staticmethod
    def get_log():
        """Return the current log

        The log is returned as a generator over its entries' lines
        """
        for entry in logutils.QUEUE:
            for line in entry.splitlines():
                yield line

    def _get_thisfile(self):
        return self.thistab.thisfile

    def _set_thisfile(self, obj):
        self.thistab.thisfile = obj

    def _get_thisdir(self):
        return self.thistab.thisdir

    def _set_thisdir(self, obj):
        self.thistab.thisdir = obj

    thisfile = property(_get_thisfile, _set_thisfile)
    thisdir = property(_get_thisdir, _set_thisdir)

    def block_input(self, sec=0):
        self.input_blocked = sec != 0
        self.input_blocked_until = time() + sec

    def input_is_blocked(self):
        if self.input_blocked and time() > self.input_blocked_until:
            self.input_blocked = False
        return self.input_blocked

    def copy_config_files(self, which):
        if ranger.args.clean:
            sys.stderr.write("refusing to copy config files in clean mode\n")
            return
        import shutil
        from errno import EEXIST

        def copy(src, dest):
            if os.path.exists(self.confpath(dest)):
                sys.stderr.write("already exists: %s\n" % self.confpath(dest))
            else:
                sys.stderr.write("creating: %s\n" % self.confpath(dest))
                try:
                    os.makedirs(ranger.args.confdir)
                except OSError as err:
                    if err.errno != EEXIST:  # EEXIST means it already exists
                        print("This configuration directory could not be created:")
                        print(ranger.args.confdir)
                        print("To run ranger without the need for configuration")
                        print("files, use the --clean option.")
                        raise SystemExit
                try:
                    shutil.copy(self.relpath(src), self.confpath(dest))
                except OSError as ex:
                    sys.stderr.write("  ERROR: %s\n" % str(ex))
        if which in ('rifle', 'all'):
            copy('config/rifle.conf', 'rifle.conf')
        if which in ('commands', 'all'):
            copy('config/commands_sample.py', 'commands.py')
        if which in ('commands_full', 'all'):
            copy('config/commands.py', 'commands_full.py')
        if which in ('rc', 'all'):
            copy('config/rc.conf', 'rc.conf')
        if which in ('scope', 'all'):
            copy('data/scope.sh', 'scope.sh')
            os.chmod(self.confpath('scope.sh'),
                     os.stat(self.confpath('scope.sh')).st_mode | stat.S_IXUSR)
        if which in ('all', 'rifle', 'scope', 'commands', 'commands_full', 'rc'):
            sys.stderr.write("\n> Please note that configuration files may "
                             "change as ranger evolves.\n  It's completely up to you to "
                             "keep them up to date.\n")
            if os.environ.get('RANGER_LOAD_DEFAULT_RC', 'TRUE').upper() != 'FALSE':
                sys.stderr.write("\n> To stop ranger from loading "
                                 "\033[1mboth\033[0m the default and your custom rc.conf,\n"
                                 "  please set the environment variable "
                                 "\033[1mRANGER_LOAD_DEFAULT_RC\033[0m to "
                                 "\033[1mFALSE\033[0m.\n")
        else:
            sys.stderr.write("Unknown config file `%s'\n" % which)

    def confpath(self, *paths):
        """returns path to ranger's configuration directory"""
        if ranger.args.clean:
            self.notify("Accessed configuration directory in clean mode", bad=True)
            return None
        return os.path.join(ranger.args.confdir, *paths)

    def datapath(self, *paths):
        """returns path to ranger's data directory"""
        if ranger.args.clean:
            self.notify("Accessed data directory in clean mode", bad=True)
            return None
        path_compat = self.confpath(*paths)  # COMPAT
        if os.path.exists(path_compat):
            return path_compat
        return os.path.join(ranger.args.datadir, *paths)

    @staticmethod
    def relpath(*paths):
        """returns the path relative to rangers library directory"""
        return os.path.join(ranger.RANGERDIR, *paths)

    def get_directory(self, path, **dir_kwargs):
        """Get the directory object at the given path"""
        path = os.path.abspath(path)
        try:
            return self.directories[path]
        except KeyError:
            obj = Directory(path, **dir_kwargs)
            self.directories[path] = obj
            return obj

    @staticmethod
    def group_paths_by_dirname(paths):
        """
        Groups the paths into a dictionary with their dirnames as keys and a set of
        basenames as entries.
        """
        groups = {}
        for path in paths:
            abspath = os.path.abspath(os.path.expanduser(path))
            dirname, basename = os.path.split(abspath)
            groups.setdefault(dirname, set()).add(basename)
        return groups

    def get_filesystem_objects(self, paths):
        """
        Find FileSystemObjects corresponding to the paths if they are already in
        memory and load those that are not.
        """
        result = []
        # Grouping the files by dirname avoids the potentially quadratic running time of doing
        # a linear search in the directory for each entry name that is supposed to be deleted.
        groups = self.group_paths_by_dirname(paths)
        for dirname, basenames in groups.items():
            directory = self.fm.get_directory(dirname)
            directory.load_content_if_outdated()
            for entry in directory.files_all:
                if entry.basename in basenames:
                    result.append(entry)
                    basenames.remove(entry.basename)
            if basenames != set():
                # Abort the operation with an error message if there are entries
                # that weren't found.
                names = ', '.join(basenames)
                self.fm.notify('Error: No such file or directory: {0}'.format(
                    names), bad=True)
                return None
        return result

    def garbage_collect(
            self, age,
            tabs=None):  # tabs=None is for COMPATibility pylint: disable=unused-argument
        """Delete unused directory objects"""
        for key in tuple(self.directories):
            value = self.directories[key]
            if age != -1:
                if not value.is_older_than(age) \
                        or any(value in tab.pathway for tab in self.tabs.values()):
                    continue
            del self.directories[key]
            if value.is_directory:
                value.files = None
        self.settings.signal_garbage_collect()
        self.signal_garbage_collect()

    def loop(self):
        """The main loop of ranger.

        It consists of:
        1. reloading bookmarks if outdated
        2. letting the loader work
        3. drawing and finalizing ui
        4. reading and handling user input
        5. after X loops: collecting unused directory objects
        """

        self.enter_dir(self.thistab.path)

        # for faster lookup:
        ui = self.ui
        throbber = ui.throbber
        loader = self.loader
        zombies = self.zombies

        ranger.api.hook_ready(self)

        try:  # pylint: disable=too-many-nested-blocks
            while True:
                loader.work()
                if loader.has_work():
                    throbber(loader.status)
                else:
                    throbber(remove=True)

                ui.redraw()

                ui.set_load_mode(not loader.paused and loader.has_work())

                ui.draw_images()

                ui.handle_input()

                if zombies:
                    for zombie in tuple(zombies):
                        if zombie.poll() is not None:
                            zombies.remove(zombie)

                # gc_tick += 1
                # if gc_tick > ranger.TICKS_BEFORE_COLLECTING_GARBAGE:
                    # gc_tick = 0
                    # self.garbage_collect(ranger.TIME_BEFORE_FILE_BECOMES_GARBAGE)

        except KeyboardInterrupt:
            # this only happens in --debug mode. By default, interrupts
            # are caught in curses_interrupt_handler
            raise SystemExit

        finally:
            self.image_displayer.quit()
            if ranger.args.choosedir and self.thisdir and self.thisdir.path:
                # XXX: UnicodeEncodeError: 'utf-8' codec can't encode character
                # '\udcf6' in position 42: surrogates not allowed
                with open(ranger.args.choosedir, 'w', encoding="utf-8") as fobj:
                    fobj.write(self.thisdir.path)
            self.bookmarks.remember(self.thisdir)
            self.bookmarks.save()

            # Save tabs
            if not ranger.args.clean and self.settings.save_tabs_on_exit and len(self.tabs) > 1:
                with open(self.datapath('tabs'), 'a', encoding="utf-8") as fobj:
                    # Don't save active tab since launching ranger changes the active tab
                    fobj.write('\0'.join(v.path for t, v in self.tabs.items())
                               + '\0\0')
