# Copyright 2019 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

"""Utilities for test code."""

from compiler.util import ir_data_utils


def proto_is_superset(proto, expected_values, path=""):
  """Returns true if every value in expected_values is set in proto.

  This is intended to be used in assertTrue in a unit test, like so:

      self.assertTrue(*proto_is_superset(proto, expected))

  Arguments:
    proto: The proto to check.
    expected_values: The reference proto.
    path: The path to the elements being compared.  Clients can generally leave
      this at default.

  Returns:
    A tuple; the first element is True if the fields set in proto are a strict
    superset of the fields set in expected_values.  The second element is an
    informational string specifying the path of a value found in expected_values
    but not in proto.

    Every atomic field that is set in expected_values must be set to the same
    value in proto; every message field set in expected_values must have a
    matching field in proto, such that proto_is_superset(proto.field,
    expected_values.field) is true.

    For repeated fields in expected_values, each element in the expected_values
    proto must have a corresponding element at the same index in proto; proto
    may have additional elements.
  """
  if path:
    path += "."
  for spec, expected_value in ir_data_utils.get_set_fields(expected_values):
    name = spec.name
    field_path = "{}{}".format(path, name)
    value = getattr(proto, name)
    if spec.is_dataclass:
      if spec.is_sequence:
        if len(expected_value) > len(value):
          return False, "{}[{}] missing".format(field_path,
                                                len(getattr(proto, name)))
        for i in range(len(expected_value)):
          result = proto_is_superset(value[i], expected_value[i],
                                     "{}[{}]".format(field_path, i))
          if not result[0]:
            return result
      else:
        if (expected_values.HasField(name) and
            not proto.HasField(name)):
          return False, "{} missing".format(field_path)
        result = proto_is_superset(value, expected_value, field_path)
        if not result[0]:
          return result
    else:
      # Zero-length repeated fields and not-there repeated fields are "the
      # same."
      if (expected_value != value and
          (not spec.is_sequence or
           len(expected_value))):
        if spec.is_sequence:
          return False, "{} differs: found {}, expected {}".format(
              field_path, list(value), list(expected_value))
        else:
          return False, "{} differs: found {}, expected {}".format(
              field_path, value, expected_value)
  return True, ""


def dict_file_reader(file_dict):
  """Returns a callable that retrieves entries from file_dict as files.

  This can be used to call glue.parse_emboss_file with file text declared
  inline.

  Arguments:
      file_dict: A dictionary from "file names" to "contents."

  Returns:
      A callable that can be passed to glue.parse_emboss_file in place of the
      "read" builtin.
  """

  def read(file_name):
    try:
      return file_dict[file_name], None
    except KeyError:
      return None, ["File '{}' not found.".format(file_name)]

  return read