# This is a sample commands.py.  You can add your own commands here.
#
# Please refer to commands_full.py for all the default commands and a complete
# documentation.  Do NOT add them all here, or you may end up with defunct
# commands when upgrading ranger.

# A simple command for demonstration purposes follows.
# -----------------------------------------------------------------------------

from __future__ import (absolute_import, division, print_function)

# You can import any python module as needed.
import os

# You always need to import ranger.api.commands here to get the Command class:
from ranger.api.commands import Command


# Any class that is a subclass of "Command" will be integrated into ranger as a
# command.  Try typing ":my_edit<ENTER>" in ranger!
# class my_edit(Command):
    # # The so-called doc-string of the class will be visible in the built-in
    # # help that is accessible by typing "?c" inside ranger.
    # """:my_edit <filename>

    # A sample command for demonstration purposes that opens a file in an editor.
    # """

    # # The execute method is called when you run this command in ranger.
    # def execute(self):
        # # self.arg(1) is the first (space-separated) argument to the function.
        # # This way you can write ":my_edit somefilename<ENTER>".
        # if self.arg(1):
            # # self.rest(1) contains self.arg(1) and everything that follows
            # target_filename = self.rest(1)
        # else:
            # # self.fm is a ranger.core.filemanager.FileManager object and gives
            # # you access to internals of ranger.
            # # self.fm.thisfile is a ranger.container.file.File object and is a
            # # reference to the currently selected file.
            # target_filename = self.fm.thisfile.path

        # # This is a generic function to print text in ranger.
        # self.fm.notify("Let's edit the file " + target_filename + "!")

        # # Using bad=True in fm.notify allows you to print error messages:
        # if not os.path.exists(target_filename):
            # self.fm.notify("The given file does not exist!", bad=True)
            # return

        # # This executes a function from ranger.core.actions, a module with a
        # # variety of subroutines that can help you construct commands.
        # # Check out the source, or run "pydoc ranger.core.actions" for a list.
        # self.fm.edit_file(target_filename)

    # # The tab method is called when you press tab, and should return a list of
    # # suggestions that the user will tab through.
    # # tabnum is 1 for <TAB> and -1 for <S-TAB> by default
    # def tab(self, tabnum):
        # # This is a generic tab-completion function that iterates through the
        # # content of the current directory.
        # return self._tab_directory_content()

class mkcd(Command):
    """
    :mkcd <dirname>

    Creates a directory with the name <dirname> and enters it.
    """

    def execute(self):
        from os.path import join, expanduser, lexists
        from os import makedirs
        import re

        dirname = join(self.fm.thisdir.path, expanduser(self.rest(1)))
        if not lexists(dirname):
            makedirs(dirname)

            match = re.search('^/|^~[^/]*/', dirname)
            if match:
                self.fm.cd(match.group(0))
                dirname = dirname[match.end(0):]

            for m in re.finditer('[^/]+', dirname):
                s = m.group(0)
                if s == '..' or (s.startswith('.') and not self.fm.settings['show_hidden']):
                    self.fm.cd(s)
                else:
                    ## We force ranger to load content before calling `scout`.
                    self.fm.thisdir.load_content(schedule=False)
                    self.fm.execute_console('scout -ae ^{}$'.format(s))
        else:
            self.fm.notify("file/directory exists!", bad=True)

class up(Command):
    def execute(self):
        if self.arg(1):
            scpcmd = ["scp", "-r"]
            scpcmd.extend([f.realpath for f in self.fm.thistab.get_selection()])
            scpcmd.append(self.arg(1))
            self.fm.execute_command(scpcmd)
            self.fm.notify("Uploaded!")


    def tab(self, tabnum):
        import os.path
        try:
            import paramiko
        except ImportError:
            """paramiko not installed"""
            return

        try:
            with open(os.path.expanduser("~/.ssh/config")) as file:
                paraconf = paramiko.SSHConfig()
                paraconf.parse(file)
        except IOError:
            """cant open ssh config"""
            return

        hosts = sorted(list(paraconf.get_hostnames()))
        # remove any wildcard host settings since they're not real servers
        hosts.remove("*")
        query = self.arg(1) or ''
        matching_hosts = []
        for host in hosts:
            if host.startswith(query):
                matching_hosts.append(host)
        return (self.start(1) + host + ":" for host in matching_hosts)