package gov.nist.secauto.oscal.lib.model;

import gov.nist.secauto.metaschema.core.datatype.adapter.StringAdapter;
import gov.nist.secauto.metaschema.core.datatype.adapter.TokenAdapter;
import gov.nist.secauto.metaschema.core.datatype.adapter.UriAdapter;
import gov.nist.secauto.metaschema.core.datatype.adapter.UuidAdapter;
import gov.nist.secauto.metaschema.core.datatype.markup.MarkupMultiline;
import gov.nist.secauto.metaschema.core.datatype.markup.MarkupMultilineAdapter;
import gov.nist.secauto.metaschema.core.model.IBoundObject;
import gov.nist.secauto.metaschema.core.model.IMetaschemaData;
import gov.nist.secauto.metaschema.core.model.JsonGroupAsBehavior;
import gov.nist.secauto.metaschema.core.model.constraint.IConstraint;
import gov.nist.secauto.metaschema.core.util.ObjectUtils;
import gov.nist.secauto.metaschema.databind.model.annotations.AllowedValue;
import gov.nist.secauto.metaschema.databind.model.annotations.AllowedValues;
import gov.nist.secauto.metaschema.databind.model.annotations.BoundAssembly;
import gov.nist.secauto.metaschema.databind.model.annotations.BoundField;
import gov.nist.secauto.metaschema.databind.model.annotations.BoundFlag;
import gov.nist.secauto.metaschema.databind.model.annotations.GroupAs;
import gov.nist.secauto.metaschema.databind.model.annotations.MetaschemaAssembly;
import gov.nist.secauto.metaschema.databind.model.annotations.ValueConstraints;
import java.lang.Override;
import java.lang.String;
import java.net.URI;
import java.util.LinkedList;
import java.util.List;
import java.util.UUID;
import org.apache.commons.lang3.builder.ReflectionToStringBuilder;
import org.apache.commons.lang3.builder.ToStringStyle;

/**
 * A relationship-based mapping between a source and target set consisting of members (i.e., controls, control statements) from the respective source and target.
 */
@MetaschemaAssembly(
    formalName = "Mapping Entry",
    description = "A relationship-based mapping between a source and target set consisting of members (i.e., controls, control statements) from the respective source and target.",
    name = "map",
    moduleClass = OscalMappingCommonModule.class
)
public class MappingEntry implements IBoundObject {
  private final IMetaschemaData __metaschemaData;

  /**
   * "The unique identifier for the mapping entry."
   */
  @BoundFlag(
      formalName = "Mapping Entry Identifier",
      description = "The unique identifier for the mapping entry.",
      name = "uuid",
      required = true,
      typeAdapter = UuidAdapter.class
  )
  private UUID _uuid;

  /**
   * "A namespace qualifying the relationship's value. This allows different organizations to associate distinct semantics for relationships with the same name."
   */
  @BoundFlag(
      formalName = "Relationship Value Namespace",
      description = "A namespace qualifying the relationship's value. This allows different organizations to associate distinct semantics for relationships with the same name.",
      name = "ns",
      defaultValue = "http://csrc.nist.gov/ns/oscal",
      typeAdapter = UriAdapter.class,
      remarks = "This value must be an [absolute URI](https://pages.nist.gov/OSCAL/concepts/uri-use/#absolute-uri) that serves as a [naming system identifier](https://pages.nist.gov/OSCAL/concepts/uri-use/#use-as-a-naming-system-identifier).\n"
              + "\n"
              + "When a `ns` is not provided, its value should be assumed to be ` http://csrc.nist.gov/ns/oscal` and the name should be a name defined by the associated OSCAL model."
  )
  private URI _ns;

  /**
   * "The method used for relating controls within the mapping. The supported methods are aligned with the <a href=\"https://doi.org/10.6028/NIST.IR.8477\">NIST Interagency Report (IR) 8477</a>, Section 4.3 Set Theory Relationship Mapping."
   */
  @BoundFlag(
      formalName = "Matching",
      description = "The method used for relating controls within the mapping. The supported methods are aligned with the [NIST Interagency Report (IR) 8477](https://doi.org/10.6028/NIST.IR.8477), Section 4.3 Set Theory Relationship Mapping.",
      name = "matching-rationale",
      typeAdapter = StringAdapter.class,
      valueConstraints = @ValueConstraints(allowedValues = @AllowedValues(level = IConstraint.Level.ERROR, values = {@AllowedValue(value = "syntactic", description = "Syntactic: How similar is the *wording* that expresses the two concepts. This is a word-for-word analysis of the relationship, not an interpretation of the language."), @AllowedValue(value = "semantic", description = "Semantic: How similar are the *meanings* of the two concepts? This involves some interpretation of each concept’s language."), @AllowedValue(value = "functional", description = "Functional: How similar are the *results* of executing the two concepts? This involves understanding what will happen if the two concepts are implemented, performed, or otherwise executed.")}))
  )
  private String _matchingRationale;

  @BoundField(
      formalName = "Mapping Entry Relationship",
      description = "The relationship type for the mapping entry, which describes the relationship between the effective requirements of the specified source and target sets in the context of the `matching-rationale` method globaly defined in the `provenance` unless overwritten locally in the ` map`. The `relationship` type and the `matching-rationale` must be used together. However, more than one `matching-rationale` method may apply to a `source` and `target` pair.",
      useName = "relationship",
      remarks = "For example, consider the CSF 1.1's PR.AC-1, \"Identities and credentials are issued, managed, verified, revoked, and audited for authorized devices, users and processes\", and the Privacy Framework's PR.AC-P1, \"Identities and credentials are issued, managed, verified, and devices.\"\n"
              + "\n"
              + "These two requirements have identical wording except for \"users\" versus \"individuals\" and the order of the last few words. With a \\`matching-rationale\\` of syntactic, the relationship type would beintersects with because the two overlap, but each includes content that the other does not. However, with a rationale of semantic, the relationship type would be equal if \"users\" and \"individuals\" have the same meaning in their respective sources, subset if \"users\" was a subset of \"individuals,\" and so on.\n"
              + "\n"
              + "When establishing relationships, mapping SHOULD be done at the control statement level where possible. This approach allows for a more accurate relationship.",
      minOccurs = 1,
      typeAdapter = TokenAdapter.class,
      valueConstraints = @ValueConstraints(allowedValues = @AllowedValues(level = IConstraint.Level.ERROR, target = ".[has-oscal-namespace('http://csrc.nist.gov/ns/oscal')]", values = {@AllowedValue(value = "equivalent-to", description = "The `source` and `target` requirements are similar, although not necessarily identical. The words may differ, but both mapped sets convey similar information with the same effective meaning. This relationship may be reversed, since \\`A equivalent-to B\\` also means that \\`B equivalent-to A\\`. This relationship is less suitable for a *syntactic* `matching-rationale` ."), @AllowedValue(value = "equal-to", description = "The `source` and `target` requirements are the same. Differences in capitalization, spelling, and grammar can be ignored, if these differences do not change the meaning. This relationship may be reversed, since \\`A equal-to B\\` also means that \\`B equal-to A\\`."), @AllowedValue(value = "subset-of", description = "The `source` requirements are a subset of ` target` requirements. In other words, `target` contains all `source`requirements and aditional others. This relationship may be reversed as a \\`superset-of\\`, since \\`A subset-of B\\` also means that \\`B superset-of A\\`."), @AllowedValue(value = "superset-of", description = "The `source` requirements are a superset of `target` requirements. In other words, ` source` contains all `target`requirements and aditional others. This relationship may be reversed as a \\`subset-of\\`, since \\`A superset-of B\\` also means that \\`B subset-of A\\`."), @AllowedValue(value = "intersects-with", description = "The `source` and `target` requirements have some overlap, but each includes content that the other does not. This relationship may be reversed, since \\`A intersects-with B\\` also means that \\`B intersects-with A\\`. A mapping at statement level could result on `relationships` mapping that allows for more inference than using this relationship type."), @AllowedValue(value = "no-relationship", description = "The `source` and `target` requirements are not related; their content does not overlap. This relation is introduced not with the intention to support exhaustiv mapping of all requirements and statements that have no overlap, but rather to support edge cases such is the need to tailor a ` relationship` in the context of a component or system to better align with the implementation and configuration of the respective component or system. Also, this `relationship` is provided in support of the [NIST IR 8477](https://doi.org/10.6028/NIST.IR.8477).")}))
  )
  private String _relationship;

  @BoundAssembly(
      formalName = "Mapping Entry Item (source or target)",
      description = "A specific edge within a source or target that is the subject of a mapping.",
      useName = "source",
      minOccurs = 1,
      maxOccurs = -1,
      groupAs = @GroupAs(name = "sources", inJson = JsonGroupAsBehavior.LIST)
  )
  private List<MappingItem> _sources;

  @BoundAssembly(
      formalName = "Mapping Entry Item (source or target)",
      description = "A specific edge within a source or target that is the subject of a mapping.",
      useName = "target",
      minOccurs = 1,
      maxOccurs = -1,
      groupAs = @GroupAs(name = "targets", inJson = JsonGroupAsBehavior.LIST)
  )
  private List<MappingItem> _targets;

  @BoundAssembly(
      formalName = "Relationship Qualifier",
      description = "Describes requirements, incompatibilities and gaps that are identified between a target and source in a mapping item.",
      useName = "qualifier",
      maxOccurs = -1,
      groupAs = @GroupAs(name = "qualifiers", inJson = JsonGroupAsBehavior.LIST)
  )
  private List<QualifierItem> _qualifiers;

  @BoundField(
      formalName = "Confidence Score",
      description = "This records either a string category or a decimal value from 0-1 representing a percentage. Both of these values describe an estimation of the author's confidence that this mapping is correct and accurate.",
      useName = "confidence-score"
  )
  private ConfidenceScore _confidenceScore;

  @BoundField(
      formalName = "Coverage",
      description = "A decimal value from 0-1, representing the percentage coverage of the targets by the sources.",
      useName = "coverage"
  )
  private Coverage _coverage;

  @BoundAssembly(
      formalName = "Property",
      description = "An attribute, characteristic, or quality of the containing object expressed as a namespace qualified name/value pair.",
      useName = "prop",
      maxOccurs = -1,
      groupAs = @GroupAs(name = "props", inJson = JsonGroupAsBehavior.LIST)
  )
  private List<Property> _props;

  @BoundAssembly(
      formalName = "Link",
      description = "A reference to a local or remote resource, that has a specific relation to the containing object.",
      useName = "link",
      maxOccurs = -1,
      groupAs = @GroupAs(name = "links", inJson = JsonGroupAsBehavior.LIST)
  )
  private List<Link> _links;

  @BoundField(
      formalName = "Remarks",
      description = "Additional commentary about the containing object.",
      useName = "remarks",
      typeAdapter = MarkupMultilineAdapter.class
  )
  private MarkupMultiline _remarks;

  public MappingEntry() {
    this(null);
  }

  public MappingEntry(IMetaschemaData data) {
    this.__metaschemaData = data;
  }

  @Override
  public IMetaschemaData getMetaschemaData() {
    return __metaschemaData;
  }

  public UUID getUuid() {
    return _uuid;
  }

  public void setUuid(UUID value) {
    _uuid = value;
  }

  public URI getNs() {
    return _ns;
  }

  public void setNs(URI value) {
    _ns = value;
  }

  public String getMatchingRationale() {
    return _matchingRationale;
  }

  public void setMatchingRationale(String value) {
    _matchingRationale = value;
  }

  public String getRelationship() {
    return _relationship;
  }

  public void setRelationship(String value) {
    _relationship = value;
  }

  public List<MappingItem> getSources() {
    return _sources;
  }

  public void setSources(List<MappingItem> value) {
    _sources = value;
  }

  /**
   * Add a new {@link MappingItem} item to the underlying collection.
   * @param item the item to add
   * @return {@code true}
   */
  public boolean addSource(MappingItem item) {
    MappingItem value = ObjectUtils.requireNonNull(item,"item cannot be null");
    if (_sources == null) {
      _sources = new LinkedList<>();
    }
    return _sources.add(value);
  }

  /**
   * Remove the first matching {@link MappingItem} item from the underlying collection.
   * @param item the item to remove
   * @return {@code true} if the item was removed or {@code false} otherwise
   */
  public boolean removeSource(MappingItem item) {
    MappingItem value = ObjectUtils.requireNonNull(item,"item cannot be null");
    return _sources != null && _sources.remove(value);
  }

