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

# Copyright 2007 - 2011, 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.cli import get_winsize, prog, w_err, w_std

from VirtualMailManager.common import human_size, size_in_bytes, 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

from VirtualMailManager.serviceset import SERVICES

__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_quota',

    'domain_services', 'domain_transport', 'get_user', 'help_', 'list_domains',

    'relocated_add', 'relocated_delete', 'relocated_info', 'user_add',

    'user_delete', 'user_info', 'user_name', 'user_password', 'user_quota',

    'user_services', 'user_transport', 'version',

)

_ = lambda msg: msg

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

cmd_map = {}

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.scmd = ctx.args[1] = 'userinfo'

            user_info(ctx)

        elif err.code is RELOCATED_EXISTS:

                  'object': address})

            ctx.scmd = 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.scmd = 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)

    noop = lambda option: option

    opt_formater = {

        'misc.dovecot_version': version_str,

        'misc.quota_bytes': human_size,

    }

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

    w_std('%s = %s' % (option, opt_formater.get(option,

                       noop)(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])

    if not ctx.cget('domain.auto_postmaster'):

        return

    ctx.scmd = 'useradd'

    ctx.args = [prog, ctx.scmd, u'postmaster@' + ctx.args[2].lower()]

    ctx.argc = 3

    user_add(ctx)

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.scmd = ctx.args[1] = 'aliasdomaininfo'

            aliasdomain_info(ctx)

        else:

            raise

    else:

        q_limit = u'Storage: %(bytes)s; Messages: %(messages)s'

        if not details:

            info['bytes'] = human_size(info['bytes'])

            info['messages'] = locale.format('%d', info['messages'], True)

            info['quota limit'] = q_limit % info

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

        else:

            info[0]['bytes'] = human_size(info[0]['bytes'])

            info[0]['messages'] = locale.format('%d', info[0]['messages'],

                                                True)

            info[0]['quota limit'] = q_limit % info[0]

            _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_quota(ctx):

    """update the quota limit of the specified domain"""

    if ctx.argc < 3:

        usage(EX_MISSING_ARGS, _(u'Missing domain name and storage value.'),

              ctx.scmd)

    if ctx.argc < 4:

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

    messages = 0

    force = None

    try:

        bytes_ = size_in_bytes(ctx.args[3])

    except (ValueError, TypeError):

        usage(INVALID_ARGUMENT, _(u"Invalid storage value: '%s'") %

              ctx.args[3], ctx.scmd)

    if ctx.argc < 5:

        pass

    elif ctx.argc < 6:

        try:

            messages = int(ctx.args[4])

        except ValueError:

            if ctx.args[4].lower() != 'force':

                usage(INVALID_ARGUMENT,

                      _(u"Neither a valid number of messages nor the keyword "

                        u"'force': '%s'") % ctx.args[4], ctx.scmd)

            force = 'force'

    else:

        try:

            messages = int(ctx.args[4])

        except ValueError:

            usage(INVALID_ARGUMENT,

                  _(u"Not a valid number of messages: '%s'") % ctx.args[4],

                  ctx.scmd)

        if ctx.args[5].lower() != 'force':

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

                  ctx.scmd)

        force = 'force'

    ctx.hdlr.domain_quotalimit(ctx.args[2].lower(), bytes_, messages, force)

def domain_services(ctx):

    """allow all named service and block the uncredited."""

    if ctx.argc < 3:

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

    services = []

    force = False

    if ctx.argc is 3:

        pass

    elif ctx.argc is 4:

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

        if arg in SERVICES:

            services.append(arg)

        elif arg == 'force':

            force = True

        else:

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

                  ctx.scmd)

    else:

        services.extend([service.lower() for service in ctx.args[3:-1]])

        arg = ctx.args[-1].lower()

        if arg == 'force':

            force = True

        else:

            services.append(arg)

        unknown = [service for service in services if service not in SERVICES]

        if unknown:

            usage(INVALID_ARGUMENT, _(u'Invalid service arguments: %s') %

                  ' '.join(unknown), ctx.scmd)

    ctx.hdlr.domain_services(ctx.args[2].lower(), (None, 'force')[force],

                             *services)

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: