package NET.worlds.scape;

import NET.worlds.network.URL;
import java.io.File;
import java.io.IOException;
import java.util.Vector;

public class Library extends SuperRoot {
   private Object owningDialog;
   private Vector contents = new Vector();
   private LibEventHandler handler;
   protected String propertyName;
   private static Object classCookie = new Object();

   public static Library load(URL url) {
      return (Library)SuperRoot.readFile(url);
   }

   public Library(URL url, String name) {
      this.setSourceURL(url);
      this.setName(name);
   }

   public Library() {
   }

   public void save() {
      try {
         this.saveFile(this.getSourceURL());
      } catch (IOException var2) {
      }
   }

   public void delete() {
      new File(this.getSourceURL().unalias()).delete();
   }

   public void add(LibraryEntry ent) {
      assert ent.getOwner() == null;

      this.contents.addElement(ent);
      super.add(ent);
      this.changed();
   }

   public void delete(LibraryEntry ent) {
      boolean found = this.contents.removeElement(ent);

      assert found;

      assert ent.getOwner() == this;

      ent.detach();
      this.changed();
   }

   public void move(LibraryEntry src, LibraryEntry dst) {
      int oldPos = this.contents.indexOf(src);

      assert oldPos != -1;

      int newPos = this.contents.indexOf(dst);

      assert newPos != -1;

      this.contents.removeElement(src);
      this.contents.insertElementAt(src, newPos);
      this.changed();
   }

   void entryChanged(LibraryEntry which) {
      this.changed();
   }

   private void changed() {
      if (this.handler != null) {
         this.handler.libraryChanged(this);
      }
   }

   public Object getOwningDialog() {
      return this.owningDialog;
   }

   public Vector getContents() {
      return (Vector)this.contents.clone();
   }

   public String getPropertyName() {
      return this.propertyName;
   }

   public LibraryEntry getEntry(int index) {
      return (LibraryEntry)this.contents.elementAt(index);
   }

   public void setOwningDialog(Object o) {
      this.owningDialog = o;
   }

   @Override
   public void setName(String s) {
      super.setName(s);
      this.changed();
   }

   public void setPropertyName(String s) {
      this.propertyName = s;
      this.changed();
   }

   public void setEventHandler(LibEventHandler handler) {
      this.handler = handler;
   }

   @Override
   public Object properties(int index, int offset, int mode, Object value) throws NoSuchPropertyException {
      Object ret = null;
      switch (index - offset) {
         case 0:
            if (mode == 0) {
               ret = PropAdder.make(new VectorProperty(this, index, "Contents"));
            } else if (mode == 1) {
               ret = this.getContents();
            } else if (mode == 4) {
               this.delete((LibraryEntry)value);
            } else if (mode == 3) {
               this.add((LibraryEntry)value);
            } else if (mode == 5 && value instanceof LibraryEntry) {
               ret = value;
            }
            break;
         case 1:
            if (mode == 0) {
               ret = StringPropertyEditor.make(new Property(this, index, "Property Name").allowSetNull());
            } else if (mode == 1) {
               ret = this.getPropertyName();
            } else if (mode == 2) {
               this.setPropertyName((String)value);
            }
            break;
         default:
            ret = super.properties(index, offset + 2, mode, value);
      }

      return ret;
   }

   @Override
   public Object propertyParent() {
      return this.getOwningDialog();
   }

   @Override
   public void saveState(Saver s) throws IOException {
      s.saveVersion(2, classCookie);
      super.saveState(s);
      s.saveVector(this.contents);
      s.saveString(this.propertyName);
   }

   @Override
   public void restoreState(Restorer r) throws IOException, TooNewException {
      Vector newContents = null;
      switch (r.restoreVersion(classCookie)) {
         case 0:
            this.setName(r.restoreString());
            r.restoreString();
            r.restoreString();
            newContents = r.restoreVector();
            break;
         case 1:
            super.restoreState(r);
            r.restoreString();
            r.restoreString();
            newContents = r.restoreVector();
            break;
         case 2:
            super.restoreState(r);
            newContents = r.restoreVector();
            this.propertyName = r.restoreString();
            break;
         default:
            throw new TooNewException();
      }

      for (int i = 0; i < newContents.size(); i++) {
         this.add((LibraryEntry)newContents.elementAt(i));
      }
   }
}