  public List<MappingItem> getTargets() {
    return _targets;
  }

  public void setTargets(List<MappingItem> value) {
    _targets = value;
  }

  /**
   * Add a new {@link MappingItem} item to the underlying collection.
   * @param item the item to add
   * @return {@code true}
   */
  public boolean addTarget(MappingItem item) {
    MappingItem value = ObjectUtils.requireNonNull(item,"item cannot be null");
    if (_targets == null) {
      _targets = new LinkedList<>();
    }
    return _targets.add(value);
  }

  /**
   * Remove the first matching {@link MappingItem} item from the underlying collection.
   * @param item the item to remove
   * @return {@code true} if the item was removed or {@code false} otherwise
   */
  public boolean removeTarget(MappingItem item) {
    MappingItem value = ObjectUtils.requireNonNull(item,"item cannot be null");
    return _targets != null && _targets.remove(value);
  }

  public List<QualifierItem> getQualifiers() {
    return _qualifiers;
  }

  public void setQualifiers(List<QualifierItem> value) {
    _qualifiers = value;
  }

  /**
   * Add a new {@link QualifierItem} item to the underlying collection.
   * @param item the item to add
   * @return {@code true}
   */
  public boolean addQualifier(QualifierItem item) {
    QualifierItem value = ObjectUtils.requireNonNull(item,"item cannot be null");
    if (_qualifiers == null) {
      _qualifiers = new LinkedList<>();
    }
    return _qualifiers.add(value);
  }

  /**
   * Remove the first matching {@link QualifierItem} item from the underlying collection.
   * @param item the item to remove
   * @return {@code true} if the item was removed or {@code false} otherwise
   */
  public boolean removeQualifier(QualifierItem item) {
    QualifierItem value = ObjectUtils.requireNonNull(item,"item cannot be null");
    return _qualifiers != null && _qualifiers.remove(value);
  }

  public ConfidenceScore getConfidenceScore() {
    return _confidenceScore;
  }

  public void setConfidenceScore(ConfidenceScore value) {
    _confidenceScore = value;
  }

  public Coverage getCoverage() {
    return _coverage;
  }

  public void setCoverage(Coverage value) {
    _coverage = value;
  }

  public List<Property> getProps() {
    return _props;
  }

  public void setProps(List<Property> value) {
    _props = value;
  }

  /**
   * Add a new {@link Property} item to the underlying collection.
   * @param item the item to add
   * @return {@code true}
   */
  public boolean addProp(Property item) {
    Property value = ObjectUtils.requireNonNull(item,"item cannot be null");
    if (_props == null) {
      _props = new LinkedList<>();
    }
    return _props.add(value);
  }

  /**
   * Remove the first matching {@link Property} item from the underlying collection.
   * @param item the item to remove
   * @return {@code true} if the item was removed or {@code false} otherwise
   */
  public boolean removeProp(Property item) {
    Property value = ObjectUtils.requireNonNull(item,"item cannot be null");
    return _props != null && _props.remove(value);
  }

  public List<Link> getLinks() {
    return _links;
  }

  public void setLinks(List<Link> value) {
    _links = value;
  }

  /**
   * Add a new {@link Link} item to the underlying collection.
   * @param item the item to add
   * @return {@code true}
   */
  public boolean addLink(Link item) {
    Link value = ObjectUtils.requireNonNull(item,"item cannot be null");
    if (_links == null) {
      _links = new LinkedList<>();
    }
    return _links.add(value);
  }

  /**
   * Remove the first matching {@link Link} item from the underlying collection.
   * @param item the item to remove
   * @return {@code true} if the item was removed or {@code false} otherwise
   */
  public boolean removeLink(Link item) {
    Link value = ObjectUtils.requireNonNull(item,"item cannot be null");
    return _links != null && _links.remove(value);
  }

  public MarkupMultiline getRemarks() {
    return _remarks;
  }

  public void setRemarks(MarkupMultiline value) {
    _remarks = value;
  }

  @Override
  public String toString() {
    return new ReflectionToStringBuilder(this, ToStringStyle.MULTI_LINE_STYLE).toString();
  }
}