#!/usr/bin/python

#+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
# SimpleCV
# a kinder, gentler machine vision python library
#-----------------------------------------------------------------------
# SimpleCV is an interface for Open Source machine
# vision libraries in Python.
# It provides a concise, readable interface for cameras,
# image manipulation, feature extraction, and format conversion.
# Our mission is to give casual users a comprehensive interface
# for basic machine vision functions and an
# elegant programming interface for advanced users.
#
# more info:
# http://www.simplecv.org
#+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++


#load system libraries
from subprocess import call
import platform
import webbrowser
import sys

from SimpleCV.__init__ import *

#Load simpleCV libraries
from SimpleCV.Shell.Tutorial import *
from SimpleCV.Shell.Example import *

try:
    from SimpleCV import __version__ as SIMPLECV_VERSION
except ImportError:
    SIMPLECV_VERSION = ''


#Command to clear the shell screen
def shellclear():
    if platform.system() == "Windows":
        return
    call("clear")

#method to get magic_* methods working in bpython
def make_magic(method):
    def wrapper(*args, **kwargs):
        if not args:
            return method('', '')
        return method('', *args, **kwargs)

    return wrapper


def plot(arg):
    try:
        import matplotlib.pyplot as plt
    except ImportError:
        logger.warning("Matplotlib is not installed and required")
        return

    print "args", arg
    print "type", type(arg)
    plt.plot(arg)
    plt.show()


def hist(arg):
    try:
        import pylab
    except ImportError:
        logger.warning("pylab is not installed and required")
        return
    plot(pylab.hist(arg)[1])


def magic_clear(self, arg):
    shellclear()

def magic_forums(self, arg):
    webbrowser.open('http://help.simplecv.org/questions/')

def magic_walkthrough(self, arg):
    webbrowser.open('http://examples.simplecv.org/en/latest/')

def magic_docs(self, arg):
    webbrowser.open('http://www.simplecv.org/docs/')

banner = '+-----------------------------------------------------------+\n'
banner += ' SimpleCV '
banner += SIMPLECV_VERSION
banner += ' [interactive shell] - http://simplecv.org\n'
banner += '+-----------------------------------------------------------+\n'
banner += '\n'
banner += 'Commands: \n'
banner += '\t"exit()" or press "Ctrl+ D" to exit the shell\n'
banner += '\t"clear()" to clear the shell screen\n'
banner += '\t"tutorial()" to begin the SimpleCV interactive tutorial\n'
banner += '\t"example()" gives a list of examples you can run\n'
banner += '\t"forums()" will launch a web browser for the help forums\n'
banner += '\t"walkthrough()" will launch a web browser with a walkthrough\n'
banner += '\n'
banner += 'Usage:\n'
banner += '\tdot complete works to show library\n'
banner += '\tfor example: Image().save("/tmp/test.jpg") will dot complete\n'
banner += '\tjust by touching TAB after typing Image().\n'
banner += '\n'
banner += 'Documentation:\n'
banner += '\thelp(Image), ?Image, Image?, or Image()? all do the same\n'
banner += '\t"docs()" will launch webbrowser showing documentation'
banner += '\n'
exit_msg = '\n... [Exiting the SimpleCV interactive shell] ...\n'


