# -*- coding: UTF-8 -*-

# Copyright 2007 - 2010, Pascal Volk

# See COPYING for distribution information.

"""

    VirtualMailManager.cli.subcommands

    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    VirtualMailManager's cli subcommands.

"""

import locale

import os

from textwrap import TextWrapper

from time import strftime, strptime

from VirtualMailManager import ENCODING

from VirtualMailManager.account import SERVICES

from VirtualMailManager.cli import get_winsize, prog, w_err, w_std

from VirtualMailManager.common import version_str

from VirtualMailManager.constants import __copyright__, __date__, \

     __version__, ACCOUNT_EXISTS, ALIAS_EXISTS, ALIASDOMAIN_ISDOMAIN, \

     DOMAIN_ALIAS_EXISTS, INVALID_ARGUMENT, EX_MISSING_ARGS, RELOCATED_EXISTS

from VirtualMailManager.errors import VMMError

__all__ = (

    'Command', 'RunContext', 'cmd_map', 'usage', 'alias_add', 'alias_delete',

    'alias_info', 'aliasdomain_add', 'aliasdomain_delete', 'aliasdomain_info',

    'aliasdomain_switch', 'config_get', 'config_set', 'configure',

    'domain_add', 'domain_delete',  'domain_info', 'domain_transport',

    'get_user', 'help_', 'list_domains', 'relocated_add', 'relocated_delete',

    'relocated_info', 'user_add', 'user_delete', 'user_disable', 'user_enable',

    'user_info', 'user_name', 'user_password', 'user_transport', 'version',

)

_ = lambda msg: msg

txt_wrpr = TextWrapper(width=get_winsize()[1] - 1)

class Command(object):

    """Container class for command information."""

    __slots__ = ('name', 'alias', 'func', 'args', 'descr')

    def __init__(self, name, alias, func, args, descr):

        """Create a new Command instance.

        Arguments:

        `name` : str

          the command name, e.g. ``addalias``

        `alias` : str

          the command's short alias, e.g. ``aa``

        `func` : callable

          the function to handle the command

        `args` : str

          argument placeholders, e.g. ``aliasaddress``

        `descr` : str

          short description of the command

        """

        self.name = name

        self.alias = alias

        self.func = func

        self.args = args

        self.descr = descr

    @property

    def usage(self):

        """the command's usage info."""

        return u'%s %s %s' % (prog, self.name, self.args)

class RunContext(object):

    """Contains all information necessary to run a subcommand."""

    __slots__ = ('argc', 'args', 'cget', 'hdlr', 'scmd')

    plan_a_b = _(u'Plan A failed ... trying Plan B: %(subcommand)s %(object)s')

    def __init__(self, argv, handler, command):

        """Create a new RunContext"""

        self.argc = len(argv)

        self.args = [unicode(arg, ENCODING) for arg in argv]

        self.cget = handler.cfg_dget

        self.hdlr = handler

        self.scmd = command

def alias_add(ctx):

    """create a new alias e-mail address"""

    if ctx.argc < 3:

        usage(EX_MISSING_ARGS, _(u'Missing alias address and destination.'),

              ctx.scmd)

    elif ctx.argc < 4:

        usage(EX_MISSING_ARGS, _(u'Missing destination address.'), ctx.scmd)

    ctx.hdlr.alias_add(ctx.args[2].lower(), *ctx.args[3:])

def alias_delete(ctx):

    """delete the specified alias e-mail address or one of its destinations"""

    if ctx.argc < 3:

        usage(EX_MISSING_ARGS, _(u'Missing alias address.'), ctx.scmd)

    elif ctx.argc < 4:

        ctx.hdlr.alias_delete(ctx.args[2].lower())

    else:

        ctx.hdlr.alias_delete(ctx.args[2].lower(), ctx.args[3])

def alias_info(ctx):

    """show the destination(s) of the specified alias"""

    if ctx.argc < 3:

        usage(EX_MISSING_ARGS, _(u'Missing alias address.'), ctx.scmd)

    address = ctx.args[2].lower()

    try:

        _print_aliase_info(address, ctx.hdlr.alias_info(address))

    except VMMError, err:

        if err.code is ACCOUNT_EXISTS:

            w_err(0, ctx.plan_a_b % {'subcommand': u'userinfo',

                  'object': address})

            ctx.args[1] = 'userinfo'

            user_info(ctx)

        elif err.code is RELOCATED_EXISTS:

            w_std(0, ctx.plan_a_b % {'subcommand': u'relocatedinfo',

                  'object': address})

            ctx.args[1] = 'relocatedinfo'

            relocated_info(ctx)

        else:

            raise

