#!/usr/bin/env python

"""
templates for the A*Team's buildbot
"""

import os
import sys
from makeitso.cli import MakeItSoCLI
from makeitso.template import assemble
from makeitso.template import MakeItSoTemplate
from makeitso.template import Variable
from projects import factories
from StringIO import StringIO

try:
    from subprocess import check_call as call
except ImportError:
    from subprocess import call

def factory_descriptions():
    """print factory descriptions"""

    buffer = StringIO()
    print >> buffer, 'Factories:\n'
    for key in sorted(factories.keys()):
        print >> buffer, '%s:' % key
        print >> buffer, getattr(factories[key], '__doc__', '').strip()
        print >> buffer
    return buffer.getvalue()


class AutobotMasterTemplate(MakeItSoTemplate):
    name = 'autobot-master'
    description = 'template for the autotools buildbot master'
    templates = [os.path.join('template', 'master')]
    vars = [Variable('slave', 'buildslave name', 'slave'),
            Variable('passwd', 'buildslave password', default='passwd'),
            Variable('slaveport', 'port to talk to slaves on', default=9010, cast=int),
            Variable('htmlport', 'port for waterfall display', default=8010, cast=int)]

    def pre(self, variables):
        factory = variables.get('factory')
        if factory:
            assert factory in factories, 'Factory must be one of: ' % ', '.join(factories.keys())
        elif self.interactive:
            print factory_descriptions()
            sys.stdout.write('Enter factory: ')
            factory = raw_input()
            assert factory in factories, 'Factory must be one of: ' % ', '.join(factories.keys())
            variables['factory'] = factory
        else:
            raise AssertionError("No factory provided")

    def create(self, output, variables):
        command = ['buildbot', 'create-master', output]
        print ' '.join(command)
        call(command)

    def post(self, variables):
        """
        called after the template is applied
        """
        self.create(self.output, variables)

class AutobotSlaveTemplate(MakeItSoTemplate):
    name = 'autobot-slave'
    description = 'template for the autotools buildbot slave'
    templates = [os.path.join('template', 'slave')]
    vars = [Variable('master', 'host of the master', default='localhost'),
            Variable('slave', 'buildslave name', 'slave'),
            Variable('passwd', 'buildslave password', default='passwd'),
            Variable('slaveport', 'port to talk to slaves on', default=9010)]

    def create(self, output, variables):
        command = ['buildslave', 'create-slave', output,
                   '%s:%d' % (variables['master'], variables['slaveport']),
                   variables['slave'],
                   variables['passwd'] ]
        print ' '.join(command)
        call(command)
        

    def post(self, variables):
        self.create(self.output, variables)


class AutobotTemplate(AutobotMasterTemplate, AutobotSlaveTemplate):
    name = 'autobot'
    description = 'template for the autotools buildbot master+slave'
    templates = ['template']
    vars = assemble(AutobotMasterTemplate, AutobotSlaveTemplate)
    vars.append(Variable('debug', default=True, cast='eval'))

    def post(self, variables):
        AutobotMasterTemplate.create(self, os.path.join(self.output, 'master'), variables)
        AutobotSlaveTemplate.create(self, os.path.join(self.output, 'slave'), variables)

# CLI front end class

class AutobotMasterCLI(MakeItSoCLI):
    """
    command line handler for the master
    """
    def parser(self):
        parser = MakeItSoCLI.parser(self)
        parser.add_option('-f', '--factory', dest='factory',
                          help="factory to use")
        parser.add_option('--list-factories', dest='_list_factories',
                          default=False, action='store_true',
                          help="list available factories")
        return parser

    def parse(self, parser=None, options=None, args=None):

        # parse the command line                                                    
        if not parser or not options or not args:
            parser = self.parser()
            options, args = parser.parse_args()

        # list the factories
        if options._list_factories:
            print factory_descriptions()
            parser.exit()

        # call the parent
        MakeItSoCLI.parse(self, parser, options, args)


### console_script front-ends

def create_master(args=sys.argv[1:]):
    cli = AutobotMasterCLI(AutobotMasterTemplate)
    template = cli.parse()
    template.substitute()

def create_slave(args=sys.argv[1:]):
    cli = MakeItSoCLI(AutobotSlaveTemplate)
    template = cli.parse()
    template.substitute()

def create_autobot(args=sys.argv[1:]):
    cli = AutobotMasterCLI(AutobotTemplate)
    template = cli.parse()
    template.substitute()

if __name__ == '__main__':
    create_master()