#!/usr/bin/env python3

# Copyright lowRISC contributors.
# Licensed under the Apache License, Version 2.0, see LICENSE for details.
# SPDX-License-Identifier: Apache-2.0

import argparse
import os
import shlex
import sys

import yaml

_DEFAULT_CONFIG_FILE = 'ibex_configs.yaml'


class ConfigException(Exception):
    pass


class Config:
    '''An object representing an Ibex configuration'''
    known_fields = [
        ('BaseIsa', str),
        ('RV32E', bool),
        ('RV32M', str),
        ('RV32B', str),
        ('RV32ZC', str),
        ('RegFile', str),
        ('BranchTargetALU', bool),
        ('WritebackStage', bool),
        ('ICache', bool),
        ('ICacheECC', bool),
        ('ICacheScramble', bool),
        ('BranchPredictor', bool),
        ('DbgTriggerEn', bool),
        ('SecureIbex', bool),
        ('PMPEnable', bool),
        ('PMPGranularity', int),
        ('PMPNumRegions', int),
        ('MHPMCounterNum', int),
        ('MHPMCounterWidth', int)
    ]

    def __init__(self, yml):
        if not isinstance(yml, dict):
            raise ValueError('Configuration object is not a dict')

        yaml_keys = set(yml.keys())
        known_keys = {fld for (fld, typ) in Config.known_fields}

        extra_keys = yaml_keys - known_keys
        if extra_keys:
            raise ValueError(f'Configuration object has '
                             f'unknown keys: {extra_keys}')

        missing_keys = known_keys - yaml_keys
        if missing_keys:
            raise ValueError(f'Configuration object has '
                             f'missing keys: {extra_keys}')

        self.params = yml

        self.base_isa = Config.read_str('BaseIsa', yml)
        self.rv32e = Config.read_bool('RV32E', yml)
        self.rv32m = Config.read_str('RV32M', yml)
        self.rv32b = Config.read_str('RV32B', yml)
        self.rv32zc = Config.read_str('RV32ZC', yml)
        self.reg_file = Config.read_str('RegFile', yml)
        self.branch_target_alu = Config.read_bool('BranchTargetALU', yml)
        self.writeback_stage = Config.read_bool('WritebackStage', yml)
        self.icache = Config.read_bool('ICache', yml)
        self.icache_ecc = Config.read_bool('ICacheECC', yml)
        self.icache_scramble = Config.read_bool('ICacheScramble', yml)
        self.branch_predictor = Config.read_bool('BranchPredictor', yml)
        self.dbg_trigger_en = Config.read_bool('DbgTriggerEn', yml)
        self.secure_ibex = Config.read_bool('SecureIbex', yml)
        self.pmp_enable = Config.read_bool('PMPEnable', yml)
        self.pmp_granularity = Config.read_int('PMPGranularity', yml)
        self.pmp_num_regions = Config.read_int('PMPNumRegions', yml)
        self.mhpm_counter_num = Config.read_int('MHPMCounterNum', yml)
        self.mhpm_counter_width = Config.read_int('MHPMCounterWidth', yml)

    @staticmethod
    def read_bool(fld, yml):
        val = yml[fld]
        if isinstance(val, bool):
            return val
        if isinstance(val, int):
            if 0 <= val <= 1:
                return val != 0

            raise ValueError(f'{fld} value is {val}, which is out of '
                             'range for a boolean type.')
        raise ValueError(f'{fld} value is {val!r}, but we expected a bool.')

    @staticmethod
    def read_int(fld, yml):
        val = yml[fld]
        if isinstance(val, int):
            return val
        raise ValueError(f'{fld} value is {val!r}, but we expected an int.')

    @staticmethod
    def read_str(fld, yml):
        val = yml[fld]
        if isinstance(val, str):
            return val
        raise ValueError(f'{fld} value is {val!r}, but we expected a string.')


class Configs:
    def __init__(self, yml):
        if not isinstance(yml, dict):
            raise ValueError('Configurations dictionary is not a dict')

        self.configs = {}
        for cfg_name, cfg_yaml in yml.items():
            try:
                self.configs[cfg_name] = Config(cfg_yaml)
            except ValueError as err:
                raise ValueError(f'Error when reading '
                                 f'{cfg_name!r} config: {err}') from None


class FusesocOpts:
    def setup_args(self, arg_subparser):
        output_argparser = arg_subparser.add_parser(
            'fusesoc_opts', help=('Outputs options for fusesoc'))
        output_argparser.set_defaults(output_fn=self.output)

    def output(self, config, args):
        fusesoc_cmd = []
        for fld, typ in Config.known_fields:
            val = config.params[fld]
            fusesoc_cmd.append(shlex.quote(f'--{fld}={val}'))

        return ' '.join(fusesoc_cmd)

class QueryOpts:
    def setup_args(self, arg_subparser):
        output_argparser = arg_subparser.add_parser(
            'query_fields', help=('Query config fields'))
        output_argparser.add_argument(
            'fields', type=str, nargs='+',
            help='Which fields to query the value of')

        output_argparser.set_defaults(output_fn=self.output)

    def output(self, config, args):
        query_result = []
        for fld in args.fields:
            if fld in config.params:
                val = config.params[fld]
                query_result.append(f'{fld}={val}')
            else:
                query_result.append(f'{fld} not found in config')

        return '\n'.join(query_result)

