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

import re
from typing import Dict, Tuple, Union

from .bool_literal import BoolLiteral
from .encoding_scheme import EncSchemeField, EncSchemes
from .yaml_parse_helpers import check_keys, check_str


class EncodingField:
    '''A single element of an encoding's mapping'''
    def __init__(self,
                 value: Union[BoolLiteral, str],
                 scheme_field: EncSchemeField) -> None:
        self.value = value
        self.scheme_field = scheme_field

    @staticmethod
    def from_yaml(as_str: str,
                  scheme_field: EncSchemeField,
                  what: str) -> 'EncodingField':
        # The value should either be a boolean literal ("000xx11" or similar)
        # or should be a name, which is taken as the name of an operand.
        if not as_str:
            raise ValueError('Empty string as {}.'.format(what))

        # Set self.value to be either the bool literal or the name of the
        # operand.
        value = ''  # type: Union[BoolLiteral, str]
        if re.match(r'b[01x_]+$', as_str):
            value = BoolLiteral.from_string(as_str, what)

            # Check that the literal operand value matches the width of the
            # schema field.
            if scheme_field.bits.width != value.width:
                raise ValueError('{} is mapped to a literal value with width '
                                 '{}, but the encoding schema field has '
                                 'width {}.'
                                 .format(what, value.width,
                                         scheme_field.bits.width))
        else:
            value = as_str

        # Track the scheme field as well (so we don't have to keep track of a
        # scheme once we've made an encoding object)
        return EncodingField(value, scheme_field)


class Encoding:
    '''The encoding for an instruction'''
    def __init__(self,
                 yml: object,
                 schemes: EncSchemes,
                 mnemonic: str):
        what = 'encoding for instruction {!r}'.format(mnemonic)
        yd = check_keys(yml, what, ['scheme', 'mapping'], [])

        scheme_what = 'encoding scheme for instruction {!r}'.format(mnemonic)
        scheme_name = check_str(yd['scheme'], scheme_what)
        scheme_fields = schemes.resolve(scheme_name, mnemonic)

        what = 'encoding mapping for instruction {!r}'.format(mnemonic)

        # Check we've got exactly the right fields for the scheme
        ydm = check_keys(yd['mapping'], what, list(scheme_fields.op_fields), [])

        # Build a map from operand name to the name of a field that uses it.
        self.op_to_field_name = {}  # type: Dict[str, str]

        self.fields = {}
        for field_name, scheme_field in scheme_fields.fields.items():
            if scheme_field.value is not None:
                field = EncodingField(scheme_field.value, scheme_field)
            else:
                field_what = ('value for {} field in '
                              'encoding for instruction {!r}'
                              .format(field_name, mnemonic))
                ef_val = check_str(ydm[field_name], field_what)
                field = EncodingField.from_yaml(ef_val,
                                                scheme_fields.fields[field_name],
                                                field_what)

                # If the field's value has type str, the field uses an operand
                # rather than a literal. Check for linearity and store the
                # mapping.
                if isinstance(field.value, str):
                    other_field_name = self.op_to_field_name.get(field.value)
                    if other_field_name is not None:
                        raise ValueError('Non-linear use of operand with name '
                                         '{!r} in encoding for instruction '
                                         '{!r}: used in fields {!r} and {!r}.'
                                         .format(field.value, mnemonic,
                                                 other_field_name,
                                                 field_name))
                    self.op_to_field_name[field.value] = field_name

            self.fields[field_name] = field

    def get_masks(self) -> Tuple[int, int]:
        '''Return zeros/ones masks for encoding

        Returns a pair (m0, m1) where m0 is the "zeros mask": a mask where a
        bit is set if there is an bit pattern matching this encoding with that
        bit zero. m1 is the ones mask: equivalent, but for that bit one.

        '''
        m0 = 0
        m1 = 0
        for field_name, field in self.fields.items():
            if isinstance(field.value, str):
                m0 |= field.scheme_field.bits.mask
                m1 |= field.scheme_field.bits.mask
            else:
                # Match up the bits in the value with the ranges in the scheme.
                assert field.value.width > 0
                assert field.value.width == field.scheme_field.bits.width
                bits_seen = 0
                for msb, lsb in field.scheme_field.bits.ranges:
                    val_msb = field.scheme_field.bits.width - 1 - bits_seen
                    val_lsb = val_msb - msb + lsb
                    bits_seen += msb - lsb + 1

                    for idx in range(0, msb - lsb + 1):
                        desc = field.value.char_for_bit(val_lsb + idx)
                        if desc in ['0', 'x']:
                            m0 |= 1 << (idx + lsb)
                        if desc in ['1', 'x']:
                            m1 |= 1 << (idx + lsb)

        all_bits = (1 << 32) - 1
        assert (m0 | m1) == all_bits
        return (m0, m1)

    def get_ones_mask(self) -> int:
        '''Return the mask of fixed bits that are set

        For literal values of x (unused bits in the encoding), we'll prefer
        '0'.

        '''
        m0, m1 = self.get_masks()
        return m1 & ~m0

    def assemble(self, op_to_idx: Dict[str, int]) -> int:
        '''Assemble an instruction

        op_to_idx should map each operand in the encoding to some integer
        index, which should be small enough to fit in the width of the
        operand's type and should be representable after any shift. Will raise
        a ValueError if not.

        '''
        val = self.get_ones_mask()
        for field_name, field in self.fields.items():
            if not isinstance(field.value, str):
                # We've done this field already (in get_ones_mask)
                continue

            # Try to get the operand value for the field. If this is an
            # optional operand, we might not have one, and just encode zero.
            field_val = op_to_idx.get(field.value, 0)

            # The encoding process should already have converted anything
            # negative to a 2's complement representation.
            assert field_val >= 0

            # Is the number too big? At the moment, we are assuming immediates
            # are unsigned (because the OTBN big number instructions all have
            # unsigned immediates).
            if field_val >> field.scheme_field.bits.width:
                raise ValueError("operand field {} has a width of {}, "
                                 "so can't represent the value {:#x}."
                                 .format(field.value,
                                         field.scheme_field.bits.width,
                                         field_val))

            val |= field.scheme_field.bits.encode(field_val)

        return val

    def extract_operands(self, word: int) -> Dict[str, int]:
        '''Extract the encoded operand values from an encoded instruction'''
        ret = {}
        for field in self.fields.values():
            # The operand fields (rather than fixed ones) have the operand name as
            # their value.
            if not isinstance(field.value, str):
                continue

            ret[field.value] = field.scheme_field.bits.decode(word)

        return ret