import os
import sublime
import sublime_plugin
import re
import logging
import errno

SETTINGS = [
    "alias",
    "default_initial",
    "use_cursor_text",
    "show_files",
    "show_path",
    "default_root",
    "default_path",
    "default_folder_index",
    "os_specific_alias",
    "ignore_case",
    "alias_root",
    "alias_path",
    "alias_folder_index",
    "debug",
    "auto_refresh_sidebar",
    "completion_type",
    "complete_single_entry",
    "use_folder_name",
    "relative_from_current",
    "default_extension"
]
VIEW_NAME = "AdvancedNewFileCreation"
WIN_ROOT_REGEX = r"[a-zA-Z]:(/|\\)"
NIX_ROOT_REGEX = r"^/"
HOME_REGEX = r"^~"
PLATFORM = sublime.platform().lower()
IS_ST3 = int(sublime.version()) > 3000

# Set up logger
logging.basicConfig(format='[AdvancedNewFile] %(levelname)s %(message)s')
logger = logging.getLogger()


class AdvancedNewFileCommand(sublime_plugin.WindowCommand):
    def run(self, is_python=False, initial_path=None):
        PLATFORM = sublime.platform().lower()
        self.root = None
        self.alias_root = None
        self.top_level_split_char = ":"
        self.is_python = is_python
        self.view = self.window.active_view()

        # Settings will be based on the view
        self.settings = get_settings(self.view)
        self.aliases = self.get_aliases()
        self.show_path = self.settings.get("show_path")
        self.default_folder_index = self.settings.get("default_folder_index")
        self.alias_folder_index = self.settings.get("alias_folder_index")
        default_root = self.get_default_root(self.settings.get("default_root"))
        if default_root == "path":
            self.root = os.path.expanduser(self.settings.get("default_path"))
            default_root = ""
        self.root, path = self.split_path(default_root)

        # Search for initial string
        if initial_path is not None:
            path = initial_path
        else:
            path = self.settings.get("default_initial", "")
            if self.settings.get("use_cursor_text", False):
                tmp = self.get_cursor_path()
                if tmp != "":
                    path = tmp

        alias_root = self.get_default_root(self.settings.get("alias_root"), True)
        if alias_root == "path":
            self.alias_root = os.path.expanduser(self.settings.get("alias_path"))
            alias_root = ""
        self.alias_root, tmp = self.split_path(alias_root, True)

        debug = self.settings.get("debug") or False
        if debug:
            logger.setLevel(logging.DEBUG)
        else:
            logger.setLevel(logging.ERROR)
        # Get user input
        self.show_filename_input(path)

    def get_aliases(self):
        aliases = self.settings.get("alias")
        all_os_aliases = self.settings.get("os_specific_alias")
        for key in all_os_aliases:
            if PLATFORM in all_os_aliases.get(key):
                aliases[key] = all_os_aliases.get(key).get(PLATFORM)

        return aliases

    def get_default_root(self, string, is_alias=False):
        root = ""

        if string == "home":
            root = "~/"
        elif string == "current":
            root = self.top_level_split_char
        elif string == "project_folder":
            if is_alias:
                folder_index = self.alias_folder_index
            else:
                folder_index = self.default_folder_index
            if len(self.window.folders()) <= folder_index:
                if is_alias:
                    self.alias_folder_index = 0
                else:
                    self.default_folder_index = 0
        elif string == "top_folder":
            if is_alias:
                self.alias_folder_index = 0
            else:
                self.default_folder_index = 0
        elif string == "path":
            root = "path"
        else:
            logger.error("Invalid specifier for \"default_root\"")
        return root

    def split_path(self, path="", is_alias=False):
        HOME_REGEX = r"^~[/\\]"
        root = None
        try:
            # Parse windows root
            if PLATFORM == "windows":
                if re.match(WIN_ROOT_REGEX, path):
                    root = path[0:3]
                    path = path[3:]

            # Parse if alias
            if self.top_level_split_char in path and root == None:
                parts = path.rsplit(self.top_level_split_char, 1)
                root, path = self.translate_alias(parts[0])
                path_list = []
                if path != "":
                    path_list.append(path)
                if parts[1] != "":
                    path_list.append(parts[1])
                path = self.top_level_split_char.join(path_list)
            elif re.match(r"^/", path):
                path_offset = 1
                if PLATFORM == "windows":
                    match = re.match(r"^/([a-zA-Z])/", path)
                    if match:
                        root = "%s:\\" % match.group(1)
                        path_offset = 3
                    else:
                        root, _ = os.path.splitdrive(self.view.file_name())
                        root += "\\"
                else:
                    root = "/"
                path = path[path_offset:]
            # Parse if tilde used
            elif re.match(HOME_REGEX, path) and root == None:
                root = os.path.expanduser("~")
                path = path[2:]
            elif re.match(r"^\.{1,2}[/\\]", path) and self.settings.get("relative_from_current", False):
                path_index = 2
                root = os.path.dirname(self.view.file_name())
                if re.match(r"^\.{2}[/\\]", path):
                    root = os.path.dirname(root)
                    path_index = 3
                path = path[path_index:]

            # Default
            if root == None:
                if is_alias:
                    root = self.alias_root
                    folder_index = self.alias_folder_index
                else:
                    root = self.root
                    folder_index = self.default_folder_index
                root = root or self.window.folders()[folder_index]
        except IndexError:
            root = os.path.expanduser("~")


        return root, path

    def translate_alias(self, path):
        root = None
        split_path = None
        if path == "" and self.view is not None:
            filename = self.view.file_name()
            if filename is not None:
                root = os.path.dirname(filename)
        else:
            split_path = path.split(self.top_level_split_char)
            join_index = len(split_path) - 1
            target = path
            root_found = False
            while join_index >= 0 and not root_found:
                # Folder aliases
                for name, folder in get_project_folder_data(self.settings.get("use_folder_name")):
                    if name == target:
                        root = folder
                        root_found = True
                        break
                # Aliases from settings.
                for alias in self.aliases.keys():
                    if alias == target:
                        alias_path = self.aliases.get(alias)
                        if re.search(HOME_REGEX, alias_path) is None:
                            if PLATFORM == "windows":
                                if re.search(WIN_ROOT_REGEX, alias_path) is None:
                                    root = os.path.join(self.alias_root, alias_path)
                                    break
                            else:
                                if re.search(NIX_ROOT_REGEX, alias_path) is None:
                                    root = os.path.join(self.alias_root, alias_path)
                                    break
                        root = os.path.expanduser(alias_path)
                        root_found = True
                        break
                remove = re.escape(split_path[join_index])
                target = re.sub(r":%s$" % remove, "", target)
                join_index -= 1

        if root is None:
            return None, path
        elif split_path is None:
            return os.path.abspath(root), ""
        else:
            # Add to index so we re
            join_index += 2
            return os.path.abspath(root), self.top_level_split_char.join(split_path[join_index:])

    def show_filename_input(self, initial=''):
        caption = 'Enter a path for a new file'
        if self.is_python:
            caption = '%s (creates __init__.py in new dirs)' % caption
        self.input_panel_view = self.window.show_input_panel(
            caption, initial,
            self.entered_filename, self.update_filename_input, self.clear
        )

        self.input_panel_view.set_name(VIEW_NAME)
        self.input_panel_view.settings().set("auto_complete_commit_on_tab", False)
        self.input_panel_view.settings().set("tab_completion", False)
        self.input_panel_view.settings().set("translate_tabs_to_spaces", False)
        self.input_panel_view.settings().set("anf_panel", True)

    def update_filename_input(self, path_in):
        if self.settings.get("completion_type") == "windows":
            if "prev_text" in dir(self) and self.prev_text != path_in:
                if self.view is not None:
                    self.view.erase_status("AdvancedNewFile2")
        if path_in.endswith("\t"):
            path_in = path_in.replace("\t", "")
            if self.settings.get("completion_type") == "windows":
                path_in = self.windows_completion(path_in)
            elif self.settings.get("completion_type") == "nix":
                path_in = self.nix_completion(path_in)

        base, path = self.split_path(path_in)

        creation_path = self.generate_creation_path(base, path, True)
        if self.show_path:
            if self.view != None:
                self.view.set_status("AdvancedNewFile", "Creating file at %s " % \
                    creation_path)
            else:
                sublime.status_message("Creating file at %s" % creation_path)
        logger.debug("Creation path is '%s'" % creation_path)

    def generate_completion_list(self, path_in, each_list=False):
        alias_list = []
        dir_list = []
        file_list = []
        self.suggestion_entries = []
        if self.top_level_split_char in path_in or re.match(r"^~[/\\]", path_in):
            pass
        else:
            directory, filename = os.path.split(path_in)
            if len(directory) == 0:
                alias_list += self.generate_alias_auto_complete(filename)
                alias_list += self.generate_project_auto_complete(filename)
        base, path = self.split_path(path_in)
        full_path = self.generate_creation_path(base, path)

        directory, filename = os.path.split(full_path)

        if os.path.isdir(directory):
            for d in os.listdir(directory):
                full_path = os.path.join(directory, d)
                if os.path.isdir(full_path):
                    is_file = False
                elif self.settings.get("show_files"):
                    is_file = True
                else:
                    continue

                if self.compare_entries(d, filename):
                    if is_file:
                        file_list.append(d)
                    else:
                        dir_list.append(d)

        completion_list = alias_list + dir_list + file_list

        return sorted(completion_list), alias_list, dir_list, file_list

    def windows_completion(self, path_in):
        pattern = r"(.*[/\\:])(.*)"
        match = re.match(pattern, path_in)
        if "prev_text" in dir(self) and self.prev_text == path_in:
            self.offset = (self.offset + 1) % len(self.completion_list)
        else:
            # Generate new completion list
            self.completion_list, self.alias_list, self.dir_list, self.file_list = self.generate_completion_list(path_in)
            self.offset = 0

            if len(self.completion_list) == 0:
                if match:
                    self.completion_list = [match.group(2)]
                else:
                    self.completion_list = [path_in]
        match = re.match(pattern, path_in)
        if match :
            completion = self.completion_list[self.offset]
            if self.settings.get("complete_single_entry"):
                if len(self.completion_list) == 1:
                    if completion in self.alias_list:
                        completion += ":"
                    elif completion in self.dir_list:
                        completion += "/"
            new_content = re.sub(pattern, r"\1" , path_in)
            new_content += completion
            first_token = False
        else:
            completion = self.completion_list[self.offset]
            if self.settings.get("complete_single_entry"):
                if len(self.completion_list) == 1:
                    if completion in self.alias_list:
                        completion += ":"
                    elif completion in self.dir_list:
                        completion += "/"
            new_content = completion
            first_token = True

        if len(self.completion_list) > 1:
            if first_token:
                if self.view is not None:
                    if self.completion_list[self.offset] in self.alias_list:
                        self.view.set_status("AdvancedNewFile2", "Alias Completion")
                    elif self.completion_list[self.offset] in self.dir_list:
                        self.view.set_status("AdvancedNewFile2", "Directory Completion")
            self.prev_text = new_content
        else:
            self.prev_text = None
        self.input_panel_view.run_command("anf_replace", {"content": new_content})
        return new_content

    def nix_completion(self, path_in):
        pattern = r"(.*[/\\:])(.*)"

        completion_list, alias_list, dir_list, file_list = self.generate_completion_list(path_in)
        new_content = path_in
        if len(completion_list) > 0:
            common = os.path.commonprefix(completion_list)
            match = re.match(pattern, path_in)
            if match :
                new_content = re.sub(pattern, r"\1", path_in)
                new_content += common
            else:
                new_content = common
            if len(completion_list) > 1:
                dir_list = map(lambda s: s + "/", dir_list)
                alias_list = map(lambda s: s + ":", alias_list)
                status_message_list = sorted(list(dir_list) + list(alias_list) + file_list)
                sublime.status_message(", ".join(status_message_list))
            else:
                if completion_list[0] in alias_list:
                    new_content += ":"
                elif completion_list[0] in dir_list:
                    new_content += "/"
        self.input_panel_view.run_command("anf_replace", {"content": new_content})
        return new_content

    def generate_project_auto_complete(self, base):
        folder_data = get_project_folder_data(self.settings.get("use_folder_name"))
        if len(folder_data) > 1:
            folders = [x[0] for x in folder_data]
            return self.generate_auto_complete(base, folders)
        return []

    def generate_alias_auto_complete(self, base):
        return self.generate_auto_complete(base, self.aliases)

    def generate_auto_complete(self, base, iterable_var):
        sugg = []
        for entry in iterable_var:
            if entry in self.suggestion_entries:
                continue
            self.suggestion_entries.append(entry)
            compare_entry = entry
            compare_base = base
            if self.settings.get("ignore_case"):
                compare_entry = compare_entry.lower()
                compare_base = compare_base.lower()

            if self.compare_entries(compare_entry, compare_base):
                sugg.append(entry)

        return sugg

    def compare_entries(self, compare_entry, compare_base):
        if self.settings.get("ignore_case"):
            compare_entry = compare_entry.lower()
            compare_base = compare_base.lower()

        return compare_entry.startswith(compare_base)


    def generate_creation_path(self, base, path, append_extension=False):
        if PLATFORM == "windows":
            if not re.match(WIN_ROOT_REGEX, base):
                return base + self.top_level_split_char + path
        else:
            if not re.match(NIX_ROOT_REGEX, base):
                return base + self.top_level_split_char + path

        tokens = re.split(r"[/\\]", base) + re.split(r"[/\\]", path)
        if tokens[0] == "":
            tokens[0] = "/"
        if PLATFORM == "windows":
            tokens[0] = base[0:3]

        full_path = os.path.abspath(os.path.join(*tokens))
        if re.search(r"[/\\]$", path) or len(path) == 0:
            full_path += os.path.sep
        elif re.search(r"\.", tokens[-1]):
            if re.search(r"\.$", tokens[-1]):
                full_path += "."
        elif append_extension:
            filename = os.path.basename(full_path)
            if not os.path.exists(full_path):
                full_path += self.settings.get("default_extension", "")
        return full_path

    def entered_filename(self, filename):
        # Check if valid root specified for windows.
        if PLATFORM == "windows":
            if re.match(WIN_ROOT_REGEX, filename):
                root = filename[0:3]
                if not os.path.isdir(root):
                    sublime.error_message(root + " is not a valid root.")
                    self.clear()
                    return

        base, path = self.split_path(filename)
        file_path = self.generate_creation_path(base, path, True)
        # Check for invalid alias specified.
        if self.top_level_split_char in filename and \
            not (PLATFORM == "windows" and re.match(WIN_ROOT_REGEX, base)) and \
            not (PLATFORM != "windows" and re.match(NIX_ROOT_REGEX, base)):
            if base == "":
                error_message = "Current file cannot be resolved."
            else:
                error_message = "'" + base + "' is an invalid alias."
            sublime.error_message(error_message)
        else:
            attempt_open = True
            logger.debug("Creating file at %s", file_path)
            if not os.path.exists(file_path):
                try:
                    self.create(file_path)
                except OSError as e:
                    attempt_open = False
                    sublime.error_message("Cannot create '" + file_path + "'. See console for details")
                    logger.error("Exception: %s '%s'" % (e.strerror, e.filename))
            if attempt_open:
                if os.path.isdir(file_path):
                    if not re.search(r"(/|\\)$", file_path):
                        sublime.error_message("Cannot open view for '" + file_path + "'. It is a directory. ")
                else:
                    self.window.open_file(file_path)
        self.clear()
        self.refresh_sidebar()

    def refresh_sidebar(self):
        if self.settings.get("auto_refresh_sidebar"):
            try:
                self.window.run_command("refresh_folder_list")
            except:
                pass

    def clear(self):
        if self.view != None:
            self.view.erase_status("AdvancedNewFile")
            self.view.erase_status("AdvancedNewFile2")

    def create(self, filename):
        base, filename = os.path.split(filename)
        self.create_folder(base)
        if filename != "":
            open(os.path.join(base, filename), "a").close()

    def create_folder(self, path):
        init_list = []
        if self.is_python:
            temp_path = path
            while not os.path.exists(temp_path):
                init_list.append(temp_path)
                temp_path = os.path.dirname(temp_path)
        try:
            if not os.path.exists(path):
                os.makedirs(path)
        except OSError as ex:
            if ex.errno != errno.EEXIST:
                raise

        for entry in init_list:
            open(os.path.join(entry, '__init__.py'), 'a').close()

    def get_cursor_path(self):
        if self.view == None:
            return ""

        view = self.view
        path = ""
        for region in view.sel():
            syntax = view.scope_name(region.begin())
            if region.begin() != region.end():
                path = view.substr(region)
                break
            if re.match(".*string.quoted.double", syntax) or re.match(".*string.quoted.single", syntax):
                path = view.substr(view.extract_scope(region.begin()))
                path = re.sub('^"|\'', '',  re.sub('"|\'$', '', path.strip()))
                break

        return path


