package NET.worlds.scape;

import NET.worlds.console.TreeNode;
import java.util.Enumeration;
import java.util.Vector;

class PropTreeNode extends TreeNode {
   private Object obj;
   private boolean allowSorting = true;

   public PropTreeNode(Object obj) {
      super(null);
      this.obj = obj;

      assert obj != null;
   }

   public PropTreeNode(Object obj, TreeNode parent) {
      super(parent);
      this.obj = obj;

      assert obj != null;
   }

   @Override
   public boolean shouldSort() {
      return this.allowSorting;
   }

   @Override
   public Vector getChildren() {
      Vector ret = null;
      Object obj = this.obj;
      if (obj instanceof VectorProperty) {
         VectorProperty vp = (VectorProperty)obj;
         this.allowSorting = vp.shouldSort();
         ret = new Vector();
         Vector v = (Vector)vp.get();
         if (v != null) {
            int count = v.size();

            for (int i = 0; i < count; i++) {
               Object child = v.elementAt(i);
               if (child == null) {
                  System.out.println("Error: VectorProperty " + vp.getName() + " of " + vp.getOwner() + " was null.");
               } else {
                  ret.addElement(new PropTreeNode(child, this));
               }
            }
         }
      } else {
         if (obj instanceof Property) {
            obj = ((Property)obj).get();
         }

         if (obj instanceof Properties) {
            ret = new Vector();
            Enumeration e = new EnumProperties(obj);

            while (e.hasMoreElements()) {
               Property p = (Property)e.nextElement();
               if (p instanceof VectorProperty || p.getEditor() == null && p.get() instanceof Properties) {
                  ret.addElement(new PropTreeNode(p, this));
               }
            }
         }
      }

      return ret;
   }

   @Override
   public Object getObject() {
      return this.obj;
   }

   @Override
   public boolean displayAsTitle() {
      return this.obj instanceof VectorProperty || this.obj instanceof Property;
   }

   public boolean canEdit() {
      return false;
   }

   public VectorProperty getContainingVectorProperty() {
      Object obj = this.obj;
      TreeNode e = this.getParent();
      return !(obj instanceof VectorProperty) && (e == null || !((obj = e.getObject()) instanceof VectorProperty)) ? null : (VectorProperty)obj;
   }

   public PropAdder getAdder() {
      VectorProperty vec = this.getContainingVectorProperty();
      return vec != null ? vec.getAdder() : null;
   }

   public String getContainerName() {
      return this.getContainingVectorProperty().getName();
   }

   public boolean canAdd() {
      PropAdder adder = this.getAdder();
      return adder != null && adder.hasAddDialog();
   }

   public boolean canDelete() {
      TreeNode e = this.getParent();
      Object obj;
      Object var3;
      return e != null
         && (
            (obj = e.getObject()) instanceof VectorProperty && ((VectorProperty)obj).getAdder() != null
               || (var3 = this.getObject()) instanceof Property && ((Property)var3).canSetNull() && ((Property)var3).get() != null
         );
   }

   public Undoable delete(boolean isCut) {
      assert this.canDelete();

      Object o = this.getParent().getObject();
      if (o instanceof VectorProperty) {
         VectorProperty owner = (VectorProperty)o;
         Vector v = (Vector)owner.get();
         int i = v.indexOf(this.obj);

         assert i != -1;

         return (Undoable)(isCut ? new UndoablCut(owner, i) : new UndoablDelete(owner, i));
      } else {
         return new UndoablSet((Property)this.getObject(), null);
      }
   }

   @Override
   public String toString() {
      if (this.obj instanceof SuperRoot) {
         return ((SuperRoot)this.obj).getName();
      } else {
         return this.obj instanceof Property ? ((Property)this.obj).getName() : this.obj.toString();
      }
   }
}