#!/usr/bin/env python
# -*- coding: utf-8 -*-

__credits__ = """
    Copyright (C) 2012 YunoHost

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU Affero General Public License as published
    by the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU Affero General Public License for more details.

    You should have received a copy of the GNU Affero General Public License
    along with this program; if not, see http://www.gnu.org/licenses
    """
__author__  = 'Kload <kload@kload.fr>'
__version__ = '2.0 beta1'

import os
import sys
import argparse
import gettext
import json
if not __debug__:
    import traceback

sys.path.append('lib')
gettext.install('YunoHost')

from yunohost import YunoHostError, str_to_func, colorize, pretty_print_dict


"""
Category/actions/arguments dictionnary


Except for general_arguments, this dictionary contains 3 levels
as in this sample command line :

    yunohost   monitor    info    --cpu --ram
       ^          ^         ^          ^
    (script) | category | action | parameters


Above example will lead to the function 'monitor_info(args)'
in the file 'lib/yunohost_monitor.py' with 'cpu' and 'ram'
stored in args dictionnary.

Usage:
    You can add a category at the first level, action at the second one,
    and arguments at the third one.

Documentation:
    You can see all arguments settings at the argparse documentation:
    http://docs.python.org/dev/library/argparse.html
    #argparse.ArgumentParser.add_argument

    Don't forget to turn them as a dictionnary ('setting' : 'value')

"""
action_dict = { 
    #############################
    #       General args        #
    #############################
    'general_arguments' : {
        '-v' : {
            'full'      : '--version',
            'help'      : 'Display %(prog)s version',
            'action'    : 'version',
            'version'   : '%(prog)s ' + __version__,
        },
    },
    #############################
    #           User            #
    #############################
    'user' : {
        'help'    : 'Manage users',
        'actions' : {
            ### user_list()
            'list'      : {
                'help'      : 'List users',
                'arguments' : {
                   '-a' : {
                        'full'      : '--all',
                        'help'      : 'Display all users',
                        'action'    : 'store_true'
                   },
                }
            },
            ### user_add()
            'add'       : {
                'help'      : 'Create user',
                'arguments' : {
                    '-u' : {
                        'full'      : '--username',
                    },
                    '-f' : {
                        'full'      : '--firstname',
                    },
                    '-l' : {
                        'full'      : '--lastname',
                    },
                    '-m' : {
                        'full'      : '--mail',
                    },
                    '-p' : {
                        'full'      : '--password',
                    }, 
                }
            },
            'info'      : {
                'help'      : 'Get user informations',
            },
        }
    },
    'domain' : {
        'help'    : 'Manage domains',
        'actions' : {}
    },
    'app' : {
        'help'    : 'Manage apps',
        'actions' : {}
    },
    'monitor' : {
        'help'    : 'Monitoring functions',
        'actions' : {}
    },
    'tools' : {
        'help'    : 'Specific tools',
        'actions' : {}
    }
}

def dict_to_args(action_dict):
    """
    Turn action dictionnary to parser, subparsers and arguments
    
    Keyword arguments:
        action_dict -- Multi-level dictionnary of categories/actions/arguments list
    
    Returns: 
        Namespace of args

    """
    # Intialize parsers
    parsers = subparsers_category = subparsers_action = {}
    parsers['general'] = argparse.ArgumentParser()
    subparsers = parsers['general'].add_subparsers()

    # Add general arguments
    for arg_name, arg_params in action_dict['general_arguments'].items():
        if arg_params['full']:
            arg_fullname = arg_params['full']
            del arg_params['full']
            parsers['general'].add_argument(arg_name, arg_fullname, **arg_params)
        else:
            parsers['general'].add_argument(arg_name, **arg_params)

    del action_dict['general_arguments'] 

    # Split categories into subparsers
    for category, cat_params in action_dict.items():
        subparsers_category[category] = subparsers.add_parser(category, help=cat_params['help'])
        subparsers_action[category] = subparsers_category[category].add_subparsers()
        # Split actions
        for action, action_params in cat_params['actions'].items():
            parsers[category + '_' + action] = subparsers_action[category].add_parser(action, help=action_params['help'])
            # Set the action's related function
            parsers[category + '_' + action].set_defaults(
                func=str_to_func('yunohost_' + category + '.' 
                                 + category + '_' + action)) 
            # Add arguments
            if 'arguments' in action_params:
                for arg_name, arg_params in action_params['arguments'].items():
                    if arg_params['full']:
                        arg_fullname = arg_params['full']
                        del arg_params['full']
                        parsers[category + '_' + action].add_argument(arg_name, arg_fullname, **arg_params)
                    else:
                        parsers[category + '_' + action].add_argument(arg_name, **arg_params)

    args = parsers['general'].parse_args()
    return args

def main():
    """ 
    Main instructions 
   
    Parse the action_dict and execute the action-specific function,
    then print json or pretty result if executed in a tty :)

    Returns:
        int -- 0 or error code
    
    """ 
    try:
        args = dict_to_args(action_dict) 
        result = args.func(vars(args))
    except YunoHostError, error:
        if not __debug__ :
            traceback.print_exc()
        if os.isatty(1):
            print('\n' + colorize(_('Error: '), 'red') + error.message)
        else:
            print(json.dumps({ 'error' : error.message }))
        return error.code
    else: 
        if os.isatty(1):
            pretty_print_dict(result)
        else:
            print(json.dumps(result))
        return 0        

if __name__ == '__main__':
    sys.exit(main())