#!/usr/bin/env python

"""
installs config to a user's home directory
this can be done with
curl http://k0s.org/hg/config/raw-file/tip/python/install_config.py | python
"""

# TODO:
# - dl and get ~/web/sync.ini :
#   ln -s /home/jhammel/web/sync.ini /home/jhammel/.silvermirror
# - handle cases where config is autogenerated BUT you still want
#   to have some base (e.g. .gkrellm2/user_config)
# - scp k0s.org:~/web/sync.ini ~/.silvermirror
# - make idempotent
# - step to install (and setup) firefox

# imports
import imp
import optparse
import os
import subprocess
import sys

# globals
SRC = 'http://k0s.org/hg/config' # config repository
HOME = os.environ['HOME'] # home directory


### standalone functions

def class_mapping(_type):
    """returns a dict of (name, class) for objects in the current globals() of _type"""
    return {name:cls for name, cls in globals().items() if cls.issubclass(_type)}


def execute(*commands, **kwargs):
    """execute a series of commands"""
    for command in commands:
        print (subprocess.list2cmdline(command))
        code = subprocess.call(command, **kwargs)
        if code:
            raise subprocess.CalledProcessError(code, command)


def install_develop(package):
    """install k0s.ware for development"""

    src = 'http://k0s.org/hg/%s' % package
    directory = '%s/src/%s' % (package, package)
    commands = [['virtualenv/virtualenv.py', package],
                ['mkdir', '-p', directory ],
                ['hg', 'clone', src, directory] ]
    execute(*commands)
    old_directory = os.getcwd()
    os.chdir(directory)
    command = ['../../bin/python',  'setup.py', 'develop']
    execute(command)
    os.chdir(old_directory)


### generic step framework

class StepGraph(object):
    """a bunch of steps"""

class Step(object):
    @classmethod
    def check(cls):
        """checks if the step may be run"""
    @classmethod
    def name(cls):
        return cls.__name__
    __str__ = name # XXX does not work! :(
    def __call__(self):
        execute(*self.commands)


class Command(object):
    """require a command"""

#@require(Virtualenv)
class InstallVirtualenv(Step):
    """ABC for installing packages in a virtualenv"""
    # TODO: move install_develop sctuff to here


### process steps

class InitializeRepository(Step):
    """make the home directory a repository"""
    commands = [
        ['hg', 'init'],
        ['hg', 'pull', SRC],
        ['hg', 'update', '-C'],
        ]
    @classmethod
    def write_hgrc(self):
        """make a (correct) .hg/hgrc file for $HOME"""

        hgrc = """[paths]
default = http://k0s.org/hg/config
default-push = ssh://k0s.org/hg/config
"""
        with file('.hg/hgrc', 'w') as f:
            f.write(hgrc)

    def __call__(self):
        Step.__call__(self)
        self.write_hgrc()

        # get the which command
        sys.path.append(os.path.join(HOME, 'python'))
        from which import which

#@requires(Command('git'))
class ConfigureGit(Step):
    """configure git"""
    commands = [
        # setup git's global ignore, since git is silly about this
        # and doesn't look for the file in the right place
        ['git', 'config', '--global', 'core.excludesfile', os.path.join(HOME, '.gitignore')]
    ]

#@requires(Command('git'))
class InstallVirtualenv(Step):
    commands = [['git', 'clone', 'https://github.com/pypa/virtualenv.git'],
                ['ln', '-s',
                 os.path.join(HOME, 'virtualenv/virtualenv.py'),
                 os.path.join(HOME, 'bin', 'virtualenv.py')]
    ]

class InstallKWare(In):
    """install k0s.ware"""
    # TODO
    # from legacy
        # # install some python
        # install_develop('smartopen')
        # install_develop('silvermirror') # XXX this won't actually work since python-dev isn't installed; install it first

        # postinstall_commands = [['ln', '-s', os.path.join(HOME, 'smartopen', 'bin', 'smartopen'), os.path.join(HOME, 'bin', 'smartopen') ],
        #                         ['ln', '-s', os.path.join(HOME, 'silvermirror', 'bin', 'silvermirror'), os.path.join(HOME, 'bin', 'silvermirror') ],
        #                      ]
        # execute(*postinstall_commands)


class DebianPackages(Step):
    """ubuntu packages to install"""
    # TODO: actually install packages

    PACKAGES=["antiword",
              "arandr",
              "curl",
              "emacs",
              "fluxbox",
              "git",
              "gkrellm",
              "graphviz",
              "graphviz-dev",
              "irssi",
              "mercurial",
              "python-dev",
              "python-lxml",
              "libxml2"
              "libxml2-dev",
              "libxslt1-dev",
              "unison",
              "xclip",
    ]

    def __call__(self):
        # TODO: actually install this shit
        print "Ensure the following packages are installed:"
        print "sudo apt-get install %s" % ' '.join(self.PACKAGES)


### legacy -v-

def legacy():
    """legacy : TO DEPRECATE!"""

    # do git stuff
    git = which('git')
    if git:

    else:
        print "git not installed"


### CLI

def main(args=sys.argv[1:]):

    # go home
    os.chdir(HOME)

    # parse command line
    usage = '%prog [options]'
    parser = optparse.OptionParser(usage=usage, description=__doc__)
    parser.add_option('--deb', '--dpkg', '--debian-packages',
                      dest='debian_packages',
                      action='store_true', default=False,
                      help="display debian packages to install")
    parser.add_option('-l', '--list', '--list-steps',
                      dest='list_steps',
                      action='store_true', default=False,
                      help="list steps to be run and exit")
    parser.add_option('--all', dest='all',
                      action='store_true', default=False,
                      help="list all actions")
    parser.add_option('--run', dest='run',
                      action='append',
                      help="run particular actions, in order")
    options, args = parser.parse_args()

    # plan steps
    steps = [InitializeRepository, DebianPackages]
    if options.debian_packages:
        steps = [DebianPackages]

    if options.list_steps:
        # list steps if specified
        for step in steps:
            print(step.name())
        parser.exit()

    if options.all:
        # list available steps
        for sorted([]):
            raise NotImplementedError("TODO")

    # execute steps
    for step in steps:
        instance = step()
        instance()

if __name__ == '__main__':
    main()