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

# Copyright (c) 2007 - 2012, 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.cli.clihelp import help_msgs

from VirtualMailManager.common import human_size, size_in_bytes, \

     version_str, format_domain_default

from VirtualMailManager.constants import __copyright__, __date__, \

     __version__, ACCOUNT_EXISTS, ALIAS_EXISTS, ALIASDOMAIN_ISDOMAIN, \

     DOMAIN_ALIAS_EXISTS, INVALID_ARGUMENT, EX_MISSING_ARGS, \

     RELOCATED_EXISTS, TYPE_ACCOUNT, TYPE_ALIAS, TYPE_RELOCATED

from VirtualMailManager.errors import VMMError

from VirtualMailManager.password import list_schemes

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', 'catchall_add', 'catchall_info', 'catchall_delete',

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

    'domain_add', 'domain_delete',  'domain_info', 'domain_quota',

    'domain_services', 'domain_transport', 'domain_note', 'get_user', 'help_',

    'list_domains', 'list_pwschemes', 'list_users', 'list_aliases',

    'list_relocated', 'list_addresses', 'relocated_add', 'relocated_delete',

    'relocated_info', 'user_add', 'user_delete', 'user_info', 'user_name',

    'user_password', 'user_quota', 'user_services', 'user_transport',

    'user_note', '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')

    FMT_HLP_USAGE = """

usage: %(prog)s %(name)s %(args)s

       %(prog)s %(alias)s %(args)s

"""

    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 '%s %s %s' % (prog, self.name, self.args)

    def help_(self):

        """Print the Command's help message to stdout."""

        old_ii = txt_wrpr.initial_indent

        old_si = txt_wrpr.subsequent_indent

        txt_wrpr.subsequent_indent = (len(self.name) + 2) * ' '

        w_std(txt_wrpr.fill('%s: %s' % (self.name, self.descr)))

        info = Command.FMT_HLP_USAGE % dict(alias=self.alias, args=self.args,

                                            name=self.name, prog=prog)

        w_std(info)

        txt_wrpr.initial_indent = txt_wrpr.subsequent_indent = ' '

        try:

            [w_std(txt_wrpr.fill(_(para)) + '\n') for para

                    in help_msgs[self.name]]

        except KeyError:

            w_err(1, _("Subcommand '%s' is not yet documented." % self.name),

                  'see also: vmm(1)')

class RunContext(object):

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

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

    plan_a_b = _('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 = [str(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, _('Missing alias address and destination.'),

              ctx.scmd)

    elif ctx.argc < 4:

        usage(EX_MISSING_ARGS, _('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, _('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, _('Missing alias address.'), ctx.scmd)

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

    try:

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

    except VMMError as err:

        if err.code is ACCOUNT_EXISTS:

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

                  'object': address})

            ctx.scmd = ctx.args[1] = 'userinfo'

            user_info(ctx)

        elif err.code is RELOCATED_EXISTS:

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

                  '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, _('Missing alias domain name and destination '

                                 'domain name.'), ctx.scmd)

    elif ctx.argc < 4:

        usage(EX_MISSING_ARGS, _('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, _('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, _('Missing alias domain name.'), ctx.scmd)

    try:

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

    except VMMError as err:

        if err.code is ALIASDOMAIN_ISDOMAIN:

            w_err(0, ctx.plan_a_b % {'subcommand': '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, _('Missing alias domain name and destination '

                                 'domain name.'), ctx.scmd)

    elif ctx.argc < 4:

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

              ctx.scmd)

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

def catchall_add(ctx):

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

    if ctx.argc < 3:

        usage(EX_MISSING_ARGS, _('Missing domain and destination.'),

              ctx.scmd)

    elif ctx.argc < 4:

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

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

def catchall_delete(ctx):

    """delete the specified destination or all of the catchall destination"""

    if ctx.argc < 3:

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

    elif ctx.argc < 4:

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

    else:

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

def catchall_info(ctx):

    """show the catchall destination(s) of the specified domain"""

    if ctx.argc < 3:

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

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

    _print_catchall_info(address, ctx.hdlr.catchall_info(address))

def config_get(ctx):

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

    if ctx.argc < 3:

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

    noop = lambda option: option

    opt_formater = {

        'misc.dovecot_version': version_str,

        'domain.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, _('Missing option and new value.'), ctx.scmd)

    if ctx.argc < 4:

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

              ctx.scmd)

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

def configure(ctx):

    """start interactive configuration mode"""

    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, _('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 ctx.cget('domain.auto_postmaster'):

        w_std(_('Creating account for postmaster@%s') % ctx.args[2].lower())

        ctx.scmd = 'useradd'

        ctx.args = [prog, ctx.scmd, '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, _('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, _("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, _('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', 'catchall'):

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

                  ctx.scmd)

    try:

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

    except VMMError as err:

        if err.code is DOMAIN_ALIAS_EXISTS:

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

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

            ctx.scmd = ctx.args[1] = 'aliasdomaininfo'

            aliasdomain_info(ctx)

        else:

            raise

    else:

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

        if not details:

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

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

                                             True).decode(ENCODING, 'replace')

            info['quota limit/user'] = q_limit % info

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

        else:

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

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

                                                True).decode(ENCODING,

                                                             'replace')

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

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

            if details == 'accounts':

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

            elif details == 'aliasdomains':

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

            elif details == 'aliases':

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

            elif details == 'relocated':

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

            elif details == 'catchall':

                _print_list(info[1], _('catch-all destinations'))

            else:

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

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

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

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

                _print_list(info[5], _('catch-all destinations'))

def domain_quota(ctx):

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

    if ctx.argc < 3:

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

              ctx.scmd)

    if ctx.argc < 4:

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

    messages = 0

    force = None

    try: