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

'''A wrapper for loading hjson files as used by dvsim's FlowCfg'''

from utils import parse_hjson, subst_wildcards


# A set of fields that can be overridden on the command line and shouldn't be
# loaded from the hjson in that case.
_CMDLINE_FIELDS = {'tool'}


def load_hjson(path, initial_values):
    '''Load an hjson file and any includes

    Combines them all into a single dictionary, which is then returned. This
    does wildcard substitution on include names (since it might be needed to
    find included files), but not otherwise.

    initial_values is a starting point for the dictionary to be returned (which
    is not modified). It needs to contain values for anything needed to resolve
    include files (typically, this is 'proj_root' and 'tool' (if set)).

    '''
    worklist = [path]
    seen = {path}
    ret = initial_values.copy()
    is_first = True

    # Figure out a list of fields that had a value from the command line. These
    # should have been passed in as part of initial_values and we need to know
    # that we can safely ignore updates.
    arg_keys = _CMDLINE_FIELDS & initial_values.keys()

    while worklist:
        next_path = worklist.pop()
        new_paths = _load_single_file(ret, next_path, is_first, arg_keys)
        paths_seen = set(new_paths) & seen
        if paths_seen:
            raise RuntimeError('The files {!r} appears more than once '
                               'when processing include {!r} for {!r}.'
                               .format(list(paths_seen), next_path, path))
        seen |= set(new_paths)
        worklist += new_paths
        is_first = False

    return ret


def _load_single_file(target, path, is_first, arg_keys):
    '''Load a single hjson file, merging its keys into target

    Returns a list of further includes that should be loaded.

    '''
    hjson = parse_hjson(path)
    if not isinstance(hjson, dict):
        raise RuntimeError('{!r}: Top-level hjson object is not a dictionary.'
                           .format(path))

    import_cfgs = []
    for key, dict_val in hjson.items():
        # If this key got set at the start of time and we want to ignore any
        # updates: ignore them!
        if key in arg_keys:
            continue

        # If key is 'import_cfgs', this should be a list. Add each item to the
        # list of cfgs to process
        if key == 'import_cfgs':
            if not isinstance(dict_val, list):
                raise RuntimeError('{!r}: import_cfgs value is {!r}, but '
                                   'should be a list.'
                                   .format(path, dict_val))
            import_cfgs += dict_val
            continue

        # 'use_cfgs' is a bit like 'import_cfgs', but is only used for primary
        # config files (where it is a list of the child configs). This
        # shouldn't be used except at top-level (the first configuration file
        # to be loaded).
        #
        # If defined, check that it's a list, but then allow it to be set in
        # the target dictionary as usual.
        if key == 'use_cfgs':
            if not is_first:
                raise RuntimeError('{!r}: File is included by another one, '
                                   'but defines "use_cfgs".'
                                   .format(path))
            if not isinstance(dict_val, list):
                raise RuntimeError('{!r}: use_cfgs must be a list. Saw {!r}.'
                                   .format(path, dict_val))

        # Otherwise, update target with this attribute
        set_target_attribute(path, target, key, dict_val)

    # Expand the names of imported configuration files as we return them
    return [subst_wildcards(cfg_path,
                            target,
                            ignored_wildcards=[],
                            ignore_error=False)
            for cfg_path in import_cfgs]


def set_target_attribute(path, target, key, dict_val):
    '''Set an attribute on the target dictionary

    This performs checks for conflicting values and merges lists /
    dictionaries.

    '''
    old_val = target.get(key)
    if old_val is None:
        # A new attribute (or the old value was None, in which case it's
        # just a placeholder and needs writing). Set it and return.
        target[key] = dict_val
        return

    if isinstance(old_val, list):
        if not isinstance(dict_val, list):
            raise RuntimeError('{!r}: Conflicting types for key {!r}: was '
                               '{!r}, a list, but loaded value is {!r}, '
                               'of type {}.'
                               .format(path, key, old_val, dict_val,
                                       type(dict_val).__name__))

        # Lists are merged by concatenation
        target[key] += dict_val
        return

    # The other types we support are "scalar" types.
    scalar_types = [(str, [""]), (int, [0, -1]), (bool, [False])]
    defaults = None
    for st_type, st_defaults in scalar_types:
        if isinstance(dict_val, st_type):
            defaults = st_defaults
            break
    if defaults is None:
        raise RuntimeError('{!r}: Value for key {!r} is {!r}, of '
                           'unknown type {}.'
                           .format(path, key, dict_val,
                                   type(dict_val).__name__))
    if not isinstance(old_val, st_type):
        raise RuntimeError('{!r}: Value for key {!r} is {!r}, but '
                           'we already had the value {!r}, of an '
                           'incompatible type.'
                           .format(path, key, dict_val, old_val))

    # The types are compatible. If the values are equal, there's nothing more
    # to do
    if old_val == dict_val:
        return

    old_is_default = old_val in defaults
    new_is_default = dict_val in defaults

    # Similarly, if new value looks like a default, ignore it (regardless
    # of whether the current value looks like a default).
    if new_is_default:
        return

    # If the existing value looks like a default and the new value doesn't,
    # take the new value.
    if old_is_default:
        target[key] = dict_val
        return

    # Neither value looks like a default. Raise an error.
    raise RuntimeError('{!r}: Value for key {!r} is {!r}, but '
                       'we already had a conflicting value of {!r}.'
                       .format(path, key, dict_val, old_val))
