package NET.worlds.scape;

import NET.worlds.console.Console;
import NET.worlds.console.Main;
import NET.worlds.core.IniFile;
import NET.worlds.core.ServerTableManager;
import NET.worlds.network.ObjID;
import NET.worlds.network.URL;
import NET.worlds.network.WorldServer;
import java.io.IOException;
import java.util.Enumeration;
import java.util.Hashtable;

public class HoloDrone extends Drone implements HoloCallback {
   private WObject _avatar;
   private WObject _realAvatar = null;
   private boolean _isConstructing = false;
   private Hologram _proxyHCnewImage = null;
   private boolean _proxyHCok = false;
   private static int _debugLevel = IniFile.gamma().getIniInt("dronedebug", 0);
   private boolean permitAnyAvatar = IniFile.gamma().getIniInt("permitAnyAvatar", 0) != 0;
   private static String[] permittedList;
   private static String[] humanList;
   private static Hashtable permittedHash;
   private static Hashtable humanHash;
   private static Object classCookie;

   static {
      if (_debugLevel > 0) {
         System.out.println("DRONE DEBUGGING LEVEL = " + _debugLevel);
      }

      permittedList = ServerTableManager.instance().getTable("permittedHoloList");
      humanList = ServerTableManager.instance().getTable("humanHoloList");
      permittedHash = new Hashtable();
      humanHash = new Hashtable();

      for (int i = 0; i < permittedList.length; i += 2) {
         if (permittedList[i + 1] != null) {
            permittedHash.put(permittedList[i], permittedList[i + 1]);
         } else {
            permittedHash.put(permittedList[i], permittedList);
         }
      }

      for (int ix = 0; ix < humanList.length; ix++) {
         humanHash.put(humanList[ix], humanList[ix]);
      }

      classCookie = new Object();
   }

   public HoloDrone() {
   }

   public HoloDrone(ObjID objID, WorldServer serv) {
      super(objID, serv);

      assert Main.isMainThread();

      if (this._proxyHCnewImage != null) {
         this.holoCallback(this._proxyHCnewImage, this._proxyHCok);
         this._proxyHCnewImage = null;
      }
   }

   public static String[] getPermittedList() {
      String[] result = new String[permittedList.length / 2];

      for (int i = 0; i < result.length; i++) {
         result[i] = permittedList[2 * i];
      }

      return result;
   }

   static URL permission(URL url) {
      String name = url.getAbsolute().toLowerCase();
      if (name.startsWith("avatar:") && name.endsWith(".mov")) {
         name = name.substring(7, name.length() - 4);
         Object newName = permittedHash.get(name);
         if (newName == null) {
            return null;
         } else {
            return newName instanceof String ? URL.make((String)newName) : url;
         }
      } else {
         return null;
      }
   }

   public static URL getHuman(URL url) {
      if (!url.endsWith(".mov")) {
         return PosableShape.getHuman(url);
      } else if (permission(url) == null) {
         return URL.make("avatar:holden.mov");
      } else {
         String s = url.getAbsolute().toLowerCase();
         int len = s.length();

         for (int i = 7; i < len; i++) {
            if ("0123456789.".indexOf(s.charAt(i)) >= 0) {
               if (humanHash.get(s.substring(7, i)) != null) {
                  return url;
               }

               return URL.make(IniFile.override().getIniString("defaultHumanAv", "avatar:holden.mov"));
            }
         }

         return url;
      }
   }

   @Override
   public Drone setAvatarNow(URL url) {
      if (!this.shouldBeMuted() && url.endsWith(".mov")) {
         if (this.shouldBeForcedHuman()) {
            url = getHuman(url);
         }

         url = PosableShape.getPermitted(url, this.getWorld());
         if (url.equals(this.getSourceURL())) {
            return this;
         } else {
            this.setSourceURL(url);
            URL replacementURL = permission(url);
            if (replacementURL != null) {
               url = replacementURL;
            } else if (!this.permitAnyAvatar) {
               url = Console.getDefaultURL();
            }

            this._realAvatar = this.makeAvatar(url);
            if (this._proxyHCnewImage != null) {
               if ((_debugLevel & 1) > 0) {
                  System.out.println("Holo.stAvNow(" + url + "): doing proxy");
               }

               this.holoCallback(this._proxyHCnewImage, this._proxyHCok);
               this._proxyHCnewImage = null;
            }

            return this;
         }
      } else {
         return super.setAvatarNow(url);
      }
   }

   public WObject makeAvatar(URL url) {
      if ((_debugLevel & 1) > 0) {
         System.out.println("HoloDrone.makeAvatar(" + url + ")");
      }

      this._isConstructing = true;
      WObject bgAvatar = new Hologram(url, this);
      this._isConstructing = false;
      bgAvatar.setVisible(true);
      bgAvatar.setBumpable(false);
      return bgAvatar;
   }

   @Override
   public void holoCallback(Hologram newImage, boolean ok) {
      if ((_debugLevel & 1) > 0) {
         System.out.println("HoloDrone.holoCallback(" + newImage + "," + ok + ")");
      }

      if (this._isConstructing) {
         assert this._proxyHCnewImage == null;

         this._proxyHCnewImage = newImage;
         this._proxyHCok = ok;
         if ((_debugLevel & 1) > 0) {
            System.out.println("holoCallback: requesting proxy");
         }
      } else if (this._realAvatar == this._avatar) {
         if ((_debugLevel & 1) > 0) {
            System.out.println("holoCb: real avatar already loaded");
         }
      } else if (!ok) {
         if (newImage == this._realAvatar) {
            this._realAvatar = null;
         }

         if ((_debugLevel & 1) > 0) {
            System.out.println("holoCb: not ok");
         }
      } else {
         if ((_debugLevel & 1) > 0) {
            System.out.println("holoCb: swapping avatars");
         }

         if (this._avatar != null) {
            this._avatar.detach();
         }

         float avatarW = newImage.getW();
         float avatarH = newImage.getH();
         float factor;
         if (avatarH < avatarW) {
            factor = (float)Math.sqrt(25600.0F / (avatarW * avatarH));
         } else {
            factor = 160.0F / avatarH;
         }

         avatarH *= factor;
         avatarW *= factor;
         float heightAdj = 0.0F;
         if (newImage == this._avatar) {
            heightAdj = -this._avatar.getZ();
         }

         this._avatar = (WObject)newImage.scale(factor).raise(avatarH / 2.0F + heightAdj);
         this.add(this._avatar);
         this.avatarHeightChangedTo(avatarH);
      }
   }

   @Override
   public float getMinXYExtent() {
      return this._avatar == null ? 0.0F : this._avatar.getMinXYExtent();
   }

   @Override
   public Object properties(int index, int offset, int mode, Object value) throws NoSuchPropertyException {
      Object ret = null;
      int var10000 = index - offset;
      return super.properties(index, offset + 0, mode, value);
   }

   @Override
   public void saveState(Saver s) throws IOException {
      s.saveVersion(0, classCookie);
      super.saveState(s);
   }

   @Override
   public void restoreState(Restorer r) throws IOException, TooNewException {
      switch (r.restoreVersion(classCookie)) {
         case 0:
            super.restoreState(r);
            Enumeration e = this.getContents();

            while (e.hasMoreElements()) {
               WObject w = (WObject)e.nextElement();
               if (w instanceof Hologram) {
                  Hologram h = (Hologram)w;
                  if (h.getMovieName() != null) {
                     this._avatar = h;
                  }
               }
            }

            return;
         default:
            throw new TooNewException();
      }
   }
}