"""%%prog %s [options] %s

CubicWeb main applications controller. 

%s"""

import sys

from os import remove, listdir, system, kill, getpgid

from os.path import exists, join, isfile, isdir

from cubicweb import ConfigurationError, ExecutionError, BadCommandUsage

from cubicweb.cwconfig import CubicWebConfiguration, CONFIGURATIONS

from cubicweb.toolsutils import (Command, register_commands, main_run, 

                                 rm, create_dir, pop_arg, confirm)

def wait_process_end(pid, maxtry=10, waittime=1):

    """wait for a process to actually die"""

    import signal

    from time import sleep

    nbtry = 0

    while nbtry < maxtry:

        try:

            kill(pid, signal.SIGUSR1)

        except OSError:

            break

        nbtry += 1

        sleep(waittime)

    else:

        raise ExecutionError('can\'t kill process %s' % pid)

def list_instances(regdir):

    return sorted(idir for idir in listdir(regdir) if isdir(join(regdir, idir)))

def detect_available_modes(templdir):

    modes = []

    for fname in ('schema', 'schema.py'):

        if exists(join(templdir, fname)):

            modes.append('repository')

            break

    for fname in ('data', 'views', 'views.py'):

        if exists(join(templdir, fname)):

            modes.append('web ui')

            break

    return modes

class ApplicationCommand(Command):

    """base class for command taking 0 to n application id as arguments

    (0 meaning all registered applications)

    """

    arguments = '[<application>...]'    

    options = (

        ("force",

         {'short': 'f', 'action' : 'store_true',

          'default': False,

          'help': 'force command without asking confirmation',

          }

         ),

        )

    actionverb = None

    def ordered_instances(self):

        """return instances in the order in which they should be started,

        considering $REGISTRY_DIR/startorder file if it exists (useful when

        some instances depends on another as external source

        """

        regdir = CubicWebConfiguration.registry_dir()

        _allinstances = list_instances(regdir)

        if isfile(join(regdir, 'startorder')):

            allinstances = []

            for line in file(join(regdir, 'startorder')):

                line = line.strip()

                if line and not line.startswith('#'):

                    try:

                        _allinstances.remove(line)

                        allinstances.append(line)

                    except ValueError:

                        print 'ERROR: startorder file contains unexistant instance %s' % line

            allinstances += _allinstances

        else:

            allinstances = _allinstances

        return allinstances

    def run(self, args):

        """run the <command>_method on each argument (a list of application

        identifiers)

        """

        if not args:

            args = self.ordered_instances()

            try:

                askconfirm = not self.config.force

            except AttributeError:

                # no force option

                askconfirm = False

        else:

            askconfirm = False

        self.run_args(args, askconfirm)

    def run_args(self, args, askconfirm):

        for appid in args:

            if askconfirm:

                print '*'*72

                if not confirm('%s application %r ?' % (self.name, appid)):

                    continue

            self.run_arg(appid)

    def run_arg(self, appid):

        cmdmeth = getattr(self, '%s_application' % self.name)

        try:

            cmdmeth(appid)

        except (KeyboardInterrupt, SystemExit):

            print >> sys.stderr, '%s aborted' % self.name

            sys.exit(2) # specific error code

        except (ExecutionError, ConfigurationError), ex:

            print >> sys.stderr, 'application %s not %s: %s' % (

                appid, self.actionverb, ex)

        except Exception, ex:

            import traceback

            traceback.print_exc()

            print >> sys.stderr, 'application %s not %s: %s' % (

                appid, self.actionverb, ex)

class ApplicationCommandFork(ApplicationCommand):

    """Same as `ApplicationCommand`, but command is forked in a new environment

    for each argument

    """

    def run_args(self, args, askconfirm):

        if len(args) > 1:

            forkcmd = ' '.join(w for w in sys.argv if not w in args)

        else:

            forkcmd = None

        for appid in args:

            if askconfirm:

                print '*'*72

                if not confirm('%s application %r ?' % (self.name, appid)):

                    continue

            if forkcmd:

                status = system('%s %s' % (forkcmd, appid))

                if status:

                    sys.exit(status)

            else:

                self.run_arg(appid)

