<?php

require_once('util/utilityFunctions.php');

require_once('objects/types.php');

class Entity {

  private $references = array();

  private $members = array();

  private $referrers = array();

  private $tableName;

  private $extensionType;

  private $inited;

  public function __construct($tableName,$node = null) {

    global $eList;

    // Entity name = table name

    $this->tableName = $tableName;

    $this->inited = False;

    $this->extensionType = '';

    if(!is_null($node)) {

      $this->init($tableName,$node);

      $this->inited = True;

    }

  }

  public function init($tableName,$node) {

    global $primitiveTypes;

    global $eList;

    $xpath = new DOMXPath($node->ownerDocument);

    $childNodesXPath = $xpath->query("child::node()",$node);

    $childNodes = array();

    foreach($childNodesXPath as $childNodeXPath) {

      $cNodeName = preg_replace("/.*:/","",$childNode->nodeName);

      if(!isIgnoreType($cNodeName)) {

        $childNodes[] = $childNodeXPath;

      }

    }

    for($i = 0; $i < count($childNodes); $i++) {

      $childNode = $childNodes[$i];

      $cNodeName = preg_replace("/.*:/","",$childNode->nodeName);

      if(isIgnoreType($cNodeName)) {

        continue;

      }

      #Very inefficient, but I want to be sure that I've handled all possible

      #attribute types.

      $attrs = $xpath->query("attribute::*",$childNode);

      foreach($attrs as $attr) {

        $attrName = $attr->name;

        if(!isKnownAttribute($attrName)) {

          throw new Exception("Encountered unkown attribute: $attrName in element $this->tableName.");

        }

      }

      switch($cNodeName) {

        #Untested

        case 'any':

          $any_e = $eList->newEntity($tableName . "_any_nodes");

          $any_e->addMember("node_name","models.CharField(max_length=255)");

          $any_e->addMember("node_value","models.TextField()");

          $any_e->addOneToManyReference($tableName . "_id",$this);

          $this->referrers['anyNode'] = $tableName . '_any_nodes';

          break;

        case 'anyAttribute':

          $any_a = $eList->newEntity($tableName . "_any_attr");

          $any_a->addMember("attr_name","models.CharField(max_length=255)");

          $any_a->addMember("attr_value","models.CharField(max_length=255)");

          $any_a->addOneToManyReference($tableName . "_id",$this);

          $this->referrers['anyAttribute'] = $tableName . '_any_attr';

          break;

        case 'attribute':

          $a_name = $childNode->getAttribute('name');

          if($a_name == '') {

            throw new Exception("Nodes defining attributes must have a name.  " .

                                "Unnamed attribute node found in $this->tableName.");

          }

          $default = $childNode->getAttribute('default');

          $use = $childNode->getAttribute('use');

          $type = preg_replace("/.*:/","",$childNode->getAttribute('type'));

          $guess = False;

          if($primitiveTypes[$type] != '') {

            $def = $primitiveTypes[$type];

          } else {

            $def = "models.CharField(max_length=255";

          }

          if($use == 'optional') {

            if($def == 'models.CharField(max_length=255') { $def .= ", "; }

            $def .= "null=True, blank=True";

          }

          if($default != '') {

            if($use == 'optional' ||

               $def == 'models.CharField(max_length=255') {

              $def .= ", ";

            }

            $def .= "default = '$default'";

          }

          $def .= ")";

          if($guess) { $def .= " # This is a guess"; }

          $this->addMember("attr_$a_name",$def);

          break;

        #Untested

        case 'group':

          if(hasImportantNodes($childNode)) {

            throw new Exception("No defined functionality for group nodes defining complex entities " .

                                "within other complex entities.");

          }

          $ref = preg_replace("/.*:/","",$childNode->getAttribute('ref'));

          if($ref == '') {

            throw new Exception("No defined functionality for group nodes " .

                                "that don't have a 'ref' attribute.");

          }

          $this->determineRelationship($ref,$ref,$childNode);

          break;

        case 'complexType':

          $name = $childNode->getAttribute('name');

          if($name != '') {

            throw new Exception("Named complexType definition within entity definition. " .

                                "This functionality is not yet implemented.");

          }

        case 'simpleType':

          $name = $childNode->getAttribute('name');

          if(isPrimitiveType($name)) {

            break;

          }

          if($name != '') {

            throw new Exception("Named simpleType definition within entity definition. " .

                                "This functionality is not yet implemented.");

          }

        case 'choice':

          # Fracking hack

          $isChoice = True;

        case 'complexContent':

        case 'simpleContent':

        case 'sequence':

          $minOccurs = $childNode->getAttribute('minOccurs');

          if($isChoice) {

            $minOccurs = 0;

          }

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

          #If defined, need to use pass these attribues through to child nodes.

          #Then, we add the grandchid nodes to the node list since we need the

          #grandchild nodes to complete the entity definition.

          $grandchildNodesXPath = $xpath->query("child::node()",$childNode);

          foreach($grandchildNodesXPath as $grandchildNodeXPath) {

            $gcNodeName = preg_replace("/.*:/","",$grandchildNodeXPath->nodeName);

            if(isIgnoreType($gcNodeName)) {

              continue;

            }

            if(((string)$minOccurs) != '') {

              $grandchildNodeXPath->setAttribute("minOccurs",$minOccurs);

            }

            if(((string)$maxOccurs) != '') {

              $grandchildNodeXPath->setAttribute("maxOccurs",$maxOccurs);

            }

            $childNodes[] = $grandchildNodeXPath;

          }

          #None of these have implemented functionality, need to fail if we reach

          #them during exection.

          $err_type = '';

          $default = $childNode->getAttribute('default');

          if($default != '' ) {

            $err_type = "default";

          }

          $use = $childNode->getAttribute('use');

          if($use != '' ) {

            $err_type = "use";

          }

          $mixed = $childNode->getAttribute('mixed');

          if($mixed != '' ) {

            $err_type = "mixed";

          }

          $type = $childNode->getAttribute('type');

          if($type != '' ) {

            $err_type = "type";

          }

          $namespace = $childNode->getAttribute('namespace');

          if($namespace != '' ) {

            $err_type = "namespace";

          }

          $nillable = $childNode->getAttribute('nillable');

          if($nillable != '' ) {

            $err_type = "nillable";

          }

          $ref = $childNode->getAttribute('ref');

          if($ref != '' ) {

            $err_type = "ref";

          }

          $base = $childNode->getAttribute('base');

          if($base != '' ) {

            $err_type = "base";

          }

          if($err_type != '') {

            throw new Exception("$err_type not defined for pass-through.");

          }

          break;

        case 'element':

          $this->handleElementCase($childNode);

          break;

        case 'extension':

          $name = findFirstAncestorName($childNode);

          $base = preg_replace("/.*:/","",$childNode->getAttribute('base'));

          if(isPrimitiveType($base)) {

            $grandchildNodesXPath = $xpath->query("child::node()",$childNode);

            foreach($grandchildNodesXPath as $grandchildNodeXPath) {

              $gcNodeName = preg_replace("/.*:/","",$grandchildNodeXPath->nodeName);

              if(isIgnoreType($gcNodeName)) {

                continue;

              }

              if($gcNodeName != 'attribute') {

                throw new Exception("Extension of primitive types can only add attributes, ".

                                    "found $gcNodeName.");

              }

              $a_name = $grandchildNodeXPath->getAttribute('name');

              if($a_name == '') {

                throw new Exception("Nodes defining attributes must have a name.  " .

                                    "Unnamed attribute node found in $this->tableName.");

              }

              $default = $grandchildNodeXPath->getAttribute('default');

              $use = $grandchildNodeXPath->getAttribute('use');

              $type = preg_replace("/.*:/","",$grandchildNodeXPath->getAttribute('type'));

              $guess = False;

              if($primitiveTypes[$type] != '') {

                $def = $primitiveTypes[$type];

              } else {

                $def = "models.CharField(max_length=255";

                $guess = True;

              }

              if($use == 'optional') {

                if($def == 'models.CharField(max_length=255') { $def .= ", "; }

                $def .= "null=True, blank=True";

              }

              if($default != '') {

                if($use == 'optional' ||

                   $def == 'models.CharField(max_length=255') { $def .= ", "; }

                $def .= "default = '$default'";

              }

              $def .= ")";

              if($guess) { $def .= " # This is a guess"; }

              $this->addMember("attr_$a_name",$def);

            }

            $def = $primitiveTypes[$base] . ")";

            $this->addMember("primitive_type_value",$def);

          } else {

            $ref_e = $eList->getEntityForReference($base);

            $this->addOneToOneReference($base . "_extend",$ref_e);

            $this->extensionType = $base;

            $grandchildNodesXPath = $xpath->query("child::node()",$childNode);

            foreach($grandchildNodesXPath as $grandchildNodeXPath) {

              $gcNodeName = preg_replace("/.*:/","",$grandchildNodeXPath->nodeName);

              if(isIgnoreType($gcNodeName)) {

                continue;

              }

              $childNodes[] = $grandchildNodeXPath;

            }

          }

          break;

        case 'restriction':

        case 'union':

        case 'maxInclusive':

        case 'minInclusive':

        case 'minExclusive':

        case 'list':

        case 'pattern':

        case 'fractionDigits':

          throw new Exception("No functionality defined for nodes of type: $cNodeName");

          break;

        default:

          throw new Exception("Encountered uknown nodes type: $cNodeName");

          break;

      }

    }

  }

