package gw.systables.verifier

uses gw.api.locale.DisplayKey
uses com.guidewire.pc.system.dependency.PCTypeloaderDependencies
uses gw.entity.IEntityType
uses gw.lang.reflect.TypeSystem
uses gw.xml.parser2.PLXMLNode

uses java.util.List
uses java.util.Map
uses java.util.Set

@ReadOnly
class DefinedFieldsVerifier extends VerifierBase {

  /**
   * For each entity to be imported, verifies that all fields in the input XML has
   * a property defined in the data model.
   */
  override function verify(importNode : PLXMLNode) : Map<PLXMLNode, List<String>> {
    var results : Map<PLXMLNode, List<String>> = {}
    var nodesByType = partitionNodesByType(importNode)
    for (var entityType in nodesByType.Keys) {
      results.putAll(verifyAllowedFields(nodesByType, entityType))    
      results.putAll(verifyRequiredFields(nodesByType, entityType))
    }
    return results
  }

  private function verifyAllowedFields(nodes : Map<IEntityType, List<PLXMLNode>>, entityType : IEntityType) : Map<PLXMLNode, List<String>> {
    var results : Map<PLXMLNode, List<String>> = {}
    var allowedFields = getAllowedFields(entityType)
    for (var node in nodes.get(entityType)) {
      for (var child in node.Children) {
        if (not allowedFields.contains(child.ElementName)) {
          addErrorToResults(
                  DisplayKey.get("Java.ValidationError.SystemTables.UnknownField", child.ElementName),
                  node,
                  results)
        }
      }
    }
    return results
  }
  
  private function verifyRequiredFields(nodes : Map<IEntityType, List<PLXMLNode>>, entityType : IEntityType) : Map<PLXMLNode, List<String>> {
    var results : Map<PLXMLNode, List<String>> = {}
    var requiredFields = getRequiredFields(entityType)
    nodes.get(entityType).each(\ node -> {
      var columnNames = node.Children*.ElementName.toSet()
      var missingColumns = requiredFields.subtract(columnNames)
      missingColumns.each(\ s -> {
        addErrorToResults(
                  DisplayKey.get("Java.ValidationError.SystemTables.NullOrEmptyField", s),
                  node,
                  results)
      })
    })
    return results 
  }

  function getRequiredFields(entityType : IEntityType) : Set<String> {
    var fileDef = PCTypeloaderDependencies.getProductModelNodeLoader().getSystablesDefinition().getFileDefinitionForEntity(entityType)
    return fileDef.getAllowedXmlProperties(entityType).where(\ s -> s.Required)*.Name?.toSet()
  }

  function getAllowedFields(entityType : IEntityType) : Set<String> {
    var fileDef = PCTypeloaderDependencies.getProductModelNodeLoader().getSystablesDefinition().getFileDefinitionForEntity(entityType)
    return fileDef.getAllowedXmlProperties(entityType)*.Name?.toSet()
  }

  /**
   * @param importNode The root node of the file
   * @return All the nodes split up by the IEntityType implied by the
   *         element name of each child node.
   */
  private function partitionNodesByType(importNode : PLXMLNode) : Map<IEntityType, List<PLXMLNode>> {
    var nodesByElementName = importNode.Children.partition(\ n -> n.ElementName)
    var types = nodesByElementName.Keys.partitionUniquely(\ k -> TypeSystem.getByRelativeName(k) as IEntityType)
    return types.mapValues(\ tn -> nodesByElementName[tn])
  }

}