# coding: utf-8
from __future__ import unicode_literals, division, absolute_import, print_function

import os
import sys
import shutil
import locale
import stat

import golangconfig

if sys.version_info < (3,):
    from cStringIO import StringIO
    str_cls = unicode  # noqa
else:
    from io import StringIO
    str_cls = str


class SublimeViewMock():

    _settings = None
    _context = None

    def __init__(self, settings, context):
        self._settings = settings
        self._context = context

    def settings(self):
        if self.window():
            # In Sublime Text, View objects inherit settings from the window/project
            # unless they are explicitly set on the view, so we replicate that here
            merged_golang_settings = {}
            project_data = self.window().project_data()
            if project_data:
                merged_golang_settings.update(project_data.get('settings', {}).get('golang', {}).copy())
            merged_golang_settings.update(self._settings)
        elif self._settings:
            merged_golang_settings = self._settings.copy()
        else:
            merged_golang_settings = {}
        return {'golang': merged_golang_settings}

    def window(self):
        return self._context.window


class SublimeWindowMock():

    _settings = None
    _context = None

    def __init__(self, settings, context):
        self._settings = settings
        self._context = context

    def project_data(self):
        if self._settings is None:
            return None
        return {'settings': {'golang': self._settings}}

    def active_view(self):
        if self._context.view:
            return self._context.view
        return SublimeViewMock({}, self._context)


class ShellenvMock():

    _env_encoding = locale.getpreferredencoding() if sys.platform == 'win32' else 'utf-8'
    _fs_encoding = 'mbcs' if sys.platform == 'win32' else 'utf-8'

    _shell = None
    _data = None

    def __init__(self, shell, data):
        self._shell = shell
        self._data = data

    def get_env(self, for_subprocess=False):
        if not for_subprocess or sys.version_info >= (3,):
            return (self._shell, self._data)

        shell = self._shell.encode(self._fs_encoding)
        env = {}
        for name, value in self._data.items():
            env[name.encode(self._env_encoding)] = value.encode(self._env_encoding)

        return (shell, env)

    def get_path(self):
        return (self._shell, self._data.get('PATH', '').split(os.pathsep))

    def env_encode(self, value):
        if sys.version_info >= (3,):
            return value
        return value.encode(self._env_encoding)

    def path_encode(self, value):
        if sys.version_info >= (3,):
            return value
        return value.encode(self._fs_encoding)

    def path_decode(self, value):
        if sys.version_info >= (3,):
            return value
        return value.decode(self._fs_encoding)


class SublimeSettingsMock():

    _values = None

    def __init__(self, values):
        self._values = values

    def get(self, name, default=None):
        return self._values.get(name, default)


class SublimeMock():

    _settings = None
    View = SublimeViewMock
    Window = SublimeWindowMock

    def __init__(self, settings):
        self._settings = SublimeSettingsMock(settings)

    def load_settings(self, basename):
        return self._settings


class GolangConfigMock():

    _shellenv = None
    _sublime = None
    _stdout = None

    _tempdir = None

    _shell = None
    _env = None
    _view_settings = None
    _window_settings = None
    _sublime_settings = None

    def __init__(self, shell, env, view_settings, window_settings, sublime_settings):
        self._shell = shell
        self._env = env
        self._view_settings = view_settings
        self._window_settings = window_settings
        self._sublime_settings = sublime_settings
        self._tempdir = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'mock_fs')
        if not os.path.exists(self._tempdir):
            os.mkdir(self._tempdir)

    def replace_tempdir_env(self):
        for key in self._env:
            self._env[key] = self._env[key].replace(
                '{tempdir}',
                self.tempdir + os.sep
            )

    def replace_tempdir_view_settings(self):
        self._replace_tempdir_settings(self._view_settings)

    def replace_tempdir_window_settings(self):
        self._replace_tempdir_settings(self._window_settings)

    def replace_tempdir_sublime_settings(self):
        self._replace_tempdir_settings(self._sublime_settings)

    def _replace_tempdir_settings(self, settings_dict):
        if settings_dict:
            for key in settings_dict:
                if isinstance(settings_dict[key], str_cls):
                    settings_dict[key] = settings_dict[key].replace(
                        '{tempdir}',
                        self.tempdir + os.sep
                    )
            for platform in ['osx', 'windows', 'linux']:
                if platform not in settings_dict:
                    continue
                for key in settings_dict[platform]:
                    if isinstance(settings_dict[platform][key], str_cls):
                        settings_dict[platform][key] = settings_dict[platform][key].replace(
                            '{tempdir}',
                            self.tempdir + os.sep
                        )

    def make_executable_files(self, executable_temp_files):
        self.make_files(executable_temp_files)
        for temp_file in executable_temp_files:
            temp_file_path = os.path.join(self.tempdir, temp_file)
            st = os.stat(temp_file_path)
            os.chmod(temp_file_path, st.st_mode | stat.S_IEXEC)

    def make_files(self, temp_files):
        for temp_file in temp_files:
            temp_file_path = os.path.join(self.tempdir, temp_file)
            temp_file_dir = os.path.dirname(temp_file_path)
            if not os.path.exists(temp_file_dir):
                os.makedirs(temp_file_dir)
            with open(temp_file_path, 'a'):
                pass

    def make_dirs(self, temp_dirs):
        for temp_dir in temp_dirs:
            temp_dir_path = os.path.join(self.tempdir, temp_dir)
            if not os.path.exists(temp_dir_path):
                os.makedirs(temp_dir_path)

    @property
    def view(self):
        if self._view_settings is None:
            return None
        return SublimeViewMock(self._view_settings, self)

    @property
    def window(self):
        return SublimeWindowMock(self._window_settings, self)

    @property
    def tempdir(self):
        return self._tempdir

    def __enter__(self):
        self._shellenv = golangconfig.shellenv
        golangconfig.shellenv = ShellenvMock(self._shell, self._env)
        self._sublime = golangconfig.sublime
        golangconfig.sublime = SublimeMock(self._sublime_settings)
        self._stdout = sys.stdout
        sys.stdout = StringIO()
        return self

    def __exit__(self, exc_type, exc_value, traceback):
        golangconfig.shellenv = self._shellenv
        golangconfig.sublime = self._sublime
        temp_stdout = sys.stdout
        sys.stdout = self._stdout
        print(temp_stdout.getvalue(), end='')
        if self._tempdir and os.path.exists(self._tempdir):
            shutil.rmtree(self._tempdir)