<?php

$ignoreTypes = array(

                     "doc:description"         => true,

                     "doc:example"             => true,

                     "doc:moduleDescription"   => true,

                     "doc:moduleDocs"          => true,

                     "doc:moduleName"          => true,

                     "doc:recommendedUsage"    => true,

                     "doc:standAlone"          => true,

                     "doc:summary"             => true,

                     "doc:tooltip"             => true,

                     "xsd:annotation"          => true,

                     "xsd:appinfo"             => true,

                     "xsd:documentation"       => true,

                     "xsd:import"              => true,

                     "xsd:include"             => true,

                     "xsd:schema"              => true,

                     "AdditionalAbbreviations" => true,

                     "BacteriaStatus"          => true,

                     "BioCodeStatus"           => true,

                     "BotanyStatus"            => true,

                     "li"                      => true,

                     "p"                       => true,

                     "para"                    => true,

                     "PreferredAbbreviation"   => true,

                     "section"                 => true,

                     "Specification"           => true,

                     "SuffixAlgae"             => true,

                     "SuffixAnimalia"          => true,

                     "SuffixBacteriae"         => true,

                     "SuffixFungi"             => true,

                     "SuffixFungi"             => true,

                     "SuffixPlantae"           => true,

                     "title"                   => true,

                     "ul"                      => true,

                     "ZoologyStatus"           => true);

function isIgnoreType($nodeName) {

  global $ignoreTypes;

  return $ignoreTypes[$nodeName];

}

$files = array(

               'eml-access.xsd',

               'eml-coverage.xsd',

               'eml-documentation.xsd',

               'eml-literature.xsd',

               'eml-party.xsd',

               'eml-project.xsd',

               'eml-resource.xsd',

               'eml-text.xsd',

               'tcsv101.xsd',

               'tdwg_basetypes.xsd',

               'tdwg_dw_element.xsd',

               'tdwg_dw_geospatial.xsd',

               'veg-misc.xsd',

               'veg-organismobservation.xsd',

               'veg-plotobservation.xsd',

               'veg.xsd',

               'veg-plot.xsd');

function hasImportantNodes($node) {

  $nodes = $node->getElementsbyTagName("*");

  foreach($nodes as $node) {

    $nodeName = preg_replace("/xs:/","xsd:",$node->nodeName);

    if(!isIgnoreType($nodeName)) {

      return true;

    }

  }

  return false;

}

$primitiveTypes = array(

  'DEFCATEGORIE' => 'enumerated string',

  'decimalLatitudeDataType' => 'xs:double [-90,90]',

  'decimalLongitudeDataType' => 'xs:double [-180,180]',

  'spatialFitDataType' => 'xs:double (0 or >1 or undefined)',

  'PERCENT' => 'xsd:decimal [0,100]',

  'RoleType' => 'xs:string (union of enumerated string & unenumerated string)',

  'TaxonomicRankEnum' => 'xs:Name (union of several enumerated string types for one big list of enum values)',

  'TINYINT' => 'xsd:decimal [-128,128]',

  'yearDate' => 'xs:gYear xs:date (union of)',

  'anyType' => 'xsd:anyType',

  'InlineType' => 'xs:anyType',

  'date' => 'xsd:date',

  'anyURI' => 'xs:anyURI',

  'decimal' => 'xsd:decimal',

  'gYear' => 'xsd:gYear',

  'string' => 'xs:string',

  'positiveInteger' => 'xs:positiveInteger',

  'time' => 'xs:time',

  'double' => 'xs:double',

  'integer' => 'xs:integer',

  'Name' => 'xs:Name',

  'NMTOKEN' => 'xs:NMTOKEN',

  'DateTimeISO' => 'xs:string',

  'dayOfYearDataType' => 'xs:integer',

  'DescriptorType' => 'xs:string',

  'FunctionType' => 'xs:string',

  'GRingType' => 'xs:anyType',

  'IDType' => 'xs:string',

  'KeyTypeCode' => 'xs:string',

  'MEDIUMINT' => 'xs:decimal',

  'NomenclaturalCodesEnum' => 'xsd:Name',

  'NomenclaturalTypeStatusOfUnitsEnum' => 'xsd:Name',

  'positiveDouble' => 'xs:double',

  'probabilityType' => 'xs:double',

  'ScopeType' => 'xs:string',

  'SMALLINT' => 'xs:decimal',

  'STRATUMINDEX' => 'xs:string',

  'SystemType' => 'xs:string',

  'TaxonomicRankAboveSuperfamilyEnum' => 'xsd:Name',

  'TaxonomicRankBelowSubspeciesEnum' => 'xsd:Name',

  'TaxonomicRankCultivatedPlants' => 'xsd:Name',

  'TaxonomicRankFamilyGroupEnum' => 'xsd:Name',

  'TaxonomicRankFamilySubdivisionEnum' => 'xsd:Name',

  'TaxonomicRankGenusGroupEnum' => 'xsd:Name',

  'TaxonomicRankGenusSubdivisionEnum' => 'xsd:Name',

  'TaxonomicRankSpeciesGroupEnum' => 'xsd:Name',

);

$primitiveGroupings = array();

$primitiveGroupingsVariableLength = array();

#Find all primitive groupings and primitive groupings of variable length.

