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

# Copyright (c) 2007 - 2014, Pascal Volk

# See COPYING for distribution information.

"""

    VirtualMailManager.cli.subcommands

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

    VirtualMailManager's cli subcommands.

"""

import locale

import platform

from argparse import Action, ArgumentParser, ArgumentTypeError, \

     RawDescriptionHelpFormatter

from textwrap import TextWrapper

from time import strftime, strptime

from VirtualMailManager import ENCODING

from VirtualMailManager.cli import get_winsize, w_err, w_std

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, 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__ = (

    'RunContext', 'alias_add', 'alias_delete', 'alias_info', 'aliasdomain_add',

    'aliasdomain_delete', 'aliasdomain_info', 'aliasdomain_switch',

    'catchall_add', 'catchall_delete', 'catchall_info', 'config_get',

    'config_set', 'configure', 'domain_add', 'domain_delete', 'domain_info',

    'domain_note', 'domain_quota', 'domain_services', 'domain_transport',

    'get_user', 'list_addresses', 'list_aliases', 'list_domains',

    'list_pwschemes', 'list_relocated', 'list_users', 'relocated_add',

    'relocated_delete', 'relocated_info', 'setup_parser', 'user_add',

    'user_delete', 'user_info', 'user_name', 'user_note', 'user_password',

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

)

WS_ROWS = get_winsize()[1] - 2

_ = lambda msg: msg

txt_wrpr = TextWrapper(width=WS_ROWS)

class RunContext(object):

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

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

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

    def __init__(self, args, handler):

        """Create a new RunContext"""

        self.args = args

        self.cget = handler.cfg_dget

        self.hdlr = handler

def alias_add(ctx):

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

    ctx.hdlr.alias_add(ctx.args.address.lower(), *ctx.args.destination)

def alias_delete(ctx):

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

    destination = ctx.args.destination if ctx.args.destination else None

    ctx.hdlr.alias_delete(ctx.args.address.lower(), destination)

def alias_info(ctx):

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

    address = ctx.args.address.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.args.scmd = 'userinfo'

            ctx.args.details = None

            user_info(ctx)

        elif err.code is RELOCATED_EXISTS:

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

                  'object': address})

            ctx.args.scmd = 'relocatedinfo'

            relocated_info(ctx)

        else:

            raise

def aliasdomain_add(ctx):

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

    ctx.hdlr.aliasdomain_add(ctx.args.fqdn.lower(),

                             ctx.args.destination.lower())

def aliasdomain_delete(ctx):

    """delete the specified alias domain"""

    ctx.hdlr.aliasdomain_delete(ctx.args.fqdn.lower())

def aliasdomain_info(ctx):

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

    fqdn = ctx.args.fqdn.lower()

    try:

        _print_aliasdomain_info(ctx.hdlr.aliasdomain_info(fqdn))

    except VMMError as err:

        if err.code is ALIASDOMAIN_ISDOMAIN:

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

                                     'object': fqdn})

            ctx.args.scmd = 'domaininfo'

            domain_info(ctx)

        else:

            raise

def aliasdomain_switch(ctx):

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

    ctx.hdlr.aliasdomain_switch(ctx.args.fqdn.lower(),

                                ctx.args.destination.lower())

def catchall_add(ctx):

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

    ctx.hdlr.catchall_add(ctx.args.fqdn.lower(), *ctx.args.destination)

def catchall_delete(ctx):

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

    destination = ctx.args.destination if ctx.args.destination else None

    ctx.hdlr.catchall_delete(ctx.args.fqdn.lower(), destination)

def catchall_info(ctx):

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

    address = ctx.args.fqdn.lower()

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

def config_get(ctx):

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

    noop = lambda option: option

    opt_formater = {

        'misc.dovecot_version': version_str,

        'domain.quota_bytes': human_size,

    }

    option = ctx.args.option.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"""

    ctx.hdlr.cfg_set(ctx.args.option.lower(), ctx.args.value)

def configure(ctx):

    """start interactive configuration mode"""

    ctx.hdlr.configure(ctx.args.section)

def domain_add(ctx):

    """create a new domain"""

    fqdn = ctx.args.fqdn.lower()

    transport = ctx.args.transport.lower() if ctx.args.transport else None

    ctx.hdlr.domain_add(fqdn, transport, ctx.args.note)

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

        w_std(_('Creating account for postmaster@%s') % fqdn)

        ctx.args.scmd = 'useradd'

        ctx.args.address = 'postmaster@%s' % fqdn

        ctx.args.password = None

        ctx.args.note = None

        user_add(ctx)

def domain_delete(ctx):

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

    ctx.hdlr.domain_delete(ctx.args.fqdn.lower(), ctx.args.force)

def domain_info(ctx):

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

    fqdn = ctx.args.fqdn.lower()

    details = ctx.args.details

    try:

        info = ctx.hdlr.domain_info(fqdn, details)

    except VMMError as err:

        if err.code is DOMAIN_ALIAS_EXISTS:

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

                                     'object': fqdn})

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

            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)

            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"""

    ctx.hdlr.domain_quotalimit(ctx.args.fqdn.lower(), ctx.args.storage,

                               ctx.args.messages, ctx.args.force)