class AnfReplaceCommand(sublime_plugin.TextCommand):
    def run(self, edit, content):
        self.view.replace(edit, sublime.Region(0, self.view.size()), content)


class AdvancedNewFileAtCommand(sublime_plugin.WindowCommand):
    def run(self, dirs):
        if len(dirs) != 1:
            return
        path = dirs[0]
        self.window.run_command("advanced_new_file", {"initial_path": path + os.sep})


    def is_visible(self, dirs):
        settings = sublime.load_settings("AdvancedNewFile.sublime-settings")
        return settings.get("show_sidebar_menu", False) and len(dirs) == 1


def get_settings(view):
    settings = sublime.load_settings("AdvancedNewFile.sublime-settings")
    project_settings = {}
    local_settings = {}
    if view != None:
        project_settings = view.settings().get('AdvancedNewFile', {})

    for setting in SETTINGS:
        local_settings[setting] = settings.get(setting)

    for key in project_settings:
        if key in SETTINGS:
            if key == "alias":
                local_settings[key] = dict(local_settings[key].items() + project_settings.get(key).items())
            else:
                local_settings[key] = project_settings[key]
        else:
            logger.error("AdvancedNewFile[Warning]: Invalid key '%s' in project settings.", key)

    return local_settings

def get_project_folder_data(use_folder_name):
    folders = []
    folder_entries = []
    window = sublime.active_window()
    project_folders = window.folders()

    if IS_ST3:
        project_data = window.project_data()

        if project_data is not None:
            if use_folder_name:
                for folder in project_data.get("folders", []):
                    folder_entries.append({})
            else:
                folder_entries = project_data.get("folders", [])
    else:
        for folder in project_folders:
            folder_entries.append({})
    for index in range(len(folder_entries)):
        folder_path = project_folders[index]
        folder_entry = folder_entries[index]
        if "name" in folder_entry:
            folders.append((folder_entry["name"], folder_path))
        else:
            folders.append((os.path.basename(folder_path), folder_path))

    return folders