def aliasdomain_add(ctx):

    """create a new alias for an existing domain"""

    if ctx.argc < 3:

        usage(EX_MISSING_ARGS, _(u'Missing alias domain name and destination '

                                 u'domain name.'), ctx.scmd)

    elif ctx.argc < 4:

        usage(EX_MISSING_ARGS, _(u'Missing destination domain name.'),

              ctx.scmd)

    ctx.hdlr.aliasdomain_add(ctx.args[2].lower(), ctx.args[3].lower())

def aliasdomain_delete(ctx):

    """delete the specified alias domain"""

    if ctx.argc < 3:

        usage(EX_MISSING_ARGS, _(u'Missing alias domain name.'), ctx.scmd)

    ctx.hdlr.aliasdomain_delete(ctx.args[2].lower())

def aliasdomain_info(ctx):

    """show the destination of the given alias domain"""

    if ctx.argc < 3:

        usage(EX_MISSING_ARGS, _(u'Missing alias domain name.'), ctx.scmd)

    try:

        _print_aliasdomain_info(ctx.hdlr.aliasdomain_info(ctx.args[2].lower()))

    except VMMError, err:

        if err.code is ALIASDOMAIN_ISDOMAIN:

            w_err(0, ctx.plan_a_b % {'subcommand': u'domaininfo',

                  'object': ctx.args[2].lower()})

            ctx.args[1] = 'domaininfo'

            domain_info(ctx)

        else:

            raise

def aliasdomain_switch(ctx):

    """assign the given alias domain to an other domain"""

    if ctx.argc < 3:

        usage(EX_MISSING_ARGS, _(u'Missing alias domain name and destination '

                                 u'domain name.'), ctx.scmd)

    elif ctx.argc < 4:

        usage(EX_MISSING_ARGS, _(u'Missing destination domain name.'),

              ctx.scmd)

    ctx.hdlr.aliasdomain_switch(ctx.args[2].lower(), ctx.args[3].lower())

def config_get(ctx):

    """show the actual value of the configuration option"""

    if ctx.argc < 3:

        usage(EX_MISSING_ARGS, _(u"Missing option name."), ctx.scmd)

    option = ctx.args[2].lower()

    if option != 'misc.dovecot_version':

        w_std('%s = %s' % (option, ctx.cget(option)))

    else:

        w_std('%s = %s' % (option, version_str(ctx.cget(option))))

def config_set(ctx):

    """set a new value for the configuration option"""

    if ctx.argc < 3:

        usage(EX_MISSING_ARGS, _(u'Missing option and new value.'), ctx.scmd)

    if ctx.argc < 4:

        usage(EX_MISSING_ARGS, _(u'Missing new configuration value.'),

              ctx.scmd)

    ctx.hdlr.cfg_set(ctx.args[2].lower(), ctx.args[3])

def configure(ctx):

    """start interactive configuration modus"""

    if ctx.argc < 3:

        ctx.hdlr.configure()

    else:

        ctx.hdlr.configure(ctx.args[2].lower())

def domain_add(ctx):

    """create a new domain"""

    if ctx.argc < 3:

        usage(EX_MISSING_ARGS, _(u'Missing domain name.'), ctx.scmd)

    elif ctx.argc < 4:

        ctx.hdlr.domain_add(ctx.args[2].lower())

    else:

        ctx.hdlr.domain_add(ctx.args[2].lower(), ctx.args[3])

def domain_delete(ctx):

    """delete the given domain and all its alias domains"""

    if ctx.argc < 3:

        usage(EX_MISSING_ARGS, _(u'Missing domain name.'), ctx.scmd)

    elif ctx.argc < 4:

        ctx.hdlr.domain_delete(ctx.args[2].lower())

    elif ctx.args[3].lower() == 'force':

        ctx.hdlr.domain_delete(ctx.args[2].lower(), True)

    else:

        usage(INVALID_ARGUMENT, _(u"Invalid argument: '%s'") % ctx.args[3],

              ctx.scmd)

def domain_info(ctx):

    """display information about the given domain"""

    if ctx.argc < 3:

        usage(EX_MISSING_ARGS, _(u'Missing domain name.'), ctx.scmd)

    if ctx.argc < 4:

        details = None

    else:

        details = ctx.args[3].lower()

        if details not in ('accounts', 'aliasdomains', 'aliases', 'full',

                           'relocated'):

            usage(INVALID_ARGUMENT, _(u"Invalid argument: '%s'") % details,

                  ctx.scmd)

    try:

        info = ctx.hdlr.domain_info(ctx.args[2].lower(), details)

    except VMMError, err:

        if err.code is DOMAIN_ALIAS_EXISTS:

            w_err(0, ctx.plan_a_b % {'subcommand': u'aliasdomaininfo',

                  'object': ctx.args[2].lower()})

            ctx.args[1] = 'aliasdomaininfo'

            aliasdomain_info(ctx)

        else:

            raise

    else:

        if not details:

            _print_info(ctx, info, _(u'Domain'))

        else:

            _print_info(ctx, info[0], _(u'Domain'))

            if details == u'accounts':

                _print_list(info[1], _(u'accounts'))

            elif details == u'aliasdomains':

                _print_list(info[1], _(u'alias domains'))

            elif details == u'aliases':

                _print_list(info[1], _(u'aliases'))

            elif details == u'relocated':

                _print_list(info[1], _(u'relocated users'))

            else:

                _print_list(info[1], _(u'alias domains'))

                _print_list(info[2], _(u'accounts'))

                _print_list(info[3], _(u'aliases'))

                _print_list(info[4], _(u'relocated users'))