# base commands ###############################################################

class ListCommand(Command):

    """List configurations, componants and applications.

    list available configurations, installed web and server componants, and

    registered applications

    """

    name = 'list'

    options = (

        ('verbose',

         {'short': 'v', 'action' : 'store_true', 

          'help': "display more information."}),        

        )

    def run(self, args):

        """run the command with its specific arguments"""

        if args:

            raise BadCommandUsage('Too much arguments')

        print 'CubicWeb version:', CubicWebConfiguration.cubicweb_version()

        print 'Detected mode:', CubicWebConfiguration.mode

        print

        print 'Available configurations:'

        for config in CONFIGURATIONS:

            print '*', config.name

            for line in config.__doc__.splitlines():

                line = line.strip()

                if not line:

                    continue

                print '   ', line

        print 

        try:

            cubesdir = CubicWebConfiguration.cubes_dir()

            namesize = max(len(x) for x in CubicWebConfiguration.available_cubes())

        except ConfigurationError, ex:

            print 'No cubes available:', ex

        except ValueError:

            print 'No cubes available in %s' % cubesdir

        else:

            print 'Available cubes (%s):' % cubesdir

            for cube in CubicWebConfiguration.available_cubes():

                if cube in ('CVS', '.svn', 'shared', '.hg'):

                    continue

                templdir = join(cubesdir, cube)

                try:

                    tinfo = CubicWebConfiguration.cube_pkginfo(cube)

                    tversion = tinfo.version

                except ConfigurationError:

                    tinfo = None

                    tversion = '[missing cube information]'

                print '* %s %s' % (cube.ljust(namesize), tversion)

                if self.config.verbose:

                    shortdesc = tinfo and (getattr(tinfo, 'short_desc', '')

                                           or tinfo.__doc__)

                    if shortdesc:

                        print '    '+ '    \n'.join(shortdesc.splitlines())

                    modes = detect_available_modes(templdir)

                    print '    available modes: %s' % ', '.join(modes)

        print

        try:

            regdir = CubicWebConfiguration.registry_dir()

        except ConfigurationError, ex:

            print 'No application available:', ex

            print

            return

        instances = list_instances(regdir)

        if instances:

            print 'Available applications (%s):' % regdir

            for appid in instances:

                modes = CubicWebConfiguration.possible_configurations(appid)

                if not modes:

                    print '* %s (BROKEN application, no configuration found)' % appid

                    continue

                print '* %s (%s)' % (appid, ', '.join(modes))

                try:

                    config = CubicWebConfiguration.config_for(appid, modes[0])

                except Exception, exc: 

                    print '    (BROKEN application, %s)' % exc

                    continue

        else:

            print 'No application available in %s' % regdir

        print

