package NET.worlds.console;

import NET.worlds.network.URL;
import NET.worlds.scape.HoloDrone;
import NET.worlds.scape.InventoryAvatar;
import NET.worlds.scape.InventoryItem;
import NET.worlds.scape.InventoryManager;
import NET.worlds.scape.PosableShape;
import NET.worlds.scape.SelectAvatarAction;
import NET.worlds.scape.WearAction;
import java.awt.Event;
import java.awt.Font;
import java.awt.Menu;
import java.awt.MenuItem;
import java.net.MalformedURLException;
import java.util.Arrays;
import java.util.Enumeration;
import java.util.StringTokenizer;
import java.util.Vector;

public class AvMenu extends Menu implements AvatarDialogCallback {
   private static final long serialVersionUID = 333613242466644876L;
   DefaultConsole defcon;
   Menu articMenuAF;
   Menu articMenuGO;
   Menu articMenuPZ;
   Menu specialGuestMenu;
   public MenuItem customize;
   static AvatarDialog avDialog;
   private static Font font = new Font(Console.message("MenuFont"), 0, 12);
   Vector<AvMenuItem> articulatedAvatarItemsAF;
   Vector<AvMenuItem> articulatedAvatarItemsGO;
   Vector<AvMenuItem> articulatedAvatarItemsPZ;
   Vector<AvMenuItem> holographicAvatarItemsAL;
   Vector<AvMenuItem> holographicAvatarItemsMZ;
   Vector<AvMenuItem> specialGuestAvatarItems;
   private static Vector<String> parts = new Vector<String>();
   private static Vector<String> sizes = new Vector<String>();
   private static Vector<String> colors = new Vector<String>();
   private static Vector<String> faceTypes = new Vector<String>();
   private static Vector<String> headTypes = new Vector<String>();

   static {
      parts.addElement(Console.message("Head"));
      parts.addElement(Console.message("Head-size"));
      parts.addElement(Console.message("Face"));
      parts.addElement(Console.message("Hair"));
      parts.addElement(Console.message("Skin"));
      parts.addElement(Console.message("Shirt"));
      parts.addElement(Console.message("Coat"));
      parts.addElement(Console.message("Dress"));
      parts.addElement(Console.message("Pants"));
      parts.addElement(Console.message("Left-glove"));
      parts.addElement(Console.message("Right-glove"));
      parts.addElement(Console.message("Left-shoe"));
      parts.addElement(Console.message("Right-shoe"));
      sizes.addElement(Console.message("m30"));
      sizes.addElement(Console.message("m20"));
      sizes.addElement(Console.message("m10"));
      sizes.addElement(Console.message("standard"));
      sizes.addElement(Console.message("p10"));
      sizes.addElement(Console.message("p20"));
      sizes.addElement(Console.message("p30"));
      colors.addElement(Console.message("Original"));
      colors.addElement(Console.message("Black"));
      colors.addElement(Console.message("Blue"));
      colors.addElement(Console.message("Tan"));
      colors.addElement(Console.message("Red-orange"));
      colors.addElement(Console.message("Pale-pink"));
      colors.addElement(Console.message("Bright-green"));
      colors.addElement(Console.message("Green"));
      colors.addElement(Console.message("Dark-blue"));
      colors.addElement(Console.message("Blue-purple"));
      colors.addElement(Console.message("Light-blue"));
      colors.addElement(Console.message("Dark-pink"));
      colors.addElement(Console.message("Light-green"));
      colors.addElement(Console.message("Pale-orange"));
      colors.addElement(Console.message("Dark-grey"));
      colors.addElement(Console.message("Orange"));
      colors.addElement(Console.message("Pink"));
      colors.addElement(Console.message("Purple"));
      colors.addElement(Console.message("Red"));
      colors.addElement(Console.message("Burgundy"));
      colors.addElement(Console.message("Brown"));
      colors.addElement(Console.message("Light-grey"));
      colors.addElement(Console.message("Violet"));
      colors.addElement(Console.message("White"));
      colors.addElement(Console.message("Golden-yellow"));
      colors.addElement(Console.message("Medium-yellow"));
      colors.addElement(Console.message("Light-yellow"));
      headTypes.addElement(Console.message("Original"));
      addProperCasedEntries(headTypes, PosableShape.getPermittedNames());
      faceTypes.addElement(Console.message("Original"));
      addProperCasedEntries(faceTypes, PosableShape.getFaceNames());
   }

