# This is startup file for interactive python.
# It is not automatically loaded by python interpreter.
# To instruct the interpreter to load it insert the following commands
# into your .profile (use whatever syntax and initialization file
# is appropriate for your shell):
#
# PYTHONSTARTUP=$HOME/init.py  # or where you really put it
# export PYTHONSTARTUP


def init():
    try:
        import __builtin__ as builtins
    except ImportError:
        import builtins
    import os
    import sys

    # readline/pyreadline

    pyreadlinew32_startup = os.path.join(
        sys.prefix, 'lib', 'site-packages',
        'pyreadline', 'configuration', 'startup.py')

    if os.path.exists(pyreadlinew32_startup):
        execfile(pyreadlinew32_startup)

    else:
        # From Bruce Edge:
        # https://mail.python.org/pipermail/python-list/2001-March/062888.html

        try:
            import rlcompleter  # noqa: need for completion
            import readline
            initfile = os.environ.get('INPUTRC') \
                or os.path.expanduser('~/.inputrc')
            readline.read_init_file(initfile)

            # if 'libedit' in readline.__doc__:
            #     readline.parse_and_bind("bind ^I rl_complete")
            # else:
            #     readline.parse_and_bind("tab: complete")

            histfiles = ['~/.python_history']
            # if 'VIRTUAL_ENV' in os.environ:
            #     histfiles.append('$VIRTUAL_ENV/.python_history')
            for histfile in histfiles:
                try:
                    histfile = os.path.expandvars(histfile)
                    histfile = os.path.expanduser(histfile)
                    readline.read_history_file(histfile)
                except IOError:
                    pass  # No such file

            def savehist():
                histsize = os.environ.get('HISTSIZE')
                if histsize:
                    try:
                        histsize = int(histsize)
                    except ValueError:
                        pass
                    else:
                        readline.set_history_length(histsize)
                histfile = histfiles[-1]
                histfile = os.path.expandvars(histfile)
                histfile = os.path.expanduser(histfile)
                try:
                    readline.write_history_file(histfile)
                except IOError:
                    pass

            import atexit
            atexit.register(savehist)

        except (ImportError, AttributeError):
            # no readline or atexit, or readline doesn't have
            # {read,write}_history_file - ignore the error
            pass

    # terminal

    term = os.environ.get('TERM', '')
    for _term in ['cygwin', 'linux', 'putty']:
        if _term in term:
            background = 'dark'
            break
    else:
        background = os.environ.get('BACKGROUND', 'light').lower()

    # From Randall Hopper:
    # https://mail.python.org/pipermail/python-list/2001-March/112696.html

    _term_found = False
    for _term in ['cygwin', 'linux', 'putty', 'rxvt',
                  'screen', 'term', 'vt100']:
        if _term in term:
            _term_found = True
            break

    if _term_found:
        if background == 'dark':
            ps1_color = '3'  # yellow
            stdout_color = '7'  # bold white
        else:
            ps1_color = '4'  # blue
            stdout_color = '0'  # bold black

        sys.ps1 = '\001\033[3%sm\002>>>\001\033[0m\002 ' % ps1_color
        sys.ps2 = '\001\033[1;32m\002...\001\033[0m\002 '  # bold green

        # From Denis Otkidach

        class ColoredFile:
            def __init__(self, fp, begin,
                         end='\033[0m'):  # reset all attributes
                self.__fp = fp
                self.__begin = begin
                self.__end = end

            def write(self, s):
                self.__fp.write(self.__begin+s+self.__end)

            def writelines(self, lines):
                map(self.write, lines)

            def __getattr__(self, attr):
                return getattr(self.__fp, attr)

        sys.stdout = ColoredFile(sys.stdout, '\033[1;3%sm' % stdout_color)
        sys.stderr = ColoredFile(sys.stderr, '\033[31m')  # red

        def myinput(prompt=None):
            save_stdout = sys.stdout
            sys.stdout = sys.__stdout__
            result = builtin_input(prompt)
            sys.stdout = save_stdout
            return result

        try:
            builtins.raw_input
        except AttributeError:  # PY3
            builtin_input = builtins.input
            builtins.input = myinput
        else:
            builtin_input = builtins.raw_input
            builtins.raw_input = myinput

    try:
        import locale
    except ImportError:
        pass  # locale was not compiled
    else:
        try:
            locale.setlocale(locale.LC_ALL, '')
        except (ImportError, locale.Error):
            pass  # no locale support or unsupported locale

    # set displayhook and excepthook

    from pprint import pprint
    from traceback import format_exception, print_exc

    pager = os.environ.get("PAGER") or 'more'

    # if your pager is 'less', options '-F' and '-R' must be passed to it,
    # and option '-X' is very much recommended
    if pager == 'less':
        less = os.environ.get("LESS") or ''
        for opt in 'X', 'R', 'F':
            if opt not in less:
                less = opt + less
        os.environ["LESS"] = less

    class BasePager:
        def write(self, value):
            self.stdout.write(value)

        if _term_found:
            def pprint(self, value):
                pprint(value,
                       stream=ColoredFile(self.stdout,
                                          '\033[1;3%sm' % stdout_color))

        def close(self):
            self.stdout.close()

    try:
        from subprocess import Popen, PIPE
    except ImportError:
        class Pager(BasePager):
            def __init__(self):
                self.stdout = os.popen(pager, 'w')
    else:
        class Pager(BasePager):
            def __init__(self):
                self.pipe = Popen(pager, shell=True, stdin=PIPE,
                                  universal_newlines=True)
                self.stdout = self.pipe.stdin

            def close(self):
                BasePager.close(self)
                self.pipe.wait()

    def displayhook(value):
        if value is not None:
            builtins._ = value
        pager = Pager()
        try:
            pager.pprint(value)
        except:  # noqa
            if _term_found:
                pager.stdout = ColoredFile(pager.stdout, '\033[31m')  # red
            print_exc(file=pager)
        pager.close()

    sys.displayhook = displayhook

    def excepthook(etype, evalue, etraceback):
        lines = format_exception(etype, evalue, etraceback)
        pager = Pager()
        if _term_found:
            pager.stdout = ColoredFile(pager.stdout, '\033[31m')  # red
        for line in lines:
            pager.write(line)
        pager.close()

    sys.excepthook = excepthook

    # try:
    #     import cgitb
    # except ImportError:
    #     pass
    # else:
    #     # cgitb.enable() overrides sys.excepthook
    #     cgitb.enable(format='text')

    # From Thomas Heller:
    # https://mail.python.org/pipermail/python-list/2001-April/099020.html

    # import pdb
    #
    # def info(*args):
    #    pdb.pm()
    # sys.excepthook = info

    # utilities

    # From: Paul Magwene:
    # https://mail.python.org/pipermail/python-list/2001-March/086191.html
    # With a lot of my fixes:

    class DirLister:
        def __getitem__(self, key):
            s = os.listdir(os.curdir)
            return s[key]

        def __getslice__(self, i, j):
            s = os.listdir(os.curdir)
            return s[i:j]

        def __repr__(self):
            return str(os.listdir(os.curdir))

        def __call__(self, path=None):
            if path:
                path = os.path.expanduser(os.path.expandvars(path))
            else:
                path = os.curdir
            return os.listdir(path)

    class DirChanger:
        def __repr__(self):
            self()
            return os.getcwd()

        def __call__(self, path=None):
            path = os.path.expanduser(os.path.expandvars(path or '~'))
            os.chdir(path)

    builtins.ls = DirLister()
    builtins.cd = DirChanger()

    # print working directory

    class Pwd:
        def __repr__(self):
            return os.getcwd()

        def __call__(self):
            return repr(self)

    builtins.pwd = Pwd()

    # exit REPL with 'exit', 'quit' or simple 'x'

    class _Exit:
        def __repr__(self):
            sys.exit()

        def __call__(self, msg=None):
            sys.exit(msg)

    builtins.x = _Exit()

    # print conten of a file

    class _Cat:
        def __repr__(self):
            return "Usage: cat('filename')"

        def __call__(self, filename):
            fp = open(filename, 'rU')
            text = fp.read()
            fp.close()
            print(text)

    builtins.cat = _Cat()

    # call shell

    class _Sh:
        def __repr__(self):
            os.system(os.environ["SHELL"])
            return ''

        def __call__(self, cmdline):
            os.system(cmdline)

    builtins.sh = _Sh()

    # paginate a file

    class _Pager:
        def __repr__(self):
            return "Usage: pager('filename')"

        def __call__(self, filename):
            os.system("%s '%s'" % (pager, filename.replace("'", '"\'"')))

    builtins.pager = _Pager()

    # edit a file

    class _Editor:
        def __repr__(self):
            return "Usage: edit('filename')"

        def __call__(self, filename):
            editor = os.environ.get("VISUAL") \
                or os.environ.get("EDITOR") or 'vi'
            os.system("%s '%s'" % (editor, filename.replace("'", '"\'"')))

    builtins.edit = builtins.editor = _Editor()


init()
del init