foreach($files as $file) {

  global $primitiveTypes;

  global $primitiveGroupings;

  global $primitiveGroupingsVariableLength;

  $xmlDoc = new DOMDocument();

  $xmlDoc->load($file);

  $nodes = $xmlDoc->getElementsByTagName("*");

  foreach($nodes as $node) {

    $variable = false;

    $isPrimitiveGroup = true;

    $nodeName = preg_replace("/xs:/","xsd:",$node->nodeName);

    if(!isIgnoreType($nodeName)) {

      if($nodeName == 'xsd:complexType' || $nodeName == 'xsd:simpleType') {

        $actualName = $node->getAttribute('name');

        $actualName = preg_replace("/.*:/","",$actualName);

        #Empty string is not a type

        if($actualName == '') {

          $isPrimitiveGroup = false;

        }

        #Don't need to evaluate if we know it to be primitive

        if(array_key_exists($actualName,$primitiveTypes)) {

          $isPrimitiveGroup = false;

        }

        #maxOccurs can show up in several child node types, so just look for it in all of them

        $elements = $node->getElementsByTagName("*");

        foreach($elements as $element) {

          $maxOccurs = $element->getAttribute('maxOccurs');

          if($maxOccurs == 'unbounded' || $maxOccurs > 1) { $variable = true; }

        }

        $elements = $node->getElementsByTagName("element");

        foreach($elements as $element) {

          $elementType = $element->getAttribute('type');

          $elementType = preg_replace("/.*:/","",$elementType);

          if($elementType != '' && $elementType != $actualName &&

             !array_key_exists($elementType,$primitiveTypes)) {

            $isPrimitiveGroup = false;

            break;

          }

        }

        if($isPrimitiveGroup) {

          if($variable) {

            $primitiveGroupingsVariableLength[$actualName] = 1;

          } else {

            $primitiveGroupings[$actualName] = 1;

          }

        }

      }

    }

  }

}

print "primitive groupings:\n";

foreach(array_keys($primitiveGroupings) as $key) {

  print $key . "\n";

}

print "\n\n";

print "primitive groupings variable length:\n";

foreach(array_keys($primitiveGroupingsVariableLength) as $key) {

  print $key . "\n";

}

function alreadyFound($name,$tiers) {

  foreach($tiers as $tierArray) {

    if(array_key_exists($name,$tierArray)) {

      return true;

    }

  }

  return false;

}

function findTierEntities($previousTiers) {

  global $files;

  $returnArray = array();

  foreach($files as $file) {

    $xmlDoc = new DOMDocument();

    $xmlDoc->load($file);

    $nodes = $xmlDoc->getElementsByTagName("*");

    foreach($nodes as $node) {

      $isInTier = true;

      $nodeName = preg_replace("/xs:/","xsd:",$node->nodeName);

      if(!isIgnoreType($nodeName)) {

        if($nodeName == 'xsd:complexType' || $nodeName == 'xsd:simpleType') {

          $actualName = $node->getAttribute('name');

          $actualName = preg_replace("/.*:/","",$actualName);

          #Empty string is not a type

          if($actualName == '') {

            $isInTier = false;

          }

          #Don't need to evaluate if we know it to be in lower tiers

          if(alreadyFound($actualName,$previousTiers)) {

            $isInTier = false;

          }

          $elements = $node->getElementsByTagName("element");

          foreach($elements as $element) {

            $elementType = $element->getAttribute('type');

            $elementType = preg_replace("/.*:/","",$elementType);

            if($elementType != '' && $elementType != $actualName &&

               !alreadyFound($elementType,$previousTiers)) {

              $isInTier = false;

              break;

            }

          }

          if($isInTier) {

            $returnArray[$actualName] = 1;

          }

        }

      }

    }

  }

  return $returnArray;

}

$prevTiers = array($primitiveTypes,$primitiveGroupings,$primitiveGroupingsVariableLength);

print "\n\n";

$tier1 = findTierEntities($prevTiers);

print "tier 1 entities:\n";

foreach(array_keys($tier1) as $key) {

  print $key . "\n";

}

$prevTiers = array($primitiveTypes,$primitiveGroupings,$primitiveGroupingsVariableLength,$tier1);

print "\n\n";

$tier2 = findTierEntities($prevTiers);

print "tier 2 entities:\n";

foreach(array_keys($tier2) as $key) {

  print $key . "\n";

}

$prevTiers = array($primitiveTypes,$primitiveGroupings,$primitiveGroupingsVariableLength,$tier1,$tier2);

print "\n\n";

$tier3 = findTierEntities($prevTiers);

print "tier 3 entities:\n";

foreach(array_keys($tier3) as $key) {

  print $key . "\n";

}

$prevTiers = array($primitiveTypes,$primitiveGroupings,$primitiveGroupingsVariableLength,$tier1,$tier2,$tier3);

print "\n\n";

$tier4 = findTierEntities($prevTiers);

print "tier 4 entities:\n";

foreach(array_keys($tier4) as $key) {

  print $key . "\n";

}

$prevTiers = array($primitiveTypes,$primitiveGroupings,$primitiveGroupingsVariableLength,$tier1,$tier2,$tier3,$tier4);

print "\n\n";

$tier5 = findTierEntities($prevTiers);

print "tier 5 entities:\n";

foreach(array_keys($tier5) as $key) {

  print $key . "\n";

}

#5 is as deep as we get

$tot = array_merge($primitiveTypes,$primitiveGroupings,$primitiveGroupingsVariableLength,$tier1,$tier2,$tier3,$tier4);

print count($tot) . "\n";

?>