   AvMenu(DefaultConsole d, URL lastPilotRequested) {
      super(Console.message("choose-av"));
      this.defcon = d;
      URL url = URL.getAvatar();
      String curAvatar = "";
      if (lastPilotRequested != null) {
         curAvatar = lastPilotRequested.getAbsolute();
         String avaStr = url.getAbsolute();
         if (curAvatar.startsWith(avaStr)) {
            curAvatar = curAvatar.substring(avaStr.length());
         }
      }

      this.articMenuAF = new Menu(Console.message("Articulated-A-F"));
      this.articMenuGO = new Menu(Console.message("Articulated-G-O"));
      this.articMenuPZ = new Menu(Console.message("Articulated-P-Z"));
      this.articMenuAF.setFont(font);
      this.articMenuGO.setFont(font);
      this.articMenuPZ.setFont(font);
      this.add(this.articMenuAF);
      this.add(this.articMenuGO);
      this.add(this.articMenuPZ);
      this.addAvatars(url, "abcdef", "bod", this.articMenuAF, curAvatar, this.articulatedAvatarItemsAF = new Vector<AvMenuItem>());
      this.addAvatars(url, "ghijklmno", "bod", this.articMenuGO, curAvatar, this.articulatedAvatarItemsGO = new Vector<AvMenuItem>());
      this.addAvatars(url, "0123456789pqrstuvwxyz", "bod", this.articMenuPZ, curAvatar, this.articulatedAvatarItemsPZ = new Vector<AvMenuItem>());
      Menu holoMenuAL = new Menu(Console.message("Holographic-A-L"));
      Menu holoMenuMZ = new Menu(Console.message("Holographic-M-Z"));
      holoMenuAL.setFont(font);
      holoMenuMZ.setFont(font);
      this.add(holoMenuAL);
      this.add(holoMenuMZ);
      this.addAvatars("abcdefghijkl", holoMenuAL, curAvatar, this.holographicAvatarItemsAL = new Vector<AvMenuItem>());
      this.addAvatars("0123456789mnopqrstuvwxyz", holoMenuMZ, curAvatar, this.holographicAvatarItemsMZ = new Vector<AvMenuItem>());
      this.specialGuestMenu = null;
      this.specialGuestAvatarItems = new Vector<AvMenuItem>();
      this.buildSpecialGuestMenu();
      this.customize = new MenuItem(Console.message("customize-av"));
   }

   public void rebuildVIPMenu() {
      this.articMenuAF.removeAll();
      this.articulatedAvatarItemsAF.removeAllElements();
      this.articMenuGO.removeAll();
      this.articulatedAvatarItemsGO.removeAllElements();
      this.articMenuPZ.removeAll();
      this.articulatedAvatarItemsPZ.removeAllElements();
      URL url = URL.getAvatar();
      this.addAvatars(url, "abcdef", "bod", this.articMenuAF, null, this.articulatedAvatarItemsAF);
      this.addAvatars(url, "ghijklmno", "bod", this.articMenuGO, null, this.articulatedAvatarItemsGO);
      this.addAvatars(url, "0123456789pqrstuvwxyz", "bod", this.articMenuPZ, null, this.articulatedAvatarItemsPZ);
   }

