#!/usr/bin/env python

#   Copyright 2021 Red Hat, Inc.
#
#   Licensed under the Apache License, Version 2.0 (the "License"); you may
#   not use this file except in compliance with the License. You may obtain
#   a copy of the License at
#
#        http://www.apache.org/licenses/LICENSE-2.0
#
#   Unless required by applicable law or agreed to in writing, software
#   distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
#   WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
#   License for the specific language governing permissions and limitations
#   under the License.

import os
import sys

from cliff.app import App
from cliff.commandmanager import CommandManager

from validations_libs import utils


class ValidationCliApp(App):
    """Cliff application for the `ValidationCli` tool.
    :param description: one-liner explaining the program purpose
    :param version: application version number
    :param command_manager: plugin loader
    :param deferred_help: Allow subcommands to accept `--help` with allowing
    to defer help print after initialize_app
    """

    def __init__(self):
        super(ValidationCliApp, self).__init__(
            description="Validations Framework Command Line Interface (CLI)",
            version='1.0',
            command_manager=CommandManager('validation.cli'),
            deferred_help=True,
            )

    def initialize_app(self, argv):
        self.LOG.debug('Initialize Validation App.')

    def prepare_to_run_command(self, cmd):
        self.LOG.debug(
            'prepare_to_run_command {}'.format(cmd.__class__.__name__))

    def clean_up(self, cmd, result, err):
        self.LOG.debug(
            'clean_up {}'.format(cmd.__class__.__name__))
        if err:
            self.LOG.debug('got an error: {}'.format(err))

    def _format_arg(self):
        namespace, argv = self.parser.parse_known_args()
        return [arg.lstrip(self.parser.prefix_chars).replace('-', '_')
                for arg in argv]

    def set_argument_parser(self, parser, section='default'):
        """ Set Arguments parser depending of the precedence ordering:
            * User CLI arguments
            * Configuration file
            * Default CLI values
        """
        cli_args = self._format_arg()
        args, _ = parser.parse_known_args()
        config = utils.load_config(os.path.abspath(args.config))
        config_args = config.get(section, {})
        for key, value in args._get_kwargs():
            # matbu: manage the race when user's cli arg is the same than
            # the parser default value. The user's cli arg will *always*
            # takes precedence on others.
            if parser.get_default(key) == value and key in cli_args:
                try:
                    cli_value = cli_args[cli_args.index(key)+1]
                    config_args.update({key: cli_value})
                except KeyError:
                    self.LOG.warning('Key not found in cli: {}').format(key)
            elif parser.get_default(key) != value:
                config_args.update({key: value})
            elif key not in config_args.keys():
                config_args.update({key: value})
        parser.set_defaults(**config_args)
        return parser


def main(argv=sys.argv[1:]):
    v_cli = ValidationCliApp()
    return v_cli.run(argv)


if __name__ == '__main__':
    sys.exit(main(sys.argv[1:]))