  public function handleElementCase($childNode) {

    global $eList;

    global $primitiveTypes;

    $ref = preg_replace("/.*:/","",$childNode->getAttribute('ref'));

    $type = preg_replace("/.*:/","",$childNode->getAttribute('type'));

    if($ref != '') {

      $type = $ref;

    }

    $name = $childNode->getAttribute('name');

    if($ref != '' && $name == '') {

      $name = $this->tableName . "_" . $ref;

    }

    if($name == '') {

      throw new Exception("All element nodes must have a name attribute, " .

                          "or a ref attribute to serve as the name.");

    }

    if($type != '') {

      $this->determineRelationship($name,$type,$childNode);

    } else {

      #Very hacky, but there a some cases where the element

      #has no type, and either 1) has some children nodes, but none of the

      #children nodes define a type, or 2) Has no useful nodes at all.

      # In this case the node is considered to be an anyType.

      $isDefined = False;

      $xpath = new DOMXPath($childNode->ownerDocument);

      $grandchildNodesXPath = $xpath->query("child::node()",$childNode);

      foreach($grandchildNodesXPath as $grandchildNodeXPath) {

        $gcNodeName = preg_replace("/.*:/","",$grandchildNodeXPath->nodeName);

        if(isIgnoreType($gcNodeName)) {

          continue;

        }

        if(hasImportantNodes($grandchildNodeXPath) || $grandchildNodeXPath->hasAttributes()) {

          $isDefined = True;

        }

      }

      if(!$isDefined) {

        $primitiveTypes[$name] = 'models.TextField(';

      }

      if(!isPrimitiveType($name)) {

        $eList->newEntity($name,$childNode);

      }

      $this->determineRelationship($name,$name,$childNode);

    }

  }