class SimOpts:
    def __init__(self, cmd_name, description, param_set_fn, define_set_fn,
                 hierarchy_sep):
        self.cmd_name = cmd_name
        self.description = description
        self.param_set_fn = param_set_fn
        self.define_set_fn = define_set_fn
        self.hierarchy_sep = hierarchy_sep

    def setup_args(self, arg_subparser):
        output_argparser = arg_subparser.add_parser(
            self.cmd_name,
            help=('Outputs options for {0}'.format(self.description)))

        output_argparser.add_argument(
            '--ins_hier_path',
            help=('Hierarchical path to the instance to set '
                  'configuration parameters on'),
            default='')
        output_argparser.add_argument(
            '--string_define_prefix',
            help=('Prefix to add to defines that are used to '
                  'pass string parameters'),
            default='')
        output_argparser.set_defaults(output_fn=self.output)

    def output(self, config, args):
        if (args.ins_hier_path != ''):
            ins_hier_path = args.ins_hier_path + self.hierarchy_sep
        else:
            ins_hier_path = ''

        sim_opts = []

        for fld, typ in Config.known_fields:
            val = config.params[fld]

            if typ is str:
                parameter_define = args.string_define_prefix + fld
                define_opts = self.define_set_fn(parameter_define, val)
                sim_opts += [shlex.quote(arg) for arg in define_opts]
            else:
                assert typ in [bool, int]

                # Explicitly convert to 0/1 (handling genuine booleans)
                val_as_int = int(val)

                full_param = ins_hier_path + fld
                param_opts = self.param_set_fn(full_param, str(val_as_int))
                sim_opts += [shlex.quote(arg) for arg in param_opts]

        return ' '.join(sim_opts)


def get_config_file_location():
    """Returns the location of the config file

    Default is _DEFAULT_CONFIG_FILE and the IBEX_CONFIG_FILE environment
    variable overrides the default"""

    return os.environ.get('IBEX_CONFIG_FILE', _DEFAULT_CONFIG_FILE)


def parse_config(config_name, config_filename):
    """Parses the selected config file and returns selected config information.

    Arguments:

        config_name: Name of the chosen Ibex core config

        config_filename: Name of the configuration filename to be parsed

    Returns: the chosen Ibex config as a Config object.

    Raises an exception if there is an error loading or parsing the YAML, or if
    the YAML doesn't define a configuration with the requested name.

    """
    with open(config_filename) as config_file:
        try:
            yml = yaml.load(config_file, Loader=yaml.SafeLoader)
        except yaml.YAMLError as err:
            raise ConfigException(f'Could not decode yaml: {err}')

    try:
        configs = Configs(yml)
    except ValueError as err:
        raise ConfigException(f'{config_filename!r}: {err}') from None

    config = configs.configs.get(config_name)
    if config is None:
        raise ValueError(f'Configuration {config_name!r} not found '
                         'in YAML at {config_filename!r}.')

    return config


def main():
    outputters = [
        FusesocOpts(),
        QueryOpts(),
        SimOpts('vcs_opts', 'VCS compile',
                lambda p, v: ['-pvalue+' + p + '=' + v],
                lambda d, v: ['+define+' + d + '=' + v], '.'),
        SimOpts('riviera_sim_opts', 'Riviera simulate',
                lambda p, v: ['-g/' + p + '=' + v],
                lambda d, v: [], '/'),
        SimOpts('riviera_compile_opts', 'Riviera compile',
                lambda p, v: [],
                lambda d, v: ['+define+' + d + '=' + v], '/'),
        SimOpts('questa_sim_opts', 'Questa simulate',
                lambda p, v: ['-g/' + p + '=' + v],
                lambda d, v: [], '/'),
        SimOpts('questa_compile_opts', 'Questa compile',
                lambda p, v: [],
                lambda d, v: ['+define+' + d + '=' + v], '/'),
        SimOpts('xlm_opts', 'Xcelium compile',
                lambda p, v: ['-defparam', p + '=' + v],
                lambda d, v: ['-define', d + '=' + v], '.'),
        SimOpts('dsim_opts', 'DSim compile',
                lambda p, v: ['-defparam', p + '=' + v],
                lambda d, v: ['+define+' + d + '=' + v], '.'),
    ]

    argparser = argparse.ArgumentParser(description=(
        'Outputs Ibex configuration parameters for a named config in a number '
        'of formats.  If not specified on the command line the config will be '
        'read from {0}. This default can be overridden by setting the '
        'IBEX_CONFIG_FILE environment variable. Some output types support '
        'arguments to see help for them pass a config_name and an output type '
        'followed by --help').format(get_config_file_location()))

    argparser.add_argument('config_name',
                           help=('The name of the Ibex '
                                 'configuration to output'))

    argparser.add_argument('--config_filename',
                           help='Config file to read',
                           default=get_config_file_location())

    arg_subparser = argparser.add_subparsers(
        help='Format to output the configuration parameters in',
        dest='output_fn',
        metavar='output_type')

    for outputter in outputters:
        outputter.setup_args(arg_subparser)

    args = argparser.parse_args()

    if args.output_fn is None:
        print('ERROR: No output format specified.')
        sys.exit(1)

    parsed_ibex_config = parse_config(args.config_name, args.config_filename)
    print(args.output_fn(parsed_ibex_config, args))

if __name__ == "__main__":
    main()
