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

load("//rules:const.bzl", "CONST", "hex")

_SEL_DEVICE_ID = 1
_SEL_MANUF_STATE_CREATOR = (1 << 8)
_SEL_MANUF_STATE_OWNER = (1 << 9)
_SEL_LIFE_CYCLE_STATE = (1 << 10)

def _manifest_impl(ctx):
    mf = {}

    # All the easy parameters are simple assignments
    if ctx.attr.signature:
        mf["signature"] = ctx.attr.signature
    if ctx.attr.modulus:
        mf["modulus"] = ctx.attr.modulus
    if ctx.attr.identifier:
        mf["identifier"] = ctx.attr.identifier
    if ctx.attr.length:
        mf["length"] = ctx.attr.length
    if ctx.attr.version_major:
        mf["version_major"] = ctx.attr.version_major
    if ctx.attr.version_minor:
        mf["version_minor"] = ctx.attr.version_minor
    if ctx.attr.security_version:
        mf["security_version"] = ctx.attr.security_version
    if ctx.attr.timestamp:
        mf["timestamp"] = ctx.attr.timestamp
    if ctx.attr.max_key_version:
        mf["max_key_version"] = ctx.attr.max_key_version
    if ctx.attr.code_start:
        mf["code_start"] = ctx.attr.code_start
    if ctx.attr.code_end:
        mf["code_end"] = ctx.attr.code_end
    if ctx.attr.entry_point:
        mf["entry_point"] = ctx.attr.entry_point

    # Address Translation is a bool, but encoded as an int so we can have
    # a special value mean "unset" and so we can set to non-standard values
    # for testing.
    if ctx.attr.address_translation:
        mf["address_translation"] = ctx.attr.address_translation

    # The binding_value, if provided, must be exactly 8 words.
    if ctx.attr.binding_value:
        if len(ctx.attr.binding_value) != 8:
            fail("The binding_value must be exactly 8 words.")
        mf["binding_value"] = [v for v in ctx.attr.binding_value]

    # The selector_bits are set based on the values of the usage_constraints.
    uc = {}
    selector_bits = 0
    device_id = list(ctx.attr.device_id)
    if len(device_id) > 8:
        fail("The device_id must be 8 words or fewer.")

    # Extend the device_id to 8 words, then set the selector_bits for each
    # non-default word.
    if len(device_id) < 8:
        device_id.extend([hex(CONST.DEFAULT_USAGE_CONSTRAINTS)] * (8 - len(device_id)))
    for i, d in enumerate(device_id):
        if d != hex(CONST.DEFAULT_USAGE_CONSTRAINTS):
            selector_bits |= _SEL_DEVICE_ID << i
        device_id[i] = d
    uc["device_id"] = device_id

    # Set the selector bits for the remaining non-default values.
    if ctx.attr.manuf_state_creator:
        uc["manuf_state_creator"] = ctx.attr.manuf_state_creator
        selector_bits |= _SEL_MANUF_STATE_CREATOR
    else:
        uc["manuf_state_creator"] = hex(CONST.DEFAULT_USAGE_CONSTRAINTS)

    if ctx.attr.manuf_state_owner:
        uc["manuf_state_owner"] = ctx.attr.manuf_state_owner
        selector_bits |= _SEL_MANUF_STATE_OWNER
    else:
        uc["manuf_state_owner"] = hex(CONST.DEFAULT_USAGE_CONSTRAINTS)

    if ctx.attr.life_cycle_state:
        uc["life_cycle_state"] = ctx.attr.life_cycle_state
        selector_bits |= _SEL_LIFE_CYCLE_STATE
    else:
        uc["life_cycle_state"] = hex(CONST.DEFAULT_USAGE_CONSTRAINTS)

    # If the user supplied selector_bits, check if they make sense.
    if ctx.attr.selector_bits:
        # If they don't match, fail unless explicitly permitted to set a
        # bad value.
        if int(ctx.attr.selector_bits, base = 16) != selector_bits and ctx.attr.selector_mismatch_is_failure:
            fail("User provided selector_bits ({}) don't match computed selector_bits ({})".format(ctx.attr.selector_bits, selector_bits))
        uc["selector_bits"] = ctx.attr.selector_bits
    else:
        uc["selector_bits"] = selector_bits

    mf["usage_constraints"] = uc

    file = ctx.actions.declare_file("{}.json".format(ctx.attr.name))
    ctx.actions.write(file, json.encode_indent(mf))
    return DefaultInfo(
        files = depset([file]),
        data_runfiles = ctx.runfiles(files = [file]),
    )

_manifest = rule(
    implementation = _manifest_impl,
    # Manifest attrs are supplied as strings due to Bazel limiting int types to 32-bit signed integers
    attrs = {
        "signature": attr.string(doc = "Image signature as a 0x-prefixed hex-encoded string"),
        "modulus": attr.string(doc = "Signing key modulus as a 0x-prefixed hex-encoded string"),
        "selector_bits": attr.string(doc = "Usage constraint selector bits as a 0x-prefixed hex-encoded string"),
        "selector_mismatch_is_failure": attr.bool(default = True, doc = "A mismatch in computed selector bits is a failure"),
        "device_id": attr.string_list(doc = "Usage constraint device ID as a 0x-prefixed hex-encoded string"),
        "manuf_state_creator": attr.string(doc = "Usage constraint for silicon creator manufacturing status as a 0x-prefixed hex-encoded string"),
        "manuf_state_owner": attr.string(doc = "Usage constraint for silicon owner manufacturing status as a 0x-prefixed hex-encoded string"),
        "life_cycle_state": attr.string(doc = "Usage constraint for life cycle status as a 0x-prefixed hex-encoded string"),
        "address_translation": attr.string(doc = "Whether this image uses address translation as a 0x-prefixed hex-encoded string"),
        "identifier": attr.string(doc = "Manifest identifier as a 0x-prefixed hex-encoded string"),
        "length": attr.string(doc = "Length of this image as a 0x-prefixed hex-encoded string"),
        "version_major": attr.string(doc = "Image major version as a 0x-prefixed hex-encoded string"),
        "version_minor": attr.string(doc = "Image minor version as a 0x-prefixed hex-encoded string"),
        "security_version": attr.string(doc = "Security version for anti-rollback protection as a 0x-prefixed hex-encoded string"),
        "timestamp": attr.string(doc = "Unix timestamp of the image as a 0x-prefixed hex-encoded string"),
        "binding_value": attr.string_list(doc = "Binding value used by key manager to derive secrets as a 0x-prefixed hex-encoded string"),
        "max_key_version": attr.string(doc = "Maximum allowed version for keys generated at the next boot stage as a 0x-prefixed hex-encoded string"),
        "code_start": attr.string(doc = "Start offset of the executable region in the image as a 0x-prefixed hex-encoded string"),
        "code_end": attr.string(doc = "End offset of the executable region in the image as a 0x-prefixed hex-encoded string"),
        "entry_point": attr.string(doc = "Offset of the first instruction in the image as a 0x-prefixed hex-encoded string"),
    },
)

def manifest(d):
    _manifest(**d)
    return d["name"]