* A library to interact with Virtual Worlds such as OpenSim

* Copyright (C) 2012  Jitendra Chauhan, Email: jitendra.chauhan@gmail.com

*

* This library is free software; you can redistribute it and/or modify it under

* the terms of the GNU Lesser General Public License as published by

* the Free Software Foundation; either version 2.1 of the License,

* or (at your option) any later version.

*

* This library is distributed in the hope that it will be useful,

* but WITHOUT ANY WARRANTY; without even the implied warranty of

* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

* See the GNU Lesser General Public License for more details.

*

* You should have received a copy of the GNU Lesser General Public License

* along with this library; if not, write to the Free Software Foundation,

* Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

*/

  private static ThreadPool threadPool = ThreadPoolFactory.getThreadPool();

  //region Enums

  /// <summary>

  /// Index of TextureEntry slots for avatar appearances

  /// </summary>

  public enum AvatarTextureIndex

  {

    Unknown(-1),

    HeadBodypaint(0),

    UpperShirt(1),

    LowerPants(2),

    EyesIris(3),

    Hair(4),

    UpperBodypaint(5),

    LowerBodypaint(6),

    LowerShoes(7),

    HeadBaked(8),

    UpperBaked(9),

    LowerBaked(10),

    EyesBaked(11),

    LowerSocks(12),

    UpperJacket(13),

    LowerJacket(14),

    UpperGloves(15),

    UpperUndershirt(16),

    LowerUnderpants(17),

    Skirt(18),

    SkirtBaked(19),

    HairBaked(20),

    LowerAlpha(21),

    UpperAlpha(22),

    HeadAlpha(23),

    EyesAlpha(24),

    HairAlpha(25),

    HeadTattoo(26),

    UpperTattoo(27),

    LowerTattoo(28),

    NumberOfEntries(29);

    private int index;

    AvatarTextureIndex(int index)

    {

      this.index = index;

    }    

    public int getIndex()

    {

      return index;

    }

    private static final Map<Integer,AvatarTextureIndex> lookup 

    = new HashMap<Integer,AvatarTextureIndex>();

    static {

      for(AvatarTextureIndex s : EnumSet.allOf(AvatarTextureIndex.class))

        lookup.put(s.getIndex(), s);

    }

    public static AvatarTextureIndex get(Integer index)

    {

      return lookup.get(index);

    }

  }

  /// <summary>

  /// Bake layers for avatar appearance

  /// </summary>

  public enum BakeType

  {

    Unknown (-1),

    Head (0),

    UpperBody (1),

    LowerBody (2),

    Eyes (3),

    Skirt (4),

    Hair (5);

    private int index;

    BakeType(int index)

    {

      this.index = index;

    }    

    public int getIndex()

    {

      return index;

    }

    private static final Map<Integer,BakeType> lookup 

    = new HashMap<Integer,BakeType>();

    static {

      for(BakeType s : EnumSet.allOf(BakeType.class))

        lookup.put(s.getIndex(), s);

    }

    public static BakeType get(Integer index)

    {

      return lookup.get(index);

    }

  }

  //endregion Enums

  //region Constants

  /// <summary>Mapping between BakeType and AvatarTextureIndex</summary>

  public static  byte[] BakeIndexToTextureIndex = new byte[] {(byte) 8, (byte)9, (byte)10, (byte)11, (byte)19, (byte)20 };

  /// <summary>Maximum number of concurrent downloads for wearable assets and textures</summary>

  final static  int MAX_CONCURRENT_DOWNLOADS = 5;

  /// <summary>Maximum number of concurrent uploads for baked textures</summary>

  final static  int MAX_CONCURRENT_UPLOADS = 6;

  /// <summary>Timeout for fetching inventory listings</summary>

  final static  int INVENTORY_TIMEOUT = 1000 * 30;

  /// <summary>Timeout for fetching a single wearable, or receiving a single packet response</summary>

  final static  int WEARABLE_TIMEOUT = 1000 * 30;

  /// <summary>Timeout for fetching a single texture</summary>

  final static  int TEXTURE_TIMEOUT = 1000 * 120;

  /// <summary>Timeout for uploading a single baked texture</summary>

  final static  int UPLOAD_TIMEOUT = 1000 * 90;

  /// <summary>Number of times to retry bake upload</summary>

  final static  int UPLOAD_RETRIES = 2;

  /// <summary>When changing outfit, kick off rebake after

  /// 20 seconds has passed since the last change</summary>

  final static  int REBAKE_DELAY = 1000 * 20;

  /// <summary>Total number of wearables for each avatar</summary>

  public final static  int WEARABLE_COUNT = 16;

  /// <summary>Total number of baked textures on each avatar</summary>

  public final static  int BAKED_TEXTURE_COUNT = 6;

  /// <summary>Total number of wearables per bake layer</summary>

  public final static  int WEARABLES_PER_LAYER = 9;

  /// <summary>Map of what wearables are included in each bake</summary>

  public static  WearableType[][] WEARABLE_BAKE_MAP = new WearableType[][]

      {

    new WearableType[] { WearableType.Shape, WearableType.Skin,    WearableType.Tattoo,  WearableType.Hair,    WearableType.Alpha,   WearableType.Invalid, WearableType.Invalid,    WearableType.Invalid,      WearableType.Invalid },

    new WearableType[] { WearableType.Shape, WearableType.Skin,    WearableType.Tattoo,  WearableType.Shirt,   WearableType.Jacket,  WearableType.Gloves,  WearableType.Undershirt, WearableType.Alpha,        WearableType.Invalid },

    new WearableType[] { WearableType.Shape, WearableType.Skin,    WearableType.Tattoo,  WearableType.Pants,   WearableType.Shoes,   WearableType.Socks,   WearableType.Jacket,     WearableType.Underpants,   WearableType.Alpha   },

    new WearableType[] { WearableType.Eyes,  WearableType.Invalid, WearableType.Invalid, WearableType.Invalid, WearableType.Invalid, WearableType.Invalid, WearableType.Invalid,    WearableType.Invalid,      WearableType.Invalid },

    new WearableType[] { WearableType.Skirt, WearableType.Invalid, WearableType.Invalid, WearableType.Invalid, WearableType.Invalid, WearableType.Invalid, WearableType.Invalid,    WearableType.Invalid,      WearableType.Invalid },

    new WearableType[] { WearableType.Hair,  WearableType.Invalid, WearableType.Invalid, WearableType.Invalid, WearableType.Invalid, WearableType.Invalid, WearableType.Invalid,    WearableType.Invalid,      WearableType.Invalid }

      };

  /// <summary>Magic values to finalize the cache check hashes for each

  /// bake</summary>

  public static  UUID[] BAKED_TEXTURE_HASH = new UUID[]

      {

    new UUID("18ded8d6-bcfc-e415-8539-944c0f5ea7a6"),

    new UUID("338c29e3-3024-4dbb-998d-7c04cf4fa88f"),

    new UUID("91b4a2c7-1b1a-ba16-9a16-1f8f8dcc1c3f"),

    new UUID("b2cf28af-b840-1071-3c6a-78085d8128b5"),

    new UUID("ea800387-ea1a-14e0-56cb-24f2022f969a"),

    new UUID("0af1ef7c-ad24-11dd-8790-001f5bf833e8")

      };

  /// <summary>Default avatar texture, used to detect when a custom

  /// texture is not set for a face</summary>

  public static  UUID DEFAULT_AVATAR_TEXTURE = new UUID("c228d1cf-4b5d-4ba8-84f4-899a0796aa97");

  //endregion Constants

  //region Structs / Classes

  /// <summary>

  /// Contains information about a wearable inventory item

  /// </summary>

  public static class WearableData

  {

    /// <summary>Inventory ItemID of the wearable</summary>

    public UUID ItemID;

    /// <summary>AssetID of the wearable asset</summary>

    public UUID AssetID;

    /// <summary>WearableType of the wearable</summary>

    public Enums.WearableType WearableType;

    /// <summary>AssetType of the wearable</summary>

    public Enums.AssetType AssetType;

    /// <summary>Asset data for the wearable</summary>

    public AssetWearable Asset;

    @Override

    public String toString()

    {

      return String.format("ItemID: %s, AssetID: %s, WearableType: %s, AssetType: %s, Asset: %s",

          ItemID, AssetID, WearableType, AssetType, Asset != null ? Asset.Name : "(null)");

    }

  }

  /// <summary>

  /// Data collected from visual params for each wearable

  /// needed for the calculation of the color

  /// </summary>

  private class ColorParamInfo

  {

    public VisualParam VisualParam;

    public VisualColorParam VisualColorParam;

    public float Value;

    public Enums.WearableType WearableType;

  }

  /// <summary>

  /// Holds a texture assetID and the data needed to bake this layer into

  /// an outfit texture. Used to keep track of currently worn textures

  /// and baking data

  /// </summary>

  public class TextureData

  {

    /// <summary>A texture AssetID</summary>

    public UUID TextureID = new UUID();

    /// <summary>Asset data for the texture</summary>

    public AssetTexture Texture = null;

    /// <summary>Collection of alpha masks that needs applying</summary>

    public Map<VisualAlphaParam, Float> AlphaMasks = new HashMap<VisualAlphaParam, Float>();

    /// <summary>Tint that should be applied to the texture</summary>

    public Color4 Color = new Color4();

    /// <summary>Where on avatar does this texture belong</summary>

    public AvatarTextureIndex TextureIndex = null;

    @Override

    public String toString()

    {

      return String.format("TextureID: %s, Texture: %s",

          TextureID, Texture != null ? Texture.AssetData.length + " bytes" : "(null)");

    }

  }

  //endregion Structs / Classes

  private EventObservable<AgentWearablesReplyEventArgs> onAgentWearablesReply = new EventObservable<AgentWearablesReplyEventArgs>();

  public void registerOnAgentWearablesReply(EventObserver<AgentWearablesReplyEventArgs> o)

  {

    onAgentWearablesReply.addObserver(o);

  }

  public void unregisterOnAgentWearablesReply(EventObserver<AgentWearablesReplyEventArgs> o)

  {

    onAgentWearablesReply.deleteObserver(o);

  }

  private EventObservable<AgentCachedBakesReplyEventArgs> onCachedBakesReply = new EventObservable<AgentCachedBakesReplyEventArgs>();

  public void registerOnCachedBakesReply(EventObserver<AgentCachedBakesReplyEventArgs> o)

  {

    onCachedBakesReply.addObserver(o);

  }

  public void unregisterOnCachedBakesReply(EventObserver<AgentCachedBakesReplyEventArgs> o)

  {

    onCachedBakesReply.deleteObserver(o);

  }

  private EventObservable<AppearanceSetEventArgs> onAppearanceSet = new EventObservable<AppearanceSetEventArgs>();

  public void registerOnAppearanceSet(EventObserver<AppearanceSetEventArgs> o)

  {

    onAppearanceSet.addObserver(o);

  }

  public void unregisterOnAppearanceSet(EventObserver<AppearanceSetEventArgs> o)

  {

    onAppearanceSet.deleteObserver(o);

  }

  private EventObservable<RebakeAvatarTexturesEventArgs> onRebakeAvatarRequested = new EventObservable<RebakeAvatarTexturesEventArgs>();

  public void registerOnRebakeAvatarRequested(EventObserver<RebakeAvatarTexturesEventArgs> o)

  {

    onRebakeAvatarRequested.addObserver(o);

  }

  public void unregisterOnRebakeAvatarRequested(EventObserver<RebakeAvatarTexturesEventArgs> o)

  {

    onRebakeAvatarRequested.deleteObserver(o);

  }       

  //region Event delegates, Raise Events

  //          /// <summary>The event subscribers. null if no subcribers</summary>

  //          private EventHandler<AgentWearablesReplyEventArgs> m_AgentWearablesReply;

  //

  //          /// <summary>Raises the AgentWearablesReply event</summary>

  //          /// <param name="e">An AgentWearablesReplyEventArgs object containing the

  //          /// data returned from the data server</param>

  //          protected virtual void OnAgentWearables(AgentWearablesReplyEventArgs e)

  //          {

  //              EventHandler<AgentWearablesReplyEventArgs> handler = m_AgentWearablesReply;

  //              if (handler != null)

  //                  handler(this, e);

  //          }

  //

  //          /// <summary>Thread sync lock object</summary>

  //          private  object m_AgentWearablesLock = new object();

  //

  //          /// <summary>Triggered when an AgentWearablesUpdate packet is received,

  //          /// telling us what our avatar is currently wearing

  //          /// <see cref="RequestAgentWearables"/> request.</summary>

  //          public event EventHandler<AgentWearablesReplyEventArgs> AgentWearablesReply 

  //          {

  //              add { lock (m_AgentWearablesLock) { m_AgentWearablesReply += value; } }

  //              remove { lock (m_AgentWearablesLock) { m_AgentWearablesReply -= value; } }

  //          }

  //

  //

  //          /// <summary>The event subscribers. null if no subcribers</summary>

  //          private EventHandler<AgentCachedBakesReplyEventArgs> m_AgentCachedBakesReply;

  //

  //          /// <summary>Raises the CachedBakesReply event</summary>

  //          /// <param name="e">An AgentCachedBakesReplyEventArgs object containing the

  //          /// data returned from the data server AgentCachedTextureResponse</param>

  //          protected virtual void OnAgentCachedBakes(AgentCachedBakesReplyEventArgs e)

  //          {

  //              EventHandler<AgentCachedBakesReplyEventArgs> handler = m_AgentCachedBakesReply;

  //              if (handler != null)

  //                  handler(this, e);

  //          }

  //

  //

  //          /// <summary>Thread sync lock object</summary>

  //          private  object m_AgentCachedBakesLock = new object();

  //

  //          /// <summary>Raised when an AgentCachedTextureResponse packet is

  //          /// received, giving a list of cached bakes that were found on the

  //          /// simulator

  //          /// <seealso cref="RequestCachedBakes"/> request.</summary>

  //          public event EventHandler<AgentCachedBakesReplyEventArgs> CachedBakesReply  

  //          {

  //              add { lock (m_AgentCachedBakesLock) { m_AgentCachedBakesReply += value; } }

  //              remove { lock (m_AgentCachedBakesLock) { m_AgentCachedBakesReply -= value; } }

  //          }

  //

  //          /// <summary>The event subscribers. null if no subcribers</summary>

  //          private EventHandler<AppearanceSetEventArgs> m_AppearanceSet;

  //

  //          /// <summary>Raises the AppearanceSet event</summary>

  //          /// <param name="e">An AppearanceSetEventArgs object indicating if the operatin was successfull</param>

  //          protected virtual void OnAppearanceSet(AppearanceSetEventArgs e)

  //          {

  //              EventHandler<AppearanceSetEventArgs> handler = m_AppearanceSet;

  //              if (handler != null)

  //                  handler(this, e);

  //          }

  //

  //          /// <summary>Thread sync lock object</summary>

  //          private  object m_AppearanceSetLock = new object();

  //

  //          /// <summary>

  //          /// Raised when appearance data is sent to the simulator, also indicates

  //          /// the main appearance thread is finished.

  //          /// </summary>

  //          /// <seealso cref="RequestAgentSetAppearance"/> request.

  //          public event EventHandler<AppearanceSetEventArgs> AppearanceSet  

  //          {

  //              add { lock (m_AppearanceSetLock) { m_AppearanceSet += value; } }

  //              remove { lock (m_AppearanceSetLock) { m_AppearanceSet -= value; } }

  //          }

  //

  //

  //          /// <summary>The event subscribers. null if no subcribers</summary>

  //          private EventHandler<RebakeAvatarTexturesEventArgs> m_RebakeAvatarReply;

  //

  //          /// <summary>Raises the RebakeAvatarRequested event</summary>

  //          /// <param name="e">An RebakeAvatarTexturesEventArgs object containing the

  //          /// data returned from the data server</param>

  //          protected virtual void OnRebakeAvatar(RebakeAvatarTexturesEventArgs e)

  //          {

  //              EventHandler<RebakeAvatarTexturesEventArgs> handler = m_RebakeAvatarReply;

  //              if (handler != null)

  //                  handler(this, e);

  //          }

  //

  //          /// <summary>Thread sync lock object</summary>

  //          private  object m_RebakeAvatarLock = new object();

  //

  //          /// <summary>

  //          /// Triggered when the simulator requests the agent rebake its appearance.

  //          /// </summary>

  //          /// <seealso cref="RebakeAvatarRequest"/>

  //          public event EventHandler<RebakeAvatarTexturesEventArgs> RebakeAvatarRequested 

  //          {

  //              add { lock (m_RebakeAvatarLock) { m_RebakeAvatarReply += value; } }

  //              remove { lock (m_RebakeAvatarLock) { m_RebakeAvatarReply -= value; } }

  //          }

  //

  //          //endregion

  //

  //region Properties and public fields

  /// <summary>

  /// Returns true if AppearanceManager is busy and trying to set or change appearance will fail

  /// </summary>

  public boolean getManagerBusy()

  {

    return AppearanceThreadRunning.get() != 0;

  }

  /// <summary>Visual parameters last sent to the sim</summary>

  public byte[] MyVisualParameters = null;

  /// <summary>Textures about this client sent to the sim</summary>

  public TextureEntry MyTextures = null;

  //endregion Properties

  //region Private Members

  /// <summary>A cache of wearables currently being worn</summary>

  private Map<WearableType, WearableData> Wearables = new HashMap<WearableType, WearableData>();

  /// <summary>A cache of textures currently being worn</summary>

  private TextureData[] Textures = new TextureData[(int)AvatarTextureIndex.NumberOfEntries.getIndex()];

  /// <summary>Incrementing serial number for AgentCachedTexture packets</summary>

  private AtomicInteger CacheCheckSerialNum = new AtomicInteger(-1);

  /// <summary>Incrementing serial number for AgentSetAppearance packets</summary>

  private AtomicInteger SetAppearanceSerialNum = new AtomicInteger(0);

  /// <summary>Indicates whether or not the appearance thread is currently

  /// running, to prevent multiple appearance threads from running

  /// simultaneously</summary>

  private AtomicInteger AppearanceThreadRunning = new AtomicInteger(0);

  /// <summary>Reference to our agent</summary>

  private GridClient Client;

  /// <summary>

  /// Timer used for delaying rebake on changing outfit

  /// </summary>

  private EventTimer RebakeScheduleTimer = null;

  /// <summary>

  /// Main appearance thread

  /// </summary>

  //  private Thread AppearanceThread;

  //endregion Private Members

  /// <summary>

  /// Default constructor

  /// </summary>

  /// <param name="client">A reference to our agent</param>

  public AppearanceManager(GridClient client)

  {

    Client = client;

    for(int i=0; i< Textures.length; i++)

      Textures[i] = new TextureData();

    // Client.network.RegisterCallback(PacketType.AgentWearablesUpdate, AgentWearablesUpdateHandler);

    Client.network.RegisterCallback(PacketType.AgentWearablesUpdate, new EventObserver<PacketReceivedEventArgs>()

        {

      @Override

      public void handleEvent(Observable o,PacketReceivedEventArgs arg) {

        try{ AgentWearablesUpdateHandler(o, arg);}

        catch(Exception e) {JLogger.warn(Utils.getExceptionStackTraceAsString(e));}

      }}

        );

    // Client.network.RegisterCallback(PacketType.AgentCachedTextureResponse, AgentCachedTextureResponseHandler);

    Client.network.RegisterCallback(PacketType.AgentCachedTextureResponse, new EventObserver<PacketReceivedEventArgs>()

        {

      @Override

      public void handleEvent(Observable o,PacketReceivedEventArgs arg) {

        try{ AgentCachedTextureResponseHandler(o, arg);}

        catch(Exception e) {JLogger.warn(Utils.getExceptionStackTraceAsString(e));}

      }}

        );

    // Client.network.RegisterCallback(PacketType.RebakeAvatarTextures, RebakeAvatarTexturesHandler);

    Client.network.RegisterCallback(PacketType.RebakeAvatarTextures, new EventObserver<PacketReceivedEventArgs>()

        {

      @Override

      public void handleEvent(Observable o,PacketReceivedEventArgs arg) {

        try{ RebakeAvatarTexturesHandler(o, arg);}

        catch(Exception e) {JLogger.warn(Utils.getExceptionStackTraceAsString(e));}

      }}

        );

    //                    Client.network.EventQueueRunning += Network_OnEventQueueRunning;

    EventObserver<EventQueueRunningEventArgs> queueCallback = new EventObserver<EventQueueRunningEventArgs>()

        {

      @Override

      public void handleEvent(Observable o, EventQueueRunningEventArgs e)

      {

        Network_OnEventQueueRunning(o, e);

      }

        };

        Client.network.RegisterOnEventQueueRunningCallback(queueCallback);

        //                    Client.network.Disconnected += Network_OnDisconnected;

        Client.network.RegisterOnDisconnectedCallback(new EventObserver<DisconnectedEventArgs>()

            {

          @Override

          public void handleEvent(Observable o, DisconnectedEventArgs arg)

          {

            Network_OnDisconnected(o, arg);

          }

            });

  }

  //region Publics Methods

  /// <summary>

  /// Starts the appearance setting thread

  /// </summary>

  public void RequestSetAppearance()

  {

    RequestSetAppearance(false);

  }

  /// <summary>

  /// Starts the appearance setting thread

  /// </summary>

  /// <param name="forceRebake">True to force rebaking, otherwise false</param>

  public void RequestSetAppearance(final boolean forceRebake)

  {

    if(!AppearanceThreadRunning.compareAndSet(0, 1))

    {

      JLogger.warn("Appearance thread is already running, skipping");

      return;

    }

    JLogger.info("RequestSetAppearance: updaing appearance");

    // If we have an active delayed scheduled appearance bake, we dispose of it

    if (RebakeScheduleTimer != null)

    {

      RebakeScheduleTimer.cancel();

      RebakeScheduleTimer = null;

    }

    threadPool.execute(new Runnable(){

      public void run()

      {

        boolean success = true;

        try

        {

          if (forceRebake)

          {

            // Set all of the baked textures to UUID.Zero to force rebaking

            for (int bakedIndex = 0; bakedIndex < BAKED_TEXTURE_COUNT; bakedIndex++)

              Textures[(int)BakeTypeToAgentTextureIndex(BakeType.get(bakedIndex)).getIndex()].TextureID = UUID.Zero;

          }

          if (SetAppearanceSerialNum.get() == 0)

          {

            // Fetch a list of the current agent wearables

            if (!GetAgentWearables())

            {

              JLogger.error("Failed to retrieve a list of current agent wearables, appearance cannot be set");

              throw new Exception("Failed to retrieve a list of current agent wearables, appearance cannot be set");

            }

          }

          JLogger.debug("Got Agent Wearable .. going to download wearables");

          // Download and parse all of the agent wearables

          if (!DownloadWearables())

          {

            success = false;

            JLogger.error("One or more agent wearables failed to download, appearance will be incomplete");

          }

          // If this is the first time setting appearance and we're not forcing rebakes, check the server

          // for cached bakes

          if (SetAppearanceSerialNum.get() == 0 && !forceRebake)

          {

            JLogger.debug("Going to GetCachedBakes...");

            // Compute hashes for each bake layer and compare against what the simulator currently has

            if (!GetCachedBakes())

            {

              JLogger.warn("Failed to get a list of cached bakes from the simulator, appearance will be rebaked");

            }

          }

          JLogger.debug("Going to create Bakes....");

          // Download textures, compute bakes, and upload for any cache misses

          if (!CreateBakes())

          {

            success = false;

            JLogger.warn("Failed to create or upload one or more bakes, appearance will be incomplete");

          }

          // Send the appearance packet

          RequestAgentSetAppearance();

        }

        catch (Exception e)

        {

          JLogger.warn(e);

          success = false;

        }

        finally

        {

          AppearanceThreadRunning.set(0);

          onAppearanceSet.raiseEvent(new AppearanceSetEventArgs(success));

        }

      }               

    });

  }

  /// <summary>

  /// Ask the server what textures our agent is currently wearing

  /// </summary>

  public void RequestAgentWearables()

  {

    AgentWearablesRequestPacket request = new AgentWearablesRequestPacket();

    request.AgentData.AgentID = Client.self.getAgentID();

    request.AgentData.SessionID = Client.self.getSessionID();

    Client.network.SendPacket(request);

  }

  /// <summary>

  /// Build hashes out of the texture assetIDs for each baking layer to

  /// ask the simulator whether it has cached copies of each baked texture

  /// </summary>

  public void RequestCachedBakes()

  {

    List<AgentCachedTexturePacket.WearableDataBlock> hashes = new ArrayList<AgentCachedTexturePacket.WearableDataBlock>();

    // Build hashes for each of the bake layers from the individual components

    synchronized (Wearables)

    {

      for (int bakedIndex = 0; bakedIndex < BAKED_TEXTURE_COUNT; bakedIndex++)

      {

        // Don't do a cache request for a skirt bake if we're not wearing a skirt

        if ((bakedIndex == (int)BakeType.Skirt.getIndex())

            && !Wearables.containsKey(WearableType.Skirt))

          continue;

        // Build a hash of all the texture asset IDs in this baking layer

        UUID hash = UUID.Zero;

        for (int wearableIndex = 0; wearableIndex < WEARABLES_PER_LAYER; wearableIndex++)

        {

          WearableType type = WEARABLE_BAKE_MAP[bakedIndex][wearableIndex];

          WearableData wearable;

          if (type != WearableType.Invalid

              && (wearable = Wearables.get(type))!=null)

            hash = UUID.xor(hash, wearable.AssetID);

        }

        if (!hash.equals(UUID.Zero))

        {

          // Hash with our secret value for this baked layer

          hash = UUID.xor(hash,  BAKED_TEXTURE_HASH[bakedIndex]);

          // Add this to the list of hashes to send out

          AgentCachedTexturePacket.WearableDataBlock block = new AgentCachedTexturePacket.WearableDataBlock();

          block.ID = hash;

          block.TextureIndex = (byte)bakedIndex;

          hashes.add(block);

          JLogger.debug("Checking cache for " + BakeType.get((int)block.TextureIndex) + ", hash=" + block.ID);

        }

      }

    }

    // Only send the packet out if there's something to check

    if (hashes.size() > 0)

    {

      AgentCachedTexturePacket cache = new AgentCachedTexturePacket();

      cache.AgentData.AgentID = Client.self.getAgentID();

      cache.AgentData.SessionID = Client.self.getSessionID();

      cache.AgentData.SerialNum = CacheCheckSerialNum.incrementAndGet();

      cache.WearableData = hashes.toArray(new WearableDataBlock[0]);

      Client.network.SendPacket(cache);

    }

  }

  /// <summary>

  /// Returns the AssetID of the asset that is currently being worn in a

  /// given WearableType slot

  /// </summary>

  /// <param name="type">WearableType slot to get the AssetID for</param>

  /// <returns>The UUID of the asset being worn in the given slot, or

  /// UUID.Zero if no wearable is attached to the given slot or wearables

  /// have not been downloaded yet</returns>

  public UUID GetWearableAsset(WearableType type)

  {

    WearableData wearable;

    if ((wearable = Wearables.get(type))!=null)

      return wearable.AssetID;

    else

      return UUID.Zero;

  }

  /// <summary>

  /// Add a wearable to the current outfit and set appearance

  /// </summary>

  /// <param name="wearableItem">Wearable to be added to the outfit</param>

  public void AddToOutfit(InventoryItem wearableItem)

  {

    List<InventoryItem> wearableItems = new ArrayList<InventoryItem>();

    wearableItems.add(wearableItem);

    AddToOutfit(wearableItems);

  }

  /// <summary>

  /// Add a list of wearables to the current outfit and set appearance

  /// </summary>

  /// <param name="wearableItems">List of wearable inventory items to

  /// be added to the outfit</param>

  public void AddToOutfit(List<InventoryItem> wearableItems)

  {

    List<InventoryWearable> wearables = new ArrayList<InventoryWearable>();

    List<InventoryItem> attachments = new ArrayList<InventoryItem>();

    for (int i = 0; i < wearableItems.size(); i++)

    {

      InventoryItem item = wearableItems.get(i);

      if (item instanceof InventoryWearable)

        wearables.add((InventoryWearable)item);

      else if ((item instanceof InventoryAttachment) || (item instanceof InventoryObject))

        attachments.add(item);

    }

    synchronized (Wearables)

    {

      // Add the given wearables to the wearables collection

      for (int i = 0; i < wearables.size(); i++)

      {

        InventoryWearable wearableItem = wearables.get(i);

        WearableData wd = new WearableData();

        wd.AssetID = wearableItem.AssetUUID;

        wd.AssetType = wearableItem.AssetType;

        wd.ItemID = wearableItem.UUID;

        wd.WearableType = wearableItem.getWearableType();

        Wearables.put(wearableItem.getWearableType(), wd);

      }

    }

    if (attachments.size() > 0)

    {

      AddAttachments(attachments, false);

    }

    if (wearables.size() > 0)

    {

      SendAgentIsNowWearing();

      DelayedRequestSetAppearance();

    }

  }

  /// <summary>

  /// Remove a wearable from the current outfit and set appearance

  /// </summary>

  /// <param name="wearableItem">Wearable to be removed from the outfit</param>

  public void RemoveFromOutfit(InventoryItem wearableItem)

  {

    List<InventoryItem> wearableItems = new ArrayList<InventoryItem>();

    wearableItems.add(wearableItem);

    RemoveFromOutfit(wearableItems);

  }

  /// <summary>

  /// Removes a list of wearables from the current outfit and set appearance

  /// </summary>

  /// <param name="wearableItems">List of wearable inventory items to

  /// be removed from the outfit</param>

  public void RemoveFromOutfit(List<InventoryItem> wearableItems)

  {

    List<InventoryWearable> wearables = new ArrayList<InventoryWearable>();

    List<InventoryItem> attachments = new ArrayList<InventoryItem>();

    for (int i = 0; i < wearableItems.size(); i++)

    {

      InventoryItem item = wearableItems.get(i);

      if (item instanceof InventoryWearable)

        wearables.add((InventoryWearable)item);

      else if (item instanceof InventoryAttachment || item instanceof InventoryObject)

        attachments.add(item);

    }

    boolean needSetAppearance = false;

    synchronized (Wearables)

    {

      // Remove the given wearables from the wearables collection

      for (int i = 0; i < wearables.size(); i++)

      {

        InventoryWearable wearableItem = wearables.get(i);

        if (wearables.get(i).AssetType != AssetType.Bodypart        // Remove if it's not a body part

            && Wearables.containsKey(wearableItem.getWearableType()) // And we have that wearabe type

            && Wearables.get(wearableItem.getWearableType()).ItemID.equals(wearableItem.UUID) // And we are wearing it

            )

        {

          Wearables.remove(wearableItem.getWearableType());

          needSetAppearance = true;

        }

      }

    }

    for (int i = 0; i < attachments.size(); i++)

    {

      Detach(attachments.get(i).UUID);

    }

    if (needSetAppearance)

    {

      SendAgentIsNowWearing();

      DelayedRequestSetAppearance();

    }

  }

  /// <summary>

  /// Replace the current outfit with a list of wearables and set appearance

  /// </summary>

  /// <param name="wearableItems">List of wearable inventory items that

  /// define a new outfit</param>

  public void ReplaceOutfit(List<InventoryItem> wearableItems) throws InterruptedException

  {

    ReplaceOutfit(wearableItems, true);

  }

  /// <summary>

  /// Replace the current outfit with a list of wearables and set appearance

  /// </summary>

  /// <param name="wearableItems">List of wearable inventory items that

  /// define a new outfit</param>

  /// <param name="safe">Check if we have all body parts, set this to false only

  /// if you know what you're doing</param>

  public void ReplaceOutfit(List<InventoryItem> wearableItems, boolean safe) throws InterruptedException

  {

    List<InventoryWearable> wearables = new ArrayList<InventoryWearable>();

    List<InventoryItem> attachments = new ArrayList<InventoryItem>();

    for (int i = 0; i < wearableItems.size(); i++)

    {

      InventoryItem item = wearableItems.get(i);

      if (item instanceof InventoryWearable)

        wearables.add((InventoryWearable)item);

      else if (item instanceof InventoryAttachment || item instanceof InventoryObject)

        attachments.add(item);

    }

    if (safe)

    {

      // If we don't already have a the current agent wearables downloaded, updating to a

      // new set of wearables that doesn't have all of the bodyparts can leave the avatar

      // in an inconsistent state. If any bodypart entries are empty, we need to fetch the

      // current wearables first

      boolean needsCurrentWearables = false;

      synchronized (Wearables)

      {

        for (int i = 0; i < WEARABLE_COUNT; i++)