   public void buildSpecialGuestMenu() {
      Vector<InventoryItem> specialGuests = InventoryManager.getInventoryManager().getInventoryAvatars();
      if (specialGuests != null && specialGuests.size() > 0) {
         if (this.specialGuestMenu != null) {
            this.specialGuestMenu.removeAll();
            this.specialGuestAvatarItems.removeAllElements();
         } else {
            this.specialGuestMenu = new Menu(Console.message("special-av"));
            this.add(this.specialGuestMenu);
         }

         Enumeration<InventoryItem> e = specialGuests.elements();

         while (e.hasMoreElements()) {
            InventoryAvatar invItem = (InventoryAvatar)e.nextElement();
            String fullName = invItem.getItemName();
            StringTokenizer tok = new StringTokenizer(fullName);
            if (tok.countTokens() < 1) {
               System.out.println("ERROR: Special avatar inventory item " + fullName + " does not conform to the form \"<name> avatar\"");
            } else {
               String finalName = "";
               String raw = tok.nextToken();
               if (raw.length() > 1) {
                  finalName = raw.substring(0, 1).toUpperCase() + raw.substring(1);
                  AvMenuItem item = new AvMenuItem(finalName, false);
                  item.intAvatar = "_vv" + raw + ".rwg";
                  this.specialGuestAvatarItems.addElement(item);
                  this.specialGuestMenu.add(item);
               }
            }
         }
      }
   }

   private void addAvatars(URL url, String initChar, String ext, Menu menu, String curAvatar, Vector<AvMenuItem> menuItems) {
      if (curAvatar != null) {
         curAvatar = SelectAvatarAction.getPrettyAvatarName(curAvatar);
      }

      Vector<String> names = PosableShape.getPermittedNames();
      Vector<AvMenuItem> menuItemList = new Vector<AvMenuItem>();
      int count = names.size();

      for (int i = 0; i < count; i++) {
         String name = names.elementAt(i);
         if (!name.substring(0, 1).equals("_")) {
            String properName = SelectAvatarAction.getPrettyAvatarName(name);
            if (initChar.indexOf(properName.toLowerCase().substring(0, 1)) >= 0) {
               AvMenuItem item = new AvMenuItem(properName, false);
               item.intAvatar = AvMenuItem.avify(name, ".rwg");
               item.setFont(font);
               menuItemList.addElement(item);
            }
         }
      }

      try {
         this.SortMenu(menuItemList, menu, menuItems);
      } catch (NoClassDefFoundError var14) {
         count = menuItemList.size();

         for (int ix = 0; ix < count; ix++) {
            AvMenuItem item = menuItemList.elementAt(ix);
            menuItems.addElement(item);
            menu.add(item);
         }
      }
   }

   private void SortMenu(Vector<AvMenuItem> menuItemList, Menu menu, Vector<AvMenuItem> menuItems) throws NoClassDefFoundError {
      Vector<AvMenuItemSortable> sortableArray = new Vector<AvMenuItemSortable>();
      int count = menuItemList.size();

      for (int i = 0; i < count; i++) {
         AvMenuItem item = menuItemList.elementAt(i);
         sortableArray.add(new AvMenuItemSortable(item));
      }

      Object[] itemList = sortableArray.toArray();
      Arrays.sort(itemList);
      count = itemList.length;

      for (int i = 0; i < count; i++) {
         AvMenuItem item = ((AvMenuItemSortable)itemList[i]).menuItem;
         menuItems.addElement(item);
         menu.add(item);
      }
   }

   private void addAvatars(String initChar, Menu menu, String curAvatar, Vector<AvMenuItem> menuItems) {
      curAvatar = SelectAvatarAction.getPrettyAvatarName(curAvatar);
      String[] list = HoloDrone.getPermittedList();
      Vector<AvMenuItem> menuItemList = new Vector<AvMenuItem>();

      for (String name : list) {
         if (!name.substring(0, 1).equals("_")) {
            String properName = SelectAvatarAction.getPrettyAvatarName(name);
            if (initChar.indexOf(properName.toLowerCase().substring(0, 1).toLowerCase()) >= 0) {
               AvMenuItem item = new AvMenuItem(properName, false);
               item.intAvatar = AvMenuItem.avify(name, ".mov");
               item.setFont(font);
               menuItemList.addElement(item);
            }
         }
      }

      try {
         this.SortMenu(menuItemList, menu, menuItems);
      } catch (NoClassDefFoundError var12) {
         int var14 = menuItemList.size();

         for (int i = 0; i < var14; i++) {
            AvMenuItem item = menuItemList.elementAt(i);
            menuItems.addElement(item);
            menu.add(item);
         }
      }
   }