  public function determineRelationship($colName,$typeName,$node) {

    global $eList;

    global $primitiveTypes;

    $tableName = $this->tableName;

    $minOccurs = $node->getAttribute('minOccurs');

    $optional = $minOccurs == 0 ? True : False;

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

    $default = $node->getAttribute('default');

    $default = $node->getAttribute('use');

    if(isPrimitiveType($typeName)) {

      $def = $primitiveTypes[$typeName];

      if($use == 'optional' || $optional) {

        if($def == 'models.CharField(max_length=255') { $def .= ", "; }

        $def .= "null=True, blank=True";

      }

      if($default != '') {

        if($use == 'optional' || $optional ||

           $def == 'models.CharField(max_length=255') {

          $def .= ", ";

        }

        $def .= "default = '$default'";

      }

      $def .= ")";

      if(((string)$maxOccurs) == '' || $maxOccurs == 1) {

        $this->addMember($colName,$def);

      } else {

        $refName = $this->tableName . "_" . $colName;

        $new_e = $eList->getEntityForReference($refName);

        $new_e->addMember("primitive_type_value",$def);

        $new_e->addOneToManyReference($tableName . "_id",$this);

        $this->referrers[$colName] = $refName;

      }

    } else {

      $ref_e = $eList->getEntityForReference($typeName);

      if(((string)$maxOccurs) == '' || $maxOccurs == 1) {

        $this->addOneToOneReference($colName,$ref_e,$optional);

      } else {

#        echo "Need to define relationship between:\n  $tableName <--> $typeName\n";

#        echo "    (O)ne to Many\n    (M)any to Many\n";

#        echo "    Your choice:  ";

#        $handle = fopen ("php://stdin","r");

#        $line = fgets($handle);

$line = 'M';

        if(trim($line) == 'O' || trim($line) == 'o'){

          $ref_e->addOneToManyReference($colName,$this);

          $this->referrers[$colName] = $ref_e->getName();

        } else {

          $this->addManyToManyReference($colName,$ref_e,$tableName . "_" . $typeName . "_" . $colName);

        }

      }

    }

  }

  private function addReference($colName,$definition) {

    # Probably shouldn't allow duplicate entries, most likely points to a problem.

    if(array_key_exists($colName,$this->references)) {

     $curDef = $this->references[$colName];

     throw new Exception("Attempting to overwrite/reinsert member $colName:$curDef with $colName:$definition in entity " . $this->tableName . ".");

    }

    $this->references[$colName] = $definition;

  }

