/**
 *
 * The OctObject class is the class which all OCT objects will
 * inherit (extend)
 *
 * @see     PeristentObject
 * @version 1.2 Oct 1996
 * @author  Francis Chan
 *
 */

import java.util.*;

abstract public class OctObject extends PersistentObject{

  /** 
   * The Name of the Class that inherits OctObject
   */
  public String className;

  /**
   * OctObjectType
   *
   */
  int type;

  /**
   * Unique object Id generated by the data server after a Save()
   *
   */
  protected int objectId = OCT.NULL_ID;

  /**
   * Number of fields in the OctObject
   */
  protected int octFields;

  /**
   * Vector which contains all object that are attached as containers
   */
  protected Vector containers;

  /**
   * Vector which contains all object that are attached as contents
   */
  protected Vector contents;

  // this is the Id that the data backend, may need to generate it during 
  // object creation
  // (retrievable through OctExternalId p9)
 
  // Design Decision
  // generate in using time during creation
  // will get an "authentic" id from the data backend after a save

  /**
   * ID generated by the program during dynamic construction
   */
  public long externalId;

  // we need this variable to identify those OctObjects which have 
  // externalId generated from the data backend

  /**
   * Determines whether the object requires saving
   */
  public boolean dirty = true;
  //  public boolean inMemory = false;

  /*
   * The object's current OctCell
   */
  public OctCell octCell;

  /*
   * Indicates the port (of the server) for network transactions
   */

  // can to set to (not) print out error/debug messages

  private boolean errorFlag = true;


  /** 
   * Constructor of an OctObject
   * Initializes internal data structures
   * Never gets called explicitly
   */
  public OctObject() {

    containers = new Vector();
    contents = new Vector();

    // need to set up unique id during object creation (for attach and stuff), 
    // even if we don't load and save
    // unique externalId by date/time of local objects

    Date date = new Date();

    this.externalId = date.getTime();

    containersInMem = true;
    contentsInMem = true;
    dirty = true;

  }


  /**
   * Add the obj to the contents Vector
   * Returns OCT.OK
   * @param obj OctObject to be added
   */

  public int Attach(OctObject obj) {

    if (octCell.Policy(this, obj) != OCT.OK) {
      return ERROR;
    }

    // attach obj to current objects contents

    contents.addElement(obj);
    
    // attach current object to obj's conatiners

    obj.AddAttachTo(this);

    octCell.SetDirty(this);
    this.dirty = true;

    return OCT.OK;

  }


  /**
   * Add the obj to the containers Vector
   * Should only be called internally or by the system
   * @param oObj OctObject to be added
   */

  public void AddAttachTo(OctObject oObj) {

    containers.addElement(oObj);
      
  }

  /**
   * Attached the obj to the current object only if it's not already attached
   * Return OCT.OK is operation is completed successfully, 
   * OCT.ALREADY_ATTACHED otherwise
   *
   * @param obj     The object to check whether it's attached
   */

  public int AttachOnce(OctObject obj) {

    if (isAttached(obj) == OCT.NOT_ATTACHED) {

      Attach(obj);

      return OCT.OK;
    }
    return OCT.ALREADY_ATTACHED;
  }


  /**
   *
   * Checks to see whether the obj is attached to the current OctObject
   * Returns OCT.OK if so, OCT.NOT_ATTACHED otherwise
   * @param cnt  The container to delete from
   */

  public int isAttached(OctObject obj) {

    OctObject oObj;

    for (int i=0; i<contents.size(); i++) {

      oObj = (OctObject) contents.elementAt(i);

      if (obj.isPersistent == true) {
	if (obj.objectId == oObj.objectId) {
	  return OK;
	}
      } else if (obj.externalId == oObj.externalId) {
	return OK;
      }
    }
    return OCT.NOT_ATTACHED;
    
  }


  /**
   *
   * Detach the container's (cnt) content's instance of this object
   * @param cnt  The container to delete from
   */

  public void DetachFrom(OctObject cnt) {

    OctObject oObj;

    for (int i=0; i<containers.size(); i++) {

      oObj = (OctObject) containers.elementAt(i);

      if (cnt.isPersistent == true) {
	if (cnt.objectId == oObj.objectId) {
	    containers.removeElementAt(i);
	    return;
	  }
      } else if (oObj.externalId == cnt.externalId) {
	containers.removeElementAt(i);
	return;
      }
    }
    System.out.println("Can't detach the container " + cnt.objectClassName);
  }
  

  /**
   *
   * Delete
   *
   * Removes all references of the OctObject in the system
   * (The object is not explicitly deleted (i.e. space freed))
   *
   */

