package NET.worlds.scape;

import NET.worlds.console.Console;
import NET.worlds.console.Gamma;
import java.io.IOException;
import java.text.MessageFormat;
import java.util.Enumeration;

public abstract class SetPropertyAction extends Action {
   SuperRoot _target;
   String _targetName;
   String _roomName;
   String _propName;
   private int _propIndex = -1;
   private String _paramName = null;
   private static Object classCookie = new Object();

   public SuperRoot getTarget() {
      if (this._target == null && this._targetName != null) {
         Room r = null;
         if (this._roomName != null) {
            World w = this.getWorld();
            if (w != null) {
               r = w.getRoom(this._roomName);
            }
         } else {
            r = this.getRoom();
         }

         if (r != null) {
            Enumeration list = r.getDeepOwned();
            this._target = SuperRoot.nameSearch(list, this._targetName);
         }
      }

      return this._target != null ? this._target : this.getOwner();
   }

   protected boolean useParam() {
      return this._paramName != null;
   }

   protected String paramName() {
      return this._paramName;
   }

   protected String param() {
      return this._paramName == null ? null : Gamma.getParam(this._paramName);
   }

   static int index(int index, String name, Object target) {
      if (index == -1 && name != null) {
         Enumeration pe = new EnumProperties(target);

         while (pe.hasMoreElements()) {
            Property prop = (Property)pe.nextElement();
            if (prop.getName().equals(name)) {
               index = prop.getIndex();
               break;
            }
         }
      }

      return index;
   }

   public static Object propHelper(int mode, Object value, String name, SuperRoot target) {
      Object ret = null;
      int i = index(-1, name, target);
      if (i != -1) {
         try {
            ret = target.properties(i, 0, mode, value);
         } catch (NoSuchPropertyException var7) {
         }
      }

      return ret;
   }

   private Object propHelper(int mode, Object value) {
      SuperRoot target = this.getTarget();
      Object ret = null;
      if ((this._propIndex = index(this._propIndex, this._propName, target)) != -1) {
         try {
            ret = target.properties(this._propIndex, 0, mode, value);
         } catch (NoSuchPropertyException var6) {
            assert false;
         }
      } else if (target == null) {
         Console.println(this.getName() + Console.message("null-target"));
      } else if (this._propName == null) {
         Object[] arguments = new Object[]{new String(this.getName()), new String(this.getTarget().getName())};
         Console.println(MessageFormat.format(Console.message("null-property"), arguments));
      } else {
         Object[] arguments = new Object[]{new String(this.getName()), new String(this._propName), new String(this.getTarget().getName())};
         Console.println(MessageFormat.format(Console.message("non-property"), arguments));
      }

      return ret;
   }

   protected final void set(Object value) {
      this.propHelper(2, value);
   }

   protected final Object get() {
      return this.propHelper(1, null);
   }

   protected final void add(Object value) {
      this.propHelper(3, value);
   }

   protected final void remove(Object value) {
      this.propHelper(4, value);
   }

   protected final Property enumerate() {
      return (Property)this.propHelper(0, null);
   }

   @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) {
               Property p = new Property(this, index, "Target");
               p.allowSetNull();
               ret = ObjPropertyEditor.make(p, this.getRoom(), "NET.worlds.scape.SuperRoot");
            } else if (mode == 1) {
               ret = this.getTarget();
            } else if (mode == 2) {
               this._target = (SuperRoot)value;
               this._propIndex = -1;
            }
            break;
         case 1:
            if (mode == 0) {
               ret = StringPropertyEditor.make(new Property(this, index, "Target Room"));
            } else if (mode == 1) {
               ret = this._roomName;
            } else if (mode == 4) {
               this._roomName = null;
            } else if (mode == 2) {
               this._roomName = (String)value;
               this._target = null;
            }
            break;
         case 2:
            if (mode == 0) {
               Property p = new Property(this, index, "Target Name");
               p.allowSetNull();
               ret = StringPropertyEditor.make(p);
            } else if (mode == 1) {
               ret = this._targetName;
            } else if (mode == 4) {
               this._targetName = null;
            } else if (mode == 2) {
               this._targetName = (String)value;
               this._target = null;
            }
            break;
         case 3:
            if (mode == 0) {
               ret = new Property(this, index, "Property Name");
               if (this.getTarget() != null) {
                  ret = PropPropEditor.make((Property)ret, this.getTarget(), true);
               }
            } else if (mode == 1) {
               SuperRoot t = this.getTarget();
               if ((this._propIndex = index(this._propIndex, this._propName, t)) != -1 && t != null) {
                  ret = this.enumerate();
               } else {
                  ret = null;
               }
            } else if (mode == 2) {
               if (value == null) {
                  this._propIndex = -1;
                  this._propName = null;
               } else if (value instanceof String) {
                  this._propIndex = -1;
                  this._propName = (String)value;
               } else {
                  this._propIndex = ((Property)value).getIndex();
                  this._propName = ((Property)value).getName();
               }
            }
            break;
         case 4:
            if (mode == 0) {
               ret = BooleanPropertyEditor.make(new Property(this, index, "Use parameter"), "Use 'Set To' value", "Use parameter");
            } else if (mode == 1) {
               ret = new Boolean(this._paramName != null);
            } else if (mode == 2) {
               if ((Boolean)value) {
                  if (this._paramName == null) {
                     this._paramName = "";
                  }
               } else {
                  this._paramName = null;
               }
            }
            break;
         case 5:
            if (mode == 0) {
               ret = new Property(this, index, "Parameter Name");
               if (this._paramName != null) {
                  ret = StringPropertyEditor.make((Property)ret);
               }
            } else if (mode == 1) {
               ret = this._paramName == null ? "" : this._paramName;
            } else if (mode == 2) {
               this._paramName = (String)value;
            }
            break;
         default:
            ret = super.properties(index, offset + 6, mode, value);
      }

      return ret;
   }

   @Override
   public void saveState(Saver s) throws IOException {
      s.saveVersion(4, classCookie);
      super.saveState(s);
      s.saveMaybeNull(this.getTarget());
      s.saveString(this._roomName);
      s.saveString(this._targetName);
      s.saveString(this._propName);
      s.saveString(this._paramName);
   }

   protected void setPropertyActionRestoreState(Restorer r) throws IOException, TooNewException {
      switch (r.restoreVersion(classCookie)) {
         case 1:
            super.restoreState(r);
            this._target = (SuperRoot)r.restore();
            this._propName = r.restoreString();
            break;
         case 2:
            super.restoreState(r);
            this._target = (SuperRoot)r.restoreMaybeNull();
            this._propName = r.restoreString();
            break;
         case 3:
            super.restoreState(r);
            this._target = (SuperRoot)r.restoreMaybeNull();
            this._propName = r.restoreString();
            this._paramName = r.restoreString();
            break;
         case 4:
            super.restoreState(r);
            this._target = (SuperRoot)r.restoreMaybeNull();
            this._roomName = r.restoreString();
            this._targetName = r.restoreString();
            this._propName = r.restoreString();
            this._paramName = r.restoreString();
            break;
         default:
            throw new TooNewException();
      }
   }

   @Override
   public void restoreState(Restorer r) throws IOException, TooNewException {
      this.setPropertyActionRestoreState(r);
   }
}