#!/usr/bin/env python3

import argparse
import json
import sys

r"""
Validates the PEL message registry JSON, which includes checking it against
a JSON schema using the jsonschema module as well as doing some extra checks
that can't be encoded in the schema.
"""


def check_duplicate_names(registry_json):
    r"""
    Check that there aren't any message registry entries with the same
    'Name' field.  There may be a use case for this in the future, but there
    isn't right now.

    registry_json: The message registry JSON
    """

    names = []
    for entry in registry_json['PELs']:
        if entry['Name'] in names:
            sys.exit("Found multiple uses of error {}".format(entry['Name']))
        else:
            names.append(entry['Name'])


def check_duplicate_reason_codes(registry_json):
    r"""
    Check that there aren't any message registry entries with the same
    'ReasonCode' field.

    registry_json: The message registry JSON
    """

    reasonCodes = []
    for entry in registry_json['PELs']:
        if entry['SRC']['ReasonCode'] in reasonCodes:
            sys.exit("Found duplicate SRC reason code {}".format(
                entry['SRC']['ReasonCode']))
        else:
            reasonCodes.append(entry['SRC']['ReasonCode'])


def check_component_id(registry_json):
    r"""
    Check that the upper byte of the ComponentID field matches the upper byte
    of the ReasonCode field, but not on "11" type SRCs where they aren't
    supposed to match.

    registry_json: The message registry JSON
    """

    for entry in registry_json['PELs']:

        # Don't check on "11" SRCs as those reason codes aren't supposed to
        # match the component ID.
        if entry['SRC'].get('Type', '') == "11":
            continue

        if 'ComponentID' in entry:
            id = int(entry['ComponentID'], 16)
            reason_code = int(entry['SRC']['ReasonCode'], 16)

            if (id & 0xFF00) != (reason_code & 0xFF00):
                sys.exit("Found mismatching component ID {} vs reason "
                         "code {} for error {}".format(
                             entry['ComponentID'],
                             entry['SRC']['ReasonCode'],
                             entry['Name']))


def check_message_args(registry_json):
    r"""
    Check that if the Message field uses the '%' style placeholders that there
    are that many entries in the MessageArgSources field.  Also checks that
    the MessageArgSources field is present but only if there are placeholders.

    registry_json: The message registry JSON
    """

    for entry in registry_json['PELs']:
        num_placeholders = entry['Documentation']['Message'].count('%')
        if num_placeholders == 0:
            continue

        if 'MessageArgSources' not in entry['Documentation']:
            sys.exit("Missing MessageArgSources property for error {}".
                     format(entry['Name']))

        if num_placeholders != \
                len(entry['Documentation']['MessageArgSources']):
            sys.exit("Different number of placeholders found in "
                     "Message vs MessageArgSources for error {}".
                     format(entry['Name']))


def validate_schema(registry, schema):
    r"""
    Validates the passed in JSON against the passed in schema JSON

    registry: Path of the file containing the registry JSON
    schema:   Path of the file containing the schema JSON
              Use None to skip the pure schema validation
    """

    with open(registry) as registry_handle:
        registry_json = json.load(registry_handle)

        if schema:

            import jsonschema

            with open(schema) as schema_handle:
                schema_json = json.load(schema_handle)

                try:
                    jsonschema.validate(registry_json, schema_json)
                except jsonschema.ValidationError as e:
                    print(e)
                    sys.exit("Schema validation failed")

        check_duplicate_names(registry_json)

        check_duplicate_reason_codes(registry_json)

        check_component_id(registry_json)

        check_message_args(registry_json)


if __name__ == '__main__':

    parser = argparse.ArgumentParser(
        description='PEL message registry processor')

    parser.add_argument('-v', '--validate', action='store_true',
                        dest='validate',
                        help='Validate the JSON using the schema')

    parser.add_argument('-s', '--schema-file', dest='schema_file',
                        help='The message registry JSON schema file')

    parser.add_argument('-r', '--registry-file', dest='registry_file',
                        help='The message registry JSON file')
    parser.add_argument('-k', '--skip-schema-validation', action='store_true',
                        dest='skip_schema',
                        help='Skip running schema validation. '
                             'Only do the extra checks.')

    args = parser.parse_args()

    if args.validate:
        if not args.schema_file:
            sys.exit("Schema file required")

        if not args.registry_file:
            sys.exit("Registry file required")

        schema = args.schema_file
        if args.skip_schema:
            schema = None

        validate_schema(args.registry_file, schema)