package NET.worlds.scape;

import NET.worlds.console.Console;
import NET.worlds.network.InfiniteWaitException;
import NET.worlds.network.NetworkObject;
import NET.worlds.network.ObjID;
import NET.worlds.network.PacketTooLargeException;
import NET.worlds.network.WorldServer;
import NET.worlds.network.propReqCmd;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.util.Vector;

public abstract class Attribute extends Sensor {
   public int _shorthandVersion = this.getMaxShorthandVersion();
   int _attrID;
   byte[] _serverData;
   boolean _waitingForFeedback;
   byte[] _outgoing;
   boolean loaded;
   Vector<LoadedAttribute> callbacks;
   private Attribute _to;
   private int _storedForwardAttrID = -1;
   protected int _propertyFlags = 208;
   protected int _accessFlags = 0;
   private static Object classCookie = new Object();

   public int getMaxShorthandVersion() {
      return 0;
   }

   public void load(LoadedAttribute callback) {
      if (this.loaded) {
         if (callback != null) {
            callback.loadedAttribute(this, null);
         }
      } else {
         Sharer s = (Sharer)this.getOwner();
         if (s != null && s.isShared()) {
            if (callback != null) {
               if (this.callbacks == null) {
                  this.callbacks = new Vector<LoadedAttribute>();
               }

               this.callbacks.addElement(callback);
            }

            Attribute f = this.getForwardAttribute();
            if (f != null) {
               f.load(null);
            } else {
               assert (s.getMode() & 1) == 0;

               Object served = s.getOwner();

               try {
                  WorldServer servr;
                  String id;
                  if (served instanceof Room) {
                     servr = ((Room)served).getServer();
                     id = ((Room)served).getNetworkRoom().getLongID();
                  } else {
                     servr = ((NetworkObject)served).getServer();
                     id = ((NetworkObject)served).getLongID();
                  }

                  servr.sendNetworkMsg(new propReqCmd(new ObjID(id), this._attrID));
               } catch (InfiniteWaitException var7) {
               } catch (PacketTooLargeException var8) {
                  assert false;
               }
            }
         } else {
            if (callback != null) {
               callback.loadedAttribute(this, "unshared");
            }
         }
      }
   }

   public int getAttrID() {
      return this._attrID;
   }

   public Attribute(int attrID) {
      this._attrID = attrID;
   }

   public Attribute() {
   }

   public void setAttrID(int newID) {
      this.flushBuffers();
      Sharer sharer = (Sharer)this.getOwner();
      if (sharer == null) {
         this._attrID = newID;
      } else {
         sharer.resetAttributeID(this, newID);
      }
   }

   private void flushBuffers() {
      this._serverData = null;
      this._waitingForFeedback = false;
      this._outgoing = null;
   }

   public int getForwardAttrID() {
      return this._to != null ? this._to._attrID : this._storedForwardAttrID;
   }

   public void unforward() {
      if (this._to != null) {
         this._storedForwardAttrID = this._to.getAttrID();
         Sharer s = (Sharer)this._to.getOwner();
         if (s != null) {
            s.removeAttribute(this._to);
         }
      }

      this.flushBuffers();
   }

   public boolean isForwarded() {
      return this._to != null;
   }

   public Attribute getForwardAttribute() {
      return this._to;
   }

   public void setForwardAttrID(int newID) {
      if (this._to != null) {
         this._to.setAttrID(newID);
      } else {
         this._storedForwardAttrID = newID;
      }
   }

   public void noteChange() {
      Sharer sharer = (Sharer)this.getOwner();
      if (sharer != null) {
         sharer.noteChange(this, this.actions.size() > 0);
      }
   }

   public void addForwarding() {
      if (!this.isForwarded()) {
         Sharer s = (Sharer)this.getOwner();

         assert ((WObject)s.getOwner()).getSharerMode() == 3;

         WObject terminal = ((WObject)s.getOwner()).getServed();
         if (terminal != null) {
            if (this.getOwner().getOwner() != terminal) {
               ForwardAttribute fwd = new ForwardAttribute(this, this._storedForwardAttrID);
               terminal.addShareableAttribute(fwd);
               this._to = fwd;
            }
         }
      }
   }

   public abstract void generateNetData(DataOutputStream var1) throws IOException;

   public abstract void setFromNetData(DataInputStream var1, int var2) throws IOException;

   @Override
   public void detach() {
      super.detach();
      this.unforward();
   }

   public int getFlags() {
      return this._propertyFlags;
   }

   public void setFlag(int flag, boolean onoff) {
      if (onoff) {
         this._propertyFlags |= flag;
      } else {
         this._propertyFlags &= ~flag;
      }
   }

   public void setFinger(boolean onoff) {
      this.setFlag(32, onoff);
   }

   public boolean getFinger() {
      return (this.getFlags() & 32) != 0;
   }

   public void setAutoUpdate(boolean onoff) {
      this.setFlag(64, onoff);
   }

   public boolean getAutoUpdate() {
      return (this.getFlags() & 64) != 0;
   }

   public void setDatabase(boolean onoff) {
      this.setFlag(128, onoff);
   }