  public void Delete() {

    if (this.isPersistent == true) {
      System.out.println("Locally Deleting a persistent object");
      System.out.println("Use DeleteCommit instead for persistent objects!");
      return;
    }

    OctObject oObj;

    for (int i=0; i<contents.size(); i++) {

      /// have all children delete "this" from containers vector

      oObj = (OctObject) contents.elementAt(i);
      oObj.DetachFrom(this);
    }

    for (int i=0; i<containers.size(); i++) {

      /// have all parents delete "this" from contents vector

      oObj = (OctObject) containers.elementAt(i);
      oObj.Detach(this);
    }
 
  }


  /**
   *
   * Committing a Delete, so that the information gets transferred back 
   * to the data server.  Both local and persistent data is updated
   *
   * @param obj   obj to commit the Delete
   */

  public void DeleteCommit() {

    if (this.isPersistent != true) {
      DEBUG("Only a _local_ Delete is required since obj is not persistent");
      Delete();
    }

    DeleteObj();

    // load all children if not in memory...
    // get their Ids
    // call disconnect to each of them

    // actually server takes care of that

    if (contentsInMem == true) {
      for (int i=0; i<contents.size(); i++) {

	/// have all children delete "this" from containers vector

	OctObject oObj = (OctObject) contents.elementAt(i);
	oObj.DetachFrom(this);
      }
    }

    // load all parents if not in memory...
    // get their Ids
    // call disconnect to each of them

    if (containersInMem == true) {
      for (int i=0; i<containers.size(); i++) {

	/// have all parents delete "this" from contents vector

	OctObject oObj = (OctObject) containers.elementAt(i);
	this.DetachFrom(oObj);
      }
    }
  }


  /**
   *
   * Detach 
   * Policy:
   * User can/should only Detach OctObjects that are not Persistent
   *
   * For detaching already Persistent OctObjects, DetachCommit must be called
   * so that the information gets transferred back to the data server.
   *
   * @param obj   object to Detach
   */

  public int Detach(OctObject obj) {

    if (obj.isPersistent == true) {
      System.out.println("Can't detach an object that's persistent");
      System.out.println("Use DetachCommit instead!");
      return ERROR;
    }

    OctObject oObj;

    for (int i=0; i<contents.size(); i++) {

      oObj = (OctObject) contents.elementAt(i);

      if (oObj.externalId == obj.externalId) {
	contents.removeElementAt(i);
	
	// have obj delete "this" from containers Vector
	obj.DetachFrom(this);
	return OCT.OK;
      }
    }
 
    System.out.println("Can't find the object, " + 
		       obj.objectClassName + " to detach!");
    return OCT.NOT_ATTACHED;
    
  }

  /**
   *
   * Committing a Detach, so that the information gets transferred back 
   * to the data server.  Both local and persistent data is updated
   *
   * @param obj   obj to commit the Detach
   */

  public int DetachCommit(OctObject obj) {

    if ((obj.isPersistent != true) || (this.isPersistent != true)) {
      System.out.println("Both objects must be persistent for DetachCommit!");
      return ERROR;
    }

    OctObject oObj;

    for (int i=0; i<contents.size(); i++) {

      oObj = (OctObject) contents.elementAt(i);

      if (oObj.externalId == obj.externalId) {
	contents.removeElementAt(i);
	
	// have obj delete "this" from containers Vector
	obj.DetachFrom(this);

	Disconnect(this.objectId, obj.objectId);

	return OCT.OK;
      }
    }
 
    System.out.println("Can't find the object, " 
		       + obj.objectClassName + " to detach!");
    return OCT.NOT_ATTACHED;
    
  }


  /**
   * Loads (all) the contents of the Octobject from data backend if 
   * they are not already loaded.
   *
   */

  public int InitGenContents() {

    if (contentsInMem == true) {
      DEBUG("Contents already in memory");
      return OCT.OK;
    }
    
    return initGenRelative(CONTENTS);

  }

  /**
   * Returns a Vector with the all containers with type "mask" 
   *
   * Load (all) the containers of the Octobject from data backend if 
   * they are not already in memory.
   *
   */

  public int InitGenContainers() {

    if (containersInMem == true) {
      DEBUG("Containers already in memory");
      return OCT.OK;
    }
    
    return initGenRelative(CONTAINERS);

  }