def setup_ipython():
    try:
        import IPython
        from IPython.config.loader import Config
        from IPython.frontend.terminal.embed import InteractiveShellEmbed

        cfg = Config()
        cfg.PromptManager.in_template = "SimpleCV:\\#> "
        cfg.PromptManager.out_template = "SimpleCV:\\#: "
        #~ cfg.InteractiveShellEmbed.prompt_in1 = "SimpleCV:\\#> "
        #~ cfg.InteractiveShellEmbed.prompt_out="SimpleCV:\\#: "
        scvShell = InteractiveShellEmbed(config=cfg, banner1=banner,
                                         exit_msg=exit_msg)
        scvShell.define_magic("tutorial", magic_tutorial)
        scvShell.define_magic("clear", magic_clear)
        scvShell.define_magic("example", magic_examples)
        scvShell.define_magic("forums", magic_forums)
        scvShell.define_magic("walkthrough", magic_walkthrough)
        scvShell.define_magic("docs", magic_docs)
    except ImportError:
        try:
            from IPython.Shell import IPShellEmbed

            argsv = ['-pi1', 'SimpleCV:\\#>', '-pi2', '   .\\D.:', '-po',
                     'SimpleCV:\\#>', '-nosep']
            scvShell = IPShellEmbed(argsv)
            scvShell.set_banner(banner)
            scvShell.set_exit_msg(exit_msg)
            scvShell.IP.api.expose_magic("tutorial", magic_tutorial)
            scvShell.IP.api.expose_magic("clear", magic_clear)
            scvShell.IP.api.expose_magic("example", magic_examples)
            scvShell.IP.api.expose_magic("forums", magic_forums)
            scvShell.IP.api.expose_magic("walkthrough", magic_walkthrough)
            scvShell.IP.api.expose_magic("docs", magic_docs)
        except ImportError:
            raise

    return scvShell()


def setup_bpython():
    import bpython
    example = make_magic(magic_examples)
    clear = make_magic(magic_clear)
    docs = make_magic(magic_docs)
    tutorial = make_magic(magic_tutorial)
    walkthrough = make_magic(magic_walkthrough)
    forums = make_magic(magic_forums)
    temp = locals().copy()
    temp.update(globals())
    return bpython.embed(locals_=temp, banner=banner)


def setup_plain():
    import code

    return code.interact(banner=banner, local=globals())


def run_notebook(mainArgs):

    if IPython.__version__.startswith('1.'):
        """Run the ipython notebook server"""
        from IPython.html import notebookapp
        from IPython.html.services.kernels import kernelmanager
    else:
        from IPython.frontend.html.notebook import notebookapp
        from IPython.frontend.html.notebook import kernelmanager

    code = ""
    code += "from SimpleCV import *;"
    code += "init_options_handler.enable_notebook();"

    kernelmanager.MappingKernelManager.first_beat = 30.0
    app = notebookapp.NotebookApp.instance()
    mainArgs += [
        '--port', '5050',
        '--c', code,
    ]
    app.initialize(mainArgs)
    app.start()
    sys.exit()


def self_update():
    URL = "https://github.com/sightmachine/SimpleCV/zipball/master"
    command = "pip install -U %s" % URL

    if os.getuid() == 0:
        command = "sudo " + command

    returncode = call(command, shell=True)
    sys.exit()


def run_shell(shell=None):
    shells = ['setup_ipython', 'setup_bpython', 'setup_plain']
    available_shells = [shell] if shell else shells

    for shell in available_shells:
        try:
            return globals()[shell]()
        except ImportError:
            pass
    raise ImportError


def main(*args):
    log_level = logging.WARNING
    interface = None

    if len(sys.argv) > 1 and len(sys.argv[1]) > 1:
        flag = sys.argv[1]

        if flag == 'notebook':
            run_notebook(sys.argv[1:])
            sys.exit()

        elif flag == 'update':
            print "Updating SimpleCV....."
            self_update()

        if flag in ['--headless', 'headless']:
            # set SDL to use the dummy NULL video driver,
            #   so it doesn't need a windowing system.
            os.environ["SDL_VIDEODRIVER"] = "dummy"

        elif flag in ['--nowarnings', 'nowarnings']:
            log_level = logging.INFO

        elif flag in ['--debug', 'debug']:
            log_level = logging.DEBUG

        if flag in ['--ipython', 'ipython']:
            interface = 'setup_ipython'

        elif flag in ['--bpython', 'bpython']:
            interface = 'setup_bpython'
        else:
            interface = 'setup_plain'

    init_logging(log_level)
    shellclear()
    scvShell = run_shell(interface)