  public function isInited() {

    return $this->inited;

  }

  public function addOneToOneReference($colName,$e,$optional = False) {

    $eName = $e->getName();

    $relatedName = $this->tableName . "_" . $colName;

    #$def = "models.OneToOneField('$eName', primary_key=True,related_name='$relatedName'";

    $def = "models.ForeignKey('$eName', unique=True,related_name='$relatedName'";

    if($optional) {

      $def .= ", null=True, blank=True";

    }

    $def .= ")";

    $this->addReference($colName,$def);

  }

  public function addOneToManyReference($colName,$e,$optional = False) {

    $eName = $e->getName();

    if($eName == $this->tableName) {

      $eName = 'self';

    }

    $relatedName = $this->tableName . "_" . $colName;

    $def = "models.ForeignKey('$eName',related_name='$relatedName'";

    if($optional) {

      $def .= ", null=True, blank=True";

    }

    $def .= ")";

    $this->addReference($colName,$def);

  }

  public function addManyToManyReference($colName,$e,$db_table = '') {

    $eName = $e->getName();

    $relatedName = $this->tableName . "_" . $colName;

    $def = "models.ManyToManyField('$eName',related_name='$relatedName'";

    #Django chokes if the table/relation names are too long.  54 characters seems to

    #be a decent magic number.

    if($db_table != '' && strlen($db_table) > 54) {

      $db_table = 'v_' . substr($db_table,0,54);

      $def .= ",db_table = '$db_table'";

    }

    $def .= ")";

    $this->addReference($colName,$def);

  }

  public function addMember($colName, $definition) {

    # Probably shouldn't allow duplicate entries, most likely points to a problem.

    if(array_key_exists($colName,$this->members)) {

      $curDef = $this->members[$colName];

      if($curDef != $definition) {

        throw new Exception("Attempting to overwrite/reinsert member $colName:$curDef with $colName:$definition.");

      }

    }

    $this->members[$colName] = $definition;

  }

  public function getName() {

    return $this->tableName;

  }

  public function getReferences() {

    return $this->references;

  }

  public function getMembers() {

    return $this->members;

  }

  public function getReferrers() {

    return $this->referrers;

  }

  public function postProcess() {

    global $eList;

    #If we're dealing with extensions we need to pull the members, references, &

    #referrers of the base class.

    if($this->extensionType != '') {

      $base = $eList->getEntityForReference($this->extensionType);

      $baseReferences = $base->getReferences();

      $baseMembers = $base->getMembers();

      $baseReferrers = $base->getReferrers();

      $this->references = array_merge($this->references,$baseReferences);

      foreach(array_keys($this->references) as $k) {

        $def = $this->references[$k];

        $baseToken = $base->getName() . "_";

        $tableToken = $this->tableName . "_";

        $def = preg_replace("/$baseToken/","$tableToken",$def);

        $this->references[$k] = $def;

      }

      $this->members = array_merge($this->members,$baseMembers);

      $this->referrers = array_merge($this->referrers,$baseReferrers);

    }

  }

  public function toString() {

    $str = "class " . $this->tableName . "(models.Model):\n";

    #Needed to keep Django from choking:

    if(count($this->references) == 0 &&

       count($this->members) == 0) {

      $str .= "  id = models.AutoField(primary_key=True)";

    }

    foreach(array_keys($this->references) as $colName) {

      $def = $this->references[$colName];

      $str .= "  $colName = $def\n";

    }

    foreach(array_keys($this->members) as $colName) {

      $def = $this->members[$colName];

      $str .= "  $colName = $def\n";

    }

    $str .= "\n" . $this->makeExportFunction();

    $str .= "\n" . $this->makeImportFunction();

    $str .= "\n" . $this->makeExportDummyDataFunction();

    #truncate table names that are too long for Django/Postgre to support

    if(strlen($this->tableName) > 54) {

      $tabName = 'v_' . substr($this->tableName,0,54);

      $str .= "\n\n  class Meta:\n".

              "    db_table = u'$tabName'\n\n";

    }

    return $str;

  }

  public function makeImportFunction() {

    #Slightly different if there are no members

    if(count($this->references) == 0 &&

       count($this->members) == 0 &&

       count($this->referrers) == 0) {

      return "  def importVegX(self,node):\n"."    self.save()\n";

    }

    $def =  "  def importVegX(self,node):\n";

    if(preg_match_all("/([a-zA-Z]*)_extend/",implode(",",array_keys($this->references)),$matches) > 0) {

      $base = $matches[1][0];

      $def .= "    extendedEl = $base()\n".

              "    extendedEl.importVegX(node)\n".

              "    self.$base"."_extend = extendedEl\n\n";

    }

    $def .= "    self.save()\n";

    #Fun hack for anyAttribute & anyNode nodes

    if(preg_match("/_any_attr/",$this->tableName,$matches) > 0 ||

       preg_match("/_any_nodes/",$this->tableName,$matches) > 0) {

      return $def;

    }

    if(preg_match("/attr_/",implode(",",array_keys($this->members))) > 0 ||

       preg_match("/anyAttribute/",implode(",",array_keys($this->referrers))) > 0) {

      $def .= "    #attributes\n".

              "    for attr in node.attributes.keys():\n".

              "      aName = 'attr_' + attr\n".

              "      aVal = node.attributes[attr].nodeValue\n";

      $i = 0;

      foreach(array_keys($this->members) as $colName) {

        $ifStmt = $i == 0 ? 'if' : 'elif';

        if(preg_match("/^attr_/",$colName,$matches) > 0) {

          $i += 1;

          if(preg_match("/BooleanField/",$this->members[$colName],$matches) > 0) {

            $def .= "      $ifStmt aName == '$colName' and (aVal == 'true' or\n".

                    "      aVal == 'false' or aVal == 0 or aVal == 1):\n".

                    "        self.$colName = (aVal == 'true' or aVal == 1)\n";

          } else {

            $def .= "      $ifStmt aName == '$colName':\n".

                    "        self.$colName = aVal\n";

          }

        }

      }

    }

    if(preg_match("/anyAttribute/",implode(",",array_keys($this->referrers))) > 0) {

      $type = $this->referrers['anyAttribute'];

      $tIDName = $this->tableName . "_id";

      if(preg_match_all("/attr_/",implode(",",array_keys($this->members)),$matches) > 0) {

        $def .= "      else:\n".

                "        newEl = $type()\n".

                "        newEl.$tIDName = self\n".

                "        newEl.attr_name = attr\n".

                "        newEl.attr_value = aVal\n".

                "        newEl.save()\n";

      } else {

        $def .= "      newEl = $type()\n".

                "      newEl.$tIDName = self\n".

                "      newEl.attr_name = attr\n".

                "      newEl.attr_value = aVal\n".

                "      newEl.save()\n";

      }

    }

    if(count($this->members) -

       preg_match_all("/attr_/",implode(",",array_keys($this->members)),$matches) -

       preg_match_all("/primitive_type_value/",implode(",",array_keys($this->members)),$matches) > 0 ||

       count($this->references) > 0 || count($this->referrers) > 0) {

      $def .= "    #members & relationships\n".

              "    for child in node.childNodes:\n".

              "      cName = child.nodeName\n";

    }

    $i = 0;

    if(count($this->members) -

       preg_match_all("/attr_/",implode(",",array_keys($this->members)),$matches) -

       preg_match_all("/primitive_type_value/",implode(",",array_keys($this->members)),$matches) > 0) {

      foreach(array_keys($this->members) as $colName) {

        if(preg_match("/^attr_/",$colName) > 0) { continue; }

        $ifStmt = $i == 0 ? 'if' : 'elif';

        $i += 1;

        $def .= "      $ifStmt cName == '$colName':\n".

                "        cVal = child.childNodes[0].nodeValue\n".

                "        self.$colName = cVal\n";

      }

    }

    if(preg_match_all("/primitive_type_value/",implode(",",array_keys($this->members)),$matches) > 0) {

      $def .= "    cVal = node.childNodes[0].nodeValue\n".

              "    self.primitive_type_value = cVal\n";

    }

    foreach(array_keys($this->references) as $colName) {

      $ifStmt = $i == 0 ? 'if' : 'elif';

      $colDef = $this->references[$colName];

      if(preg_match("/(ForeignKey\(')([a-zA-Z]*)/",$colDef,$matches) > 0 &&

         preg_match("/unique/",$colDef) > 0 && preg_match("/_extend/",$colName) == 0) {

        $i += 1;

        $def .= "      $ifStmt cName == '$colName':\n".

                "        newEl = $matches[2]()\n".

                "        newEl.importVegX(child)\n".

                "        self.$colName = newEl\n";

      }

      if(preg_match("/(ManyToManyField\(')([a-zA-Z]*)/",$colDef,$matches) > 0) {

        $i += 1;

        $def .= "      $ifStmt cName == '$colName':\n".