   public boolean action(Event event, Object what) {
      if (this.articulatedAvatarItemsAF == null
         || !this.articulatedAvatarItemsAF.contains(event.target)
            && !this.articulatedAvatarItemsGO.contains(event.target)
            && !this.articulatedAvatarItemsPZ.contains(event.target)) {
         if (this.holographicAvatarItemsAL == null
            || !this.holographicAvatarItemsAL.contains(event.target) && !this.holographicAvatarItemsMZ.contains(event.target)) {
            if (event.target == this.customize && this.customize != null) {
               if (avDialog != null) {
                  avDialog.closeWin();
               }

               avDialog = new AvatarDialog(Console.getFrame(), null, Console.message("customize-av"), this);
            } else {
               if (this.specialGuestAvatarItems == null || !this.specialGuestAvatarItems.contains(event.target)) {
                  return false;
               }

               AvMenuItem item = (AvMenuItem)event.target;
               this.changeAvatar(item, "rwg", URL.make(URL.getAvatar(), "_vv" + item.getLabel().toLowerCase() + ".rwg"));
            }
         } else {
            this.changeAvatar((AvMenuItem)event.target, "mov", null);
         }
      } else {
         this.changeAvatar((AvMenuItem)event.target, "rwg", null);
      }

      return true;
   }

   public void notifyOfChange() {
      if (avDialog != null) {
         avDialog.setChangeCheck();
      }
   }

   @Override
   public Vector<String> getChoices(int index) {
      switch (index) {
         case 0:
            return headTypes;
         case 1:
            return sizes;
         case 2:
            return faceTypes;
         default:
            return colors;
      }
   }

   private static void addProperCasedEntries(Vector<String> dest, Vector<String> source) {
      for (int i = 0; i < source.size(); i++) {
         String s = source.elementAt(i);
         if (s.charAt(0) != '_') {
            dest.addElement(s.substring(0, 1).toUpperCase() + s.substring(1));
         }
      }
   }

   public static void rebuildHeadList() {
      headTypes.removeAllElements();
      headTypes.addElement(Console.message("Original"));
      addProperCasedEntries(headTypes, PosableShape.getPermittedNames());
   }

   @Override
   public Vector<String> getComponents() {
      return parts;
   }

   public static int findIndex(Vector<String> v, String match) {
      int end = v.size();

      for (int i = 0; i < end; i++) {
         String s = v.elementAt(i);
         if (s.equalsIgnoreCase(match)) {
            return i;
         }
      }

      return -1;
   }

   @Override
   public int getCurrentSelection(int index) {
      String str = PosableShape.getCurrentAvCustomizable();
      if (str == null) {
         return 0;
      } else {
         int pos = str.indexOf(".", 7);
         String bodyType = str.substring(7, pos).toLowerCase();
         int result = -1;
         switch (index) {
            case 0:
               int p = str.lastIndexOf("NS");
               if (p >= 0 && str.charAt(p + 5) == 'G') {
                  result = findIndex(headTypes, PosableShape.readName(str, p + 6));
                  if (result >= 0) {
                     return result;
                  }
               }

               result = findIndex(headTypes, bodyType);
               return result < 0 ? 0 : result;
            case 1:
               p = str.lastIndexOf("NS");
               if (p >= 0) {
                  result = "qhd0DHQ".indexOf(str.charAt(p + 2));
               }

               return result < 0 ? 3 : result;
            case 2:
               int head = str.lastIndexOf("NS");
               p = str.lastIndexOf("DgT");
               if (p > head) {
                  p += 3;

                  while (str.charAt(p) >= '0' && str.charAt(p) <= '9') {
                     p++;
                  }

                  String texName = PosableShape.readName(str, p);
                  Vector<String> v = faceTypes;
                  int i = v.size();

                  while (--i >= 1) {
                     String s = v.elementAt(i);
                     if (s.regionMatches(true, 0, texName, 0, s.length())) {
                        result = i;
                        break;
                     }
                  }

                  if (result < 0) {
                     result = findIndex(faceTypes, bodyType);
                  }

                  if (result > 0 && faceTypes.elementAt(result).equals(headTypes.elementAt(this.getCurrentSelection(0)))) {
                     result = 0;
                  }
               } else {
                  result = 0;
               }

               return result < 0 ? 0 : result;
            default:
               p = PosableShape.getMatPosition(str, "fabcdeOVKY".charAt(index - 3));
               if (p >= 0 && str.charAt(p) == 'C' && str.charAt(p + 1) == '_') {
                  char letter = str.charAt(p + 2);
                  if (letter >= 'A' && letter <= 'Z') {
                     result = 1 + (letter - 'A');
                  }
               }

               return result < 0 ? 0 : result;
         }
      }
   }

   @Override
   public void setCurrentSelection(int index, int choice) {
      String str = PosableShape.getCurrentAvCustomizable();
      if (str != null) {
         String val;
         char limb;
         if (index >= 3) {
            limb = "fabcdeOVKY".charAt(index - 3);

            assert choice >= 0;

            assert choice <= PosableShape.colorTable.length;

            val = choice == 0 ? null : "C_" + (char)(65 + choice - 1);
         } else if (index == 1) {
            char scale = "qhd0DHQ".charAt(choice);
            char[] scaleStr = new char[]{scale, scale, scale};
            limb = 'Q';
            val = new String(scaleStr);
         } else {
            limb = (char)(index == 0 ? 72 : 69);
            Vector<String> choices = index == 0 ? headTypes : faceTypes;
            val = choice == 0 ? null : choices.elementAt(choice).toLowerCase();
         }

         WearAction.setAvLimb(limb, val);
      }
   }

   private void changeAvatar(AvMenuItem item, String ext, URL url) {
      if (url == null) {
         try {
            url = new URL(URL.getAvatar(), item.intAvatar);
         } catch (MalformedURLException var5) {
            Console.println(Console.message("invalid-URL") + " " + var5);
            return;
         }
      }

      this.defcon.setNextAvatar(url, item);
   }

   private AvMenuItem findAvatar(Vector<AvMenuItem> items, String name) {
      if (items != null) {
         int count = items.size();

         for (int i = 0; i < count; i++) {
            AvMenuItem item = items.elementAt(i);
            if (item.getLabel().equals(name)) {
               return item;
            }
         }
      }

      return null;
   }

   public AvMenuItem findMenuItem(URL url) {
      String prefix = URL.getAvatar().getAbsolute();
      String name = url.getAbsolute().substring(prefix.length());
      String pname = SelectAvatarAction.getPrettyAvatarName(name);
      String suffix = name.substring(name.lastIndexOf(46) + 1);
      AvMenuItem item;
      return (
               !suffix.equalsIgnoreCase("rwg")
                  || this.articulatedAvatarItemsAF == null
                  || (item = this.findAvatar(this.articulatedAvatarItemsAF, pname)) == null
            )
            && (item = this.findAvatar(this.articulatedAvatarItemsGO, pname)) == null
            && (item = this.findAvatar(this.articulatedAvatarItemsPZ, pname)) == null
            && (item = this.findAvatar(this.specialGuestAvatarItems, pname)) == null
            && (
               !suffix.equalsIgnoreCase("mov")
                  || this.holographicAvatarItemsAL == null
                  || (item = this.findAvatar(this.holographicAvatarItemsAL, pname)) == null
                     && (item = this.findAvatar(this.holographicAvatarItemsMZ, pname)) == null
            )
         ? null
         : item;
   }
}