class CreateApplicationCommand(Command):

    """Create an application from a cube. This is an unified

    command which can handle web / server / all-in-one installation

    according to available parts of the software library and of the

    desired cube.

    <cube>

      the name of cube to use (list available cube names using

      the "list" command). You can use several cubes by separating

      them using comma (e.g. 'jpl,eemail')

    <application>

      an identifier for the application to create

    """

    name = 'create'

    arguments = '<cube> <application>'

    options = (

        ("config-level",

         {'short': 'l', 'type' : 'int', 'metavar': '<level>',

          'default': 0,

          'help': 'configuration level (0..2): 0 will ask for essential \

configuration parameters only while 2 will ask for all parameters',

          }

         ),

        ("config",

         {'short': 'c', 'type' : 'choice', 'metavar': '<install type>',

          'choices': ('all-in-one', 'repository', 'twisted'),

          'default': 'all-in-one',

          'help': 'installation type, telling which part of an application \

should be installed. You can list available configurations using the "list" \

command. Default to "all-in-one", e.g. an installation embedding both the RQL \

repository and the web server.',

          }

         ),

        )

    def run(self, args):

        """run the command with its specific arguments"""

        from logilab.common.textutils import get_csv

        configname = self.config.config

        cubes = get_csv(pop_arg(args, 1))

        appid = pop_arg(args)

        # get the configuration and helper

        CubicWebConfiguration.creating = True

        config = CubicWebConfiguration.config_for(appid, configname)

        config.set_language = False

        config.init_cubes(config.expand_cubes(cubes))

        helper = self.config_helper(config)

        # check the cube exists

        try:

            templdirs = [CubicWebConfiguration.cube_dir(cube)

                         for cube in cubes]

        except ConfigurationError, ex:

            print ex

            print '\navailable cubes:',

            print ', '.join(CubicWebConfiguration.available_cubes())

            return

        # create the registry directory for this application

        create_dir(config.apphome)

        # load site_cubicweb from the cubes dir (if any)

        config.load_site_cubicweb()

        # cubicweb-ctl configuration

        print '** application\'s %s configuration' % configname

        print '-' * 72

        config.input_config('main', self.config.config_level)

        # configuration'specific stuff

        print

        helper.bootstrap(cubes, self.config.config_level)

        # write down configuration

        config.save()

        # handle i18n files structure

        # XXX currently available languages are guessed from translations found

        # in the first cube given

        from cubicweb.common import i18n

        langs = [lang for lang, _ in i18n.available_catalogs(join(templdirs[0], 'i18n'))]

        errors = config.i18ncompile(langs)

        if errors:

            print '\n'.join(errors)

            if not confirm('error while compiling message catalogs, '

                           'continue anyway ?'):

                print 'creation not completed'

                return

        # create the additional data directory for this application

        if config.appdatahome != config.apphome: # true in dev mode

            create_dir(config.appdatahome)

        if config['uid']:

            from logilab.common.shellutils import chown

            # this directory should be owned by the uid of the server process

            print 'set %s as owner of the data directory' % config['uid']

            chown(config.appdatahome, config['uid'])

        print

        print

        print '*' * 72

        print 'application %s (%s) created in %r' % (appid, configname,

                                                     config.apphome)

        print

        helper.postcreate()

class DeleteApplicationCommand(Command):

    """Delete an application. Will remove application's files and

    unregister it.

    """

    name = 'delete'

    arguments = '<application>'

    options = ()

    def run(self, args):

        """run the command with its specific arguments"""

        appid = pop_arg(args, msg="No application specified !")

        configs = [CubicWebConfiguration.config_for(appid, configname)

                   for configname in CubicWebConfiguration.possible_configurations(appid)]

        if not configs:

            raise ExecutionError('unable to guess configuration for %s' % appid)

        for config in configs:

            helper = self.config_helper(config, required=False)

            if helper:

                helper.cleanup()

        # remove home

        rm(config.apphome)

        # remove instance data directory

        try:

            rm(config.appdatahome)

        except OSError, ex:

            import errno

            if ex.errno != errno.ENOENT:

                raise

        confignames = ', '.join([config.name for config in configs])

        print 'application %s (%s) deleted' % (appid, confignames)

# application commands ########################################################

class StartApplicationCommand(ApplicationCommand):

    """Start the given applications. If no application is given, start them all.

    <application>...

      identifiers of the applications to start. If no application is

      given, start them all.

    """

    name = 'start'

    actionverb = 'started'

    options = (

        ("debug",

         {'short': 'D', 'action' : 'store_true',

          'help': 'start server in debug mode.'}),

        ("force",

         {'short': 'f', 'action' : 'store_true',

          'default': False,

          'help': 'start the application even if it seems to be already \

running.'}),

        ('profile',

         {'short': 'P', 'type' : 'string', 'metavar': '<stat file>',

          'default': None,

          'help': 'profile code and use the specified file to store stats',

          }),

        )

    def start_application(self, appid):

        """start the application's server"""

        # use get() since start may be used from other commands (eg upgrade)

        # without all options defined

        debug = self.get('debug')

        force = self.get('force')

        config = CubicWebConfiguration.config_for(appid)

        if self.get('profile'):

            config.global_set_option('profile', self.config.profile)

        helper = self.config_helper(config, cmdname='start')

        pidf = config['pid-file']

        if exists(pidf) and not force:

            msg = "%s seems to be running. Remove %s by hand if necessary or use \

the --force option."

            raise ExecutionError(msg % (appid, pidf))

        command = helper.start_command(config, debug)

        if debug:

            print "starting server with command :"

            print command

        if system(command):