  private int initGenRelative(int relativeType) {
  
    Vector memberVector;
    int numMembers;
    int memType;
    int index = 0;
    OctObject oObj;
    
    if (relativeType == CONTAINERS) {
      memberVector = this.containers;
      numMembers = numParents;
      memType = PARENTS;
    } else {
      memberVector = this.contents;
      numMembers = numChildren;
      memType = CONTENTS;
      index = numObjField;  // index starts at numObjField as there are
                            // numObjField objects already attached
    }
    
    /*
    for (int i=0; i<memberVector.size(); i++) {

      oObj = (OctObject) memberVector.elementAt(i);
      if (oObj.objectClassName.compareTo(mask) == 0)
        genVector.addElement(contents.elementAt(i));
      }

      return genVector;
      */

    DEBUG("loading members to memory");

    for (int i=index; i<numMembers; i++) {

      MemberInfo memInfo = GetMemberInfo(memType, i);

      oObj = this.octCell.GetById(memInfo.id);
      if (oObj != null) {

      } else {
	// somewhat of a table lookup, could be written as a 
	// separate class

	if (memInfo.objClassName.compareTo("OctView") == 0) {
	  oObj = new OctView(this.octCell);
	} else if (memInfo.objClassName.compareTo("OctFacet") == 0) {
	  oObj = new OctFacet(this.octCell);
	} else if (memInfo.objClassName.compareTo("OctPoint") == 0) {
	  oObj = new OctPoint(this.octCell);
	} else if (memInfo.objClassName.compareTo("OctBag") == 0) {
	  oObj = new OctBag(this.octCell);
	} else if (memInfo.objClassName.compareTo("OctBox") == 0){
	  oObj = new OctBox(this.octCell);
	  /*
	} else if (memInfo.objClassName.compareTo("OctCircle") == 0) {
	  oObj = new OctCircle(this.octCell);
	} else if (memInfo.objClassName.compareTo("OctEdge") == 0) {
	  oObj = new OctEdge(this.octCell);
	  */
	} else if (memInfo.objClassName.compareTo("OctInstance") == 0) {
	  oObj = new OctInstance(this.octCell);
	} else if (memInfo.objClassName.compareTo("OctLayer") == 0) {
	  oObj = new OctLayer(this.octCell);
	} else if (memInfo.objClassName.compareTo("OctNet") == 0){ 
	  oObj = new OctNet(this.octCell);
	} else if (memInfo.objClassName.compareTo("OctPath") == 0) {
	  oObj = new OctPath(this.octCell);
	} else if (memInfo.objClassName.compareTo("OctTerm") == 0) {
	  oObj = new OctTerm(this.octCell);
	} else if (memInfo.objClassName.compareTo("OctTransform") == 0) {
	  oObj = new OctTransform(this.octCell);
	} else 
	  oObj = new OctFacet(this.octCell); // abitrary default
	// should not reach here
	
	oObj.Load(memInfo.id);
      }
	
      memberVector.addElement(oObj);
      oObj.isPersistent = true;
    }

    if (relativeType == CONTAINERS)
      containersInMem = true;
    else contentsInMem = true;

    return OCT.OK;
  }


  /**
   * Gets the nth member of the children
   *
   * @param nthField    The position of the field in the object
   * @param indicator   OBJECT_INDICATOR (should be passed in)
   * @param nthObject   The position within object fields
   */
  protected Object GetField(int nthField, Object indicator, int nthObject) {

    OctObject oObj;

    //DEBUG("Before getMemberInfo " + objectClassName);
      MemberInfo memInfo = GetMemberInfo(CONTENTS, nthObject);

      oObj = this.octCell.GetById(memInfo.id);
      if (oObj != null) {
      } else {

	if (memInfo.objClassName.compareTo("OctView") == 0) {
	  oObj = new OctView(this.octCell);
	} else if (memInfo.objClassName.compareTo("OctFacet") == 0) {
	  oObj = new OctFacet(this.octCell);
	} else if (memInfo.objClassName.compareTo("OctPoint") == 0) {
	  oObj = new OctPoint(this.octCell);
	} else if (memInfo.objClassName.compareTo("OctBag") == 0) {
	  oObj = new OctBag(this.octCell);
	} else if (memInfo.objClassName.compareTo("OctBox") == 0){
	  oObj = new OctBox(this.octCell);
	} else if (memInfo.objClassName.compareTo("OctInstance") == 0) {
	  oObj = new OctInstance(this.octCell);
	} else if (memInfo.objClassName.compareTo("OctLayer") == 0) {
	  oObj = new OctLayer(this.octCell);
	} else if (memInfo.objClassName.compareTo("OctNet") == 0){ 
	  oObj = new OctNet(this.octCell);
	} else if (memInfo.objClassName.compareTo("OctPath") == 0) {
	  oObj = new OctPath(this.octCell);
	} else if (memInfo.objClassName.compareTo("OctTerm") == 0) {
	  oObj = new OctTerm(this.octCell);
	} else if (memInfo.objClassName.compareTo("OctTransform") == 0) {
	  oObj = new OctTransform(this.octCell);
	} else 
	  oObj = new OctFacet(this.octCell); // abitrary default
	// should not reach here
	
	oObj.Load(memInfo.id);
      }
	
      octCell.AddElement(oObj);
      InstancePolicy(oObj);
   
      return oObj;
  }