def domain_services(ctx):

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

    services = ctx.args.services if ctx.args.services else []

    ctx.hdlr.domain_services(ctx.args.fqdn.lower(), ctx.args.force, *services)

def domain_transport(ctx):

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

    ctx.hdlr.domain_transport(ctx.args.fqdn.lower(),

                              ctx.args.transport.lower(), ctx.args.force)

def domain_note(ctx):

    """update the note of the given domain"""

    ctx.hdlr.domain_note(ctx.args.fqdn.lower(), ctx.args.note)

def get_user(ctx):

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

    _print_info(ctx, ctx.hdlr.user_by_uid(ctx.args.uid), _('Account'))

def list_domains(ctx):

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

    matching = True if ctx.args.pattern else False

    pattern = ctx.args.pattern.lower() if matching else None

    gids, domains = ctx.hdlr.domain_list(pattern)

    _print_domain_list(gids, domains, matching)

def list_pwschemes(ctx_unused):

    """Prints all usable password schemes and password encoding suffixes."""

    keys = (_('Usable password schemes'), _('Usable encoding suffixes'))

    old_ii, old_si = txt_wrpr.initial_indent, txt_wrpr.subsequent_indent

    txt_wrpr.initial_indent = txt_wrpr.subsequent_indent = '\t'

    txt_wrpr.width = txt_wrpr.width - 8

    for key, value in zip(keys, list_schemes()):

        w_std(key, len(key) * '-')

        w_std('\n'.join(txt_wrpr.wrap(' '.join(sorted(value)))), '')

    txt_wrpr.initial_indent, txt_wrpr.subsequent_indent = old_ii, old_si

    txt_wrpr.width = txt_wrpr.width + 8

def list_addresses(ctx, limit=None):

    """List all addresses / search addresses by pattern. The output can be

    limited with TYPE_ACCOUNT, TYPE_ALIAS and TYPE_RELOCATED, which can be

    bitwise ORed as a combination. Not specifying a limit is the same as

    combining all three."""

    if limit is None:

        limit = TYPE_ACCOUNT | TYPE_ALIAS | TYPE_RELOCATED

    matching = True if ctx.args.pattern else False

    pattern = ctx.args.pattern.lower() if matching else None

    gids, addresses = ctx.hdlr.address_list(limit, pattern)

    _print_address_list(limit, gids, addresses, matching)

def list_users(ctx):

    """list all user accounts / search user accounts by pattern"""

    return list_addresses(ctx, TYPE_ACCOUNT)

def list_aliases(ctx):

    """list all aliases / search aliases by pattern"""

    return list_addresses(ctx, TYPE_ALIAS)

def list_relocated(ctx):

    """list all relocated records / search relocated records by pattern"""

    return list_addresses(ctx, TYPE_RELOCATED)

def relocated_add(ctx):

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

    ctx.hdlr.relocated_add(ctx.args.address.lower(), ctx.args.newaddress)

def relocated_delete(ctx):

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

    ctx.hdlr.relocated_delete(ctx.args.address.lower())

def relocated_info(ctx):

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

    relocated = ctx.args.address.lower()

    try:

        _print_relocated_info(addr=relocated,

                              dest=ctx.hdlr.relocated_info(relocated))

    except VMMError as err:

        if err.code is ACCOUNT_EXISTS:

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

                  'object': relocated})

            ctx.args.scmd = 'userinfo'

            ctx.args.details = None

            user_info(ctx)

        elif err.code is ALIAS_EXISTS:

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

                  'object': relocated})

            ctx.args.scmd = 'aliasinfo'

            alias_info(ctx)

        else:

            raise

def user_add(ctx):

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

    gen_pass = ctx.hdlr.user_add(ctx.args.address.lower(), ctx.args.password,

                                 ctx.args.note)

    if not ctx.args.password and gen_pass:

        w_std(_("Generated password: %s") % gen_pass)

def user_delete(ctx):

    """delete the specified user"""

def user_info(ctx):

    """display information about the given address"""

    address = ctx.args.address.lower()

    try:

        info = ctx.hdlr.user_info(address, ctx.args.details)

    except VMMError as err:

        if err.code is ALIAS_EXISTS:

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

                  'object': address})

            ctx.args.scmd = 'aliasinfo'

            alias_info(ctx)

        elif err.code is RELOCATED_EXISTS: