#!/usr/bin/env python3

import json, sys


def assert_non_empty_string(obj, field):
    assert field in obj, 'Missing field "%s"' % field
    assert isinstance(obj[field], basestring), \
        'Field "%s" must be a string' % field
    assert len(obj[field]) > 0, 'Field "%s" must not be empty' % field


def assert_non_empty_list(obj, field):
    assert isinstance(obj[field], list), \
        '%s must be a list' % field
    assert len(obj[field]) > 0, \
        '%s list must not be empty' % field


def assert_non_empty_dict(obj, field):
    assert isinstance(obj[field], dict), \
        '%s must be a dict' % field
    assert len(obj[field]) > 0, \
        '%s dict must not be empty' % field


def assert_contains(obj, field):
    assert field in obj, 'Must contain field "%s"' % field


def assert_value_from(obj, field, items):
    assert obj[field] in items, \
         'Field "%s" must be from: %s' % (field, str(items))


def assert_atom_or_list_items_from(obj, field, items):
    if isinstance(obj[field], basestring) or isinstance(
            obj[field], int) or obj[field] is None:
        assert_value_from(obj, field, items)
        return

    assert isinstance(obj[field], list), '%s must be a list' % field
    for allowed_value in obj[field]:
        assert allowed_value != '*', "Wildcard is not supported for lists!"
        assert allowed_value in items, \
            'Field "%s" must be from: %s' % (field, str(items))


def assert_contains_only_fields(obj, expected_fields):
    for expected_field in expected_fields:
        assert_contains(obj, expected_field)

    for actual_field in obj:
        assert actual_field in expected_fields, \
                'Unexpected field "%s".' % actual_field


def leaf_values(schema):
    if isinstance(schema, list):
        return schema
    ret = []
    for _, sub_schema in schema.iteritems():
        ret += leaf_values(sub_schema)
    return ret


def assert_value_unique_in(value, used_values):
    assert value not in used_values, 'Duplicate value "%s"!' % str(value)
    used_values[value] = True


def assert_valid_artifact(exp_pattern, artifact_key, schema):
    if isinstance(schema, list):
        assert_atom_or_list_items_from(exp_pattern, artifact_key,
                                       ["*"] + schema)
        return

    for sub_artifact_key, sub_schema in schema.iteritems():
        assert_valid_artifact(exp_pattern[artifact_key], sub_artifact_key,
                              sub_schema)


def validate(spec_json, details):
    """ Validates the json specification for generating tests. """

    details['object'] = spec_json
    assert_contains_only_fields(spec_json, [
        "selection_pattern", "test_file_path_pattern",
        "test_description_template", "test_page_title_template",
        "specification", "delivery_key", "subresource_schema",
        "source_context_schema", "source_context_list_schema",
        "test_expansion_schema", "excluded_tests"
    ])
    assert_non_empty_list(spec_json, "specification")
    assert_non_empty_dict(spec_json, "test_expansion_schema")
    assert_non_empty_list(spec_json, "excluded_tests")

    specification = spec_json['specification']
    test_expansion_schema = spec_json['test_expansion_schema']
    excluded_tests = spec_json['excluded_tests']

    valid_test_expansion_fields = test_expansion_schema.keys()

    # Should be consistent with `sourceContextMap` in
    # `/common/security-features/resources/common.sub.js`.
    valid_source_context_names = [
        "top", "iframe", "iframe-blank", "srcdoc", "worker-classic",
        "worker-module", "worker-classic-data", "worker-module-data",
        "sharedworker-classic", "sharedworker-module",
        "sharedworker-classic-data", "sharedworker-module-data"
    ]

    valid_subresource_names = [
        "a-tag", "area-tag", "audio-tag", "form-tag", "iframe-tag", "img-tag",
        "link-css-tag", "link-prefetch-tag", "object-tag", "picture-tag",
        "script-tag", "script-tag-dynamic-import", "video-tag"
    ] + ["beacon", "fetch", "xhr", "websocket"] + [
        "worker-classic", "worker-module", "worker-import",
        "worker-import-data", "sharedworker-classic", "sharedworker-module",
        "sharedworker-import", "sharedworker-import-data",
        "serviceworker-classic", "serviceworker-module",
        "serviceworker-import", "serviceworker-import-data"
    ] + [
        "worklet-animation", "worklet-audio", "worklet-layout",
        "worklet-paint", "worklet-animation-import", "worklet-audio-import",
        "worklet-layout-import", "worklet-paint-import",
        "worklet-animation-import-data", "worklet-audio-import-data",
        "worklet-layout-import-data", "worklet-paint-import-data"
    ]

    # Validate each single spec.
    for spec in specification:
        details['object'] = spec

        # Validate required fields for a single spec.
        assert_contains_only_fields(spec, [
            'title', 'description', 'specification_url', 'test_expansion'
        ])
        assert_non_empty_string(spec, 'title')
        assert_non_empty_string(spec, 'description')
        assert_non_empty_string(spec, 'specification_url')
        assert_non_empty_list(spec, 'test_expansion')

        for spec_exp in spec['test_expansion']:
            details['object'] = spec_exp
            assert_contains_only_fields(spec_exp, valid_test_expansion_fields)

            for artifact in test_expansion_schema:
                details['test_expansion_field'] = artifact
                assert_valid_artifact(spec_exp, artifact,
                                      test_expansion_schema[artifact])
                del details['test_expansion_field']

    # Validate source_context_schema.
    details['object'] = spec_json['source_context_schema']
    assert_contains_only_fields(
        spec_json['source_context_schema'],
        ['supported_delivery_type', 'supported_subresource'])
    assert_contains_only_fields(
        spec_json['source_context_schema']['supported_delivery_type'],
        valid_source_context_names)
    for source_context in spec_json['source_context_schema'][
            'supported_delivery_type']:
        assert_valid_artifact(
            spec_json['source_context_schema']['supported_delivery_type'],
            source_context, test_expansion_schema['delivery_type'])
    assert_contains_only_fields(
        spec_json['source_context_schema']['supported_subresource'],
        valid_source_context_names)
    for source_context in spec_json['source_context_schema'][
            'supported_subresource']:
        assert_valid_artifact(
            spec_json['source_context_schema']['supported_subresource'],
            source_context, leaf_values(test_expansion_schema['subresource']))

    # Validate subresource_schema.
    details['object'] = spec_json['subresource_schema']
    assert_contains_only_fields(spec_json['subresource_schema'],
                                ['supported_delivery_type'])
    assert_contains_only_fields(
        spec_json['subresource_schema']['supported_delivery_type'],
        leaf_values(test_expansion_schema['subresource']))
    for subresource in spec_json['subresource_schema'][
            'supported_delivery_type']:
        assert_valid_artifact(
            spec_json['subresource_schema']['supported_delivery_type'],
            subresource, test_expansion_schema['delivery_type'])

    # Validate the test_expansion schema members.
    details['object'] = test_expansion_schema
    assert_contains_only_fields(test_expansion_schema, [
        'expansion', 'source_scheme', 'source_context_list', 'delivery_type',
        'delivery_value', 'redirection', 'subresource', 'origin', 'expectation'
    ])
    assert_atom_or_list_items_from(test_expansion_schema, 'expansion',
                                   ['default', 'override'])
    assert_atom_or_list_items_from(test_expansion_schema, 'source_scheme',
                                   ['http', 'https'])
    assert_atom_or_list_items_from(
        test_expansion_schema, 'source_context_list',
        spec_json['source_context_list_schema'].keys())

    # Should be consistent with `preprocess_redirection` in
    # `/common/security-features/subresource/subresource.py`.
    assert_atom_or_list_items_from(test_expansion_schema, 'redirection', [
        'no-redirect', 'keep-origin', 'swap-origin', 'keep-scheme',
        'swap-scheme', 'downgrade'
    ])
    for subresource in leaf_values(test_expansion_schema['subresource']):
        assert subresource in valid_subresource_names, "Invalid subresource %s" % subresource
    # Should be consistent with getSubresourceOrigin() in
    # `/common/security-features/resources/common.sub.js`.
    assert_atom_or_list_items_from(test_expansion_schema, 'origin', [
        'same-http', 'same-https', 'same-ws', 'same-wss', 'cross-http',
        'cross-https', 'cross-ws', 'cross-wss', 'same-http-downgrade',
        'cross-http-downgrade', 'same-ws-downgrade', 'cross-ws-downgrade'
    ])

    # Validate excluded tests.
    details['object'] = excluded_tests
    for excluded_test_expansion in excluded_tests:
        assert_contains_only_fields(excluded_test_expansion,
                                    valid_test_expansion_fields)
        details['object'] = excluded_test_expansion
        for artifact in test_expansion_schema:
            details['test_expansion_field'] = artifact
            assert_valid_artifact(excluded_test_expansion, artifact,
                                  test_expansion_schema[artifact])
            del details['test_expansion_field']

    del details['object']


def assert_valid_spec_json(spec_json):
    error_details = {}
    try:
        validate(spec_json, error_details)
    except AssertionError as err:
        print('ERROR:', err.message)
        print(json.dumps(error_details, indent=4))
        sys.exit(1)


def main():
    spec_json = load_spec_json()
    assert_valid_spec_json(spec_json)
    print("Spec JSON is valid.")


if __name__ == '__main__':
    main()