  /**
   * Policy that have to be observed when instantiating an object
   *
   * @param pObj     The Persistent object to be processed
   */
  public void InstancePolicy(PersistentObject pObj) {

    OctObject oObj = (OctObject) pObj;

    // need to do the overhead for management within an OctCell
    oObj.OctObjSetup(octCell.port, oObj.octFields, oObj.objectClassName);
    
    // need to do the overhead for new/non-persistent/instance object
    oObj.contentsInMem = false;
    oObj.containersInMem = false;
    oObj.SetPersistent(false);
    oObj.dirty = true;
    
  }


  /**
   * Returns the externalId of the OctObject (for identification purposes)
   */

  public long getExternalId() {

    return externalId;
  }

  /**
   * Returns the objectId of the OctObject (for identification purposes)
   */

  public int GetObjId() {

    return dbId;
  }

  /**
   * Compares the objectId of the (persistent) OctObjects
   */

  public boolean OctIdsEqual(int id) {

    if (id == this.objectId)
      return true;
    return false;
  }


  /**
   * Prints Error messages
   */
  protected void OctError(String message) {

    if (errorFlag == true) 
      System.out.println(message);

  }

  /**
   * Prints the Debug "message" if the debugFlag is set to true
   */
  protected void DEBUG(String message) {

    if (debugFlag == true) 
      System.out.println(message);

  }

  /*-------------------------------------------------------
   *
   * Methods needed for data backend management
   * 
   *-------------------------------------------------------*/

  /**
   * Performs additional overhead for objects that inherits OctObjects 
   * since 3 fields (containers, contents, objectId) are implicitly 
   * declared in the parent (OctObject) class
   *
   * @param port        Port number of the server for network operations
   * @param octFields   Number of fields of the child OctObject
   * @param className   Class name of the child OctObject
   */
  protected void OctObjSetup(int port, int octFields, 
			     String className) {

    // sets the userId to the OctCell's name
    userId = octCell.GetName();

    this.octFields = octFields;

    debugFlag = octCell.debugFlag;

    // 2 added for the containers and contents Vector + 1 for ID

    NetObjSetup(port, (octFields + 3), className);
    
  }

  /**
   * Performs additional overhead for objects that inherits OctObjects 
   * since 3 fields (containers, contents, objectId) are implicitly 
   * declared in the parent (OctObject) class
   *
   */
  protected void OctSetField(int octFields) {

    SetField(octFields, this.objectId, PersistentObject.UNIQUE_ID);
    SetField((octFields+1), this.contents, PersistentObject.CHILDREN);
    SetField((octFields+2), this.containers, PersistentObject.PARENTS);

  }

  /**
   * Performs post-load operations (such as set dirty flag to false)
   */
  protected void OctGetField(int octFields) {

    // maybe we don't have to do anything before the user
    // generates the containers and contents

    this.dirty = false;

  }

  /**
   * Policies that should be followed and confirmed before the
   * saving of OctObjects
   */
  protected int SavePolicy(Object obj) {

    // just return ok, and not_ok for the time being

    OctObject oObj = (OctObject) obj;
 
    if (oObj.dirty == true)
      return PersistentObject.OK;
    else return PersistentObject.DO_NOT_PROCEED;

  }

  /**
   * Policies that has be followed after the saving of OctObjects
   */
  protected void PostSavePolicy(Object obj) {

    OctObject oObj = (OctObject) obj;
 
    // set object's info (such as dirty bit to false)
    
    oObj.SetPersistent(true);
    oObj.dirty = false;
    //DEBUG("ExtId: " + oObj.externalId);

    oObj.SetId();
    //oObj.octCell.UpdateObjId(oObj);

  }

  /**
   * Policies that has be followed after the loading of OctObjects
   */
  protected void PostLoadPolicy(Object obj) {

    OctObject oObj = (OctObject) obj;
 
    oObj.contentsInMem = false;
    oObj.containersInMem = false;
  }

  /**
   * Sets the object's cell environment to a new one
   */
  protected void SetNewCell(OctCell cell) {

    this.octCell = cell;
    userId = cell.GetName();

  }

  /**
   * Sets the objectId field to unique id return by data server
   */
  protected void SetId() {

    this.objectId = dbId;
  }
  
}