   public boolean getDatabase() {
      return (this.getFlags() & 128) != 0;
   }

   public void setBinary(boolean onoff) {
      this.setFlag(16, onoff);
   }

   public boolean getBinary() {
      return (this.getFlags() & 16) != 0;
   }

   public int getAccessFlags() {
      return this._accessFlags;
   }

   public void setAccessFlags(int flags) {
      this._accessFlags = flags;
   }

   @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 = IntegerPropertyEditor.make(new Property(this, index, "Attribute ID"));
            } else if (mode == 1) {
               ret = new Integer(this._attrID);
            } else if (mode == 2) {
               int id = (Integer)value;
               if (id >= 0 && id <= 255) {
                  this.setAttrID(id);
               } else {
                  Console.println(Console.message("Attribute-id"));
               }
            }
            break;
         case 1:
            if (mode == 0) {
               ret = BooleanPropertyEditor.make(new Property(this, index, "Fingerable"), "No", "Yes");
            } else if (mode == 1) {
               ret = new Boolean(this.getFinger());
            } else if (mode == 2) {
               this.setFinger((Boolean)value);
            }
            break;
         case 2:
            if (mode == 0) {
               ret = BooleanPropertyEditor.make(new Property(this, index, "Auto Update"), "No", "Yes");
            } else if (mode == 1) {
               ret = new Boolean(this.getAutoUpdate());
            } else if (mode == 2) {
               this.setAutoUpdate((Boolean)value);
            }
            break;
         case 3:
            if (mode == 0) {
               ret = BooleanPropertyEditor.make(new Property(this, index, "Store in Database"), "No", "Yes");
            } else if (mode == 1) {
               ret = new Boolean(this.getDatabase());
            } else if (mode == 2) {
               this.setDatabase((Boolean)value);
            }
            break;
         case 4:
            if (mode == 0) {
               ret = IntegerPropertyEditor.make(new Property(this, index, "Shorthand version"));
            } else if (mode == 1) {
               ret = new Integer(this._shorthandVersion);
            } else if (mode == 2) {
               int id = (Integer)value;
               if (id >= 0 && id <= this.getMaxShorthandVersion()) {
                  this._shorthandVersion = id;
               } else {
                  Console.println(Console.message("Shorthand-version") + " " + this.getMaxShorthandVersion());
               }
            }
            break;
         case 5:
            if (mode == 0) {
               ret = IntegerPropertyEditor.make(new Property(this, index, "Forwarder attrID"));
            } else if (mode == 1) {
               ret = new Integer(this.getForwardAttrID());
            } else if (mode == 2) {
               int id = (Integer)value;
               if (id >= 0 && id <= 255) {
                  this.setForwardAttrID(id);
               } else {
                  Console.println(Console.message("Attribute-id"));
               }
            }
            break;
         case 6:
            if (mode == 0) {
               ret = BooleanPropertyEditor.make(new Property(this, index, "Load Now"), "No", "Yes");
            } else if (mode == 1) {
               ret = new Boolean(false);
            } else if (mode == 2 && (Boolean)value) {
               this.load(null);
            }
            break;
         default:
            ret = super.properties(index, offset + 7, mode, value);
      }

      return ret;
   }

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

   @Override
   public void saveState(Saver s) throws IOException {
      s.saveVersion(5, classCookie);
      super.saveState(s);
      s.saveInt(this._attrID);
      s.saveInt(this.getForwardAttrID());
      s.saveInt(this._propertyFlags);
      s.saveInt(this._shorthandVersion);
   }

   @Override
   public void restoreState(Restorer r) throws IOException, TooNewException {
      switch (r.restoreVersion(classCookie)) {
         case 0:
            this._attrID = r.restoreInt();
            if (r.restoreBoolean()) {
               this._storedForwardAttrID = r.restoreInt();
            } else {
               r.restoreInt();
            }
            break;
         case 1:
            this._attrID = r.restoreInt();
            this._storedForwardAttrID = r.restoreInt();
            break;
         case 2:
            this._attrID = r.restoreInt();
            this._storedForwardAttrID = r.restoreInt();
            this._propertyFlags = r.restoreInt();
            break;
         case 3:
            this.restoreStateSuperRoot(r);
            this._attrID = r.restoreInt();
            this._storedForwardAttrID = r.restoreInt();
            this._propertyFlags = r.restoreInt();
            break;
         case 4:
            this.restoreStateSuperRoot(r);
            this._attrID = r.restoreInt();
            this._storedForwardAttrID = r.restoreInt();
            this._propertyFlags = r.restoreInt();
            this._shorthandVersion = r.restoreInt();
            break;
         case 5:
            super.restoreState(r);
            this._attrID = r.restoreInt();
            this._storedForwardAttrID = r.restoreInt();
            this._propertyFlags = r.restoreInt();
            this._shorthandVersion = r.restoreInt();
            break;
         default:
            throw new TooNewException();
      }
   }

   @Override
   public String toString() {
      return this.isForwarded() ? super.toString() + "[forwarded to " + this._to.getName() + "]" : super.toString();
   }

   public void releaseAuxilaryData() {
   }
}