def domain_transport(ctx):

    """update the transport of the specified domain"""

    if ctx.argc < 3:

        usage(EX_MISSING_ARGS, _(u'Missing domain name and new transport.'),

              ctx.scmd)

    if ctx.argc < 4:

        usage(EX_MISSING_ARGS, _(u'Missing new transport.'), ctx.scmd)

    if ctx.argc < 5:

        ctx.hdlr.domain_transport(ctx.args[2].lower(), ctx.args[3])

    else:

        force = ctx.args[4].lower()

        if force != 'force':

            usage(INVALID_ARGUMENT, _(u"Invalid argument: '%s'") % force,

                  ctx.scmd)

        ctx.hdlr.domain_transport(ctx.args[2].lower(), ctx.args[3], force)

def get_user(ctx):

    """get the address of the user with the given UID"""

    if ctx.argc < 3:

        usage(EX_MISSING_ARGS, _(u'Missing userid.'), ctx.scmd)

    _print_info(ctx, ctx.hdlr.user_by_uid(ctx.args[2]), _(u'Account'))

def help_(ctx):

    """print help messgaes."""

    if ctx.argc > 2:

        hlptpc = ctx.args[2].lower()

        if hlptpc in cmd_map:

            topic = hlptpc

        else:

            for scmd in cmd_map.itervalues():

                if scmd.alias == hlptpc:

                    topic = scmd.name

                    break

            else:

                usage(INVALID_ARGUMENT, _(u"Unknown help topic: '%s'") %

                      ctx.args[2], ctx.scmd)

        # FIXME

        w_err(1, "'help %s' not yet implemented." % topic, 'see also: vmm(1)')

    old_ii = txt_wrpr.initial_indent

    old_si = txt_wrpr.subsequent_indent

    txt_wrpr.initial_indent = ' '

    # len(max(_overview.iterkeys(), key=len)) #Py25

    txt_wrpr.subsequent_indent = 20 * ' '

    order = cmd_map.keys()

    order.sort()

    w_std(_(u'List of available subcommands:') + '\n')

    for key in order:

        w_std('\n'.join(txt_wrpr.wrap('%-18s %s' % (key, cmd_map[key].descr))))

    txt_wrpr.initial_indent = old_ii

    txt_wrpr.subsequent_indent = old_si

    txt_wrpr.initial_indent = ''

def list_domains(ctx):

    """list all domains / search domains by pattern"""

    matching = ctx.argc > 2

    if matching:

        gids, domains = ctx.hdlr.domain_list(ctx.args[2].lower())

    else:

        gids, domains = ctx.hdlr.domain_list()

    _print_domain_list(gids, domains, matching)

def relocated_add(ctx):

    """create a new record for a relocated user"""

    if ctx.argc < 3:

        usage(EX_MISSING_ARGS,

              _(u'Missing relocated address and destination.'), ctx.scmd)

    elif ctx.argc < 4:

        usage(EX_MISSING_ARGS, _(u'Missing destination address.'), ctx.scmd)

    ctx.hdlr.relocated_add(ctx.args[2].lower(), ctx.args[3])

def relocated_delete(ctx):

    """delete the record of the relocated user"""

    if ctx.argc < 3:

        usage(EX_MISSING_ARGS, _(u'Missing relocated address.'), ctx.scmd)

    ctx.hdlr.relocated_delete(ctx.args[2].lower())

def relocated_info(ctx):

    """print information about a relocated user"""

    if ctx.argc < 3:

        usage(EX_MISSING_ARGS, _(u'Missing relocated address.'), ctx.scmd)

    relocated = ctx.args[2].lower()

    try:

        _print_relocated_info(addr=relocated,

                              dest=ctx.hdlr.relocated_info(relocated))

    except VMMError, err:

        if err.code is ACCOUNT_EXISTS:

            w_err(0, ctx.plan_a_b % {'subcommand': u'userinfo',

                  'object': relocated})

            ctx.args[1] = 'userinfoi'

            user_info(ctx)

        elif err.code is ALIAS_EXISTS:

            w_err(0, ctx.plan_a_b % {'subcommand': u'aliasinfo',

                  'object': relocated})

            ctx.args[1] = 'aliasinfo'

            alias_info(ctx)

        else:

            raise

def user_add(ctx):

    """create a new e-mail user with the given address"""