* 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

*/

   

    //region Enums

    public enum EstateAssetTypeint

    {

        None (-1),

        Covenant (0);

        private int index;

        EstateAssetTypeint(int index)

    {

      this.index = index;

    }    

    public int getIndex()

    {

      return index;

    }

    private static final Map<Integer,EstateAssetTypeint> lookup 

    = new HashMap<Integer,EstateAssetTypeint>();

    static {

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

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

    }

    public static EstateAssetTypeint get(Integer index)

    {

      return lookup.get(index);

    }  

    }

    /// <summary>

    ///

    /// </summary>

    public enum StatusCode

    {

        /// <summary>OK</summary>

        OK(0),

        /// <summary>Transfer completed</summary>

        Done(1),

        /// <summary></summary>

        Skip(2),

        /// <summary></summary>

        Abort(3),

        /// <summary>Unknown error occurred</summary>

        Error(-1),

        /// <summary>Equivalent to a 404 error</summary>

        UnknownSource(-2),

        /// <summary>Client does not have permission for that resource</summary>

        InsufficientPermissions(-3),

        /// <summary>Unknown status</summary>

        Unknown(-4);

        private int index;

        StatusCode(int index)

    {

      this.index = index;

    }    

    public int getIndex()

    {

      return index;

    }

    private static final Map<Integer,StatusCode> lookup 

    = new HashMap<Integer,StatusCode>();

    static {

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

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

    }

    public static StatusCode get(Integer index)

    {

      return lookup.get(index);

    }  

    }

    /// <summary>

    ///

    /// </summary>

    public enum ChannelType

    {

        /// <summary></summary>

        Unknown(0),

        /// <summary>Unknown</summary>

        Misc (1),

        /// <summary>Virtually all asset transfers use this channel</summary>

        Asset (2);

       

        private int index;

        ChannelType(int index)

    {

      this.index = index;

    }    

    public int getIndex()

    {

      return index;

    }

    private static final Map<Integer,ChannelType> lookup 

    = new HashMap<Integer,ChannelType>();

    static {

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

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

    }

    public static ChannelType get(Integer index)

    {

      return lookup.get(index);

    }  

    }

    /// <summary>

    ///

    /// </summary>

    public enum SourceType

    {

        /// <summary></summary>

        Unknown(0),

        /// <summary>Asset from the asset server</summary>

        Asset (2),

        /// <summary>Inventory item</summary>

        SimInventoryItem (3),

        /// <summary>Estate asset, such as an estate covenant</summary>

        SimEstate (4);

       

        private int index;

        SourceType(int index)

    {

      this.index = index;

    }    

    public int getIndex()

    {

      return index;

    }

    private static final Map<Integer,SourceType> lookup 

    = new HashMap<Integer,SourceType>();

    static {

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

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

    }

    public static SourceType get(Integer index)

    {

      return lookup.get(index);

    }  

    }

    /// <summary>

    ///

    /// </summary>

    public enum TargetType

    {

        /// <summary></summary>

        Unknown (0),

        /// <summary></summary>

        File (1),

        /// <summary></summary>

        VFile (2);

       

        private int index;

        TargetType(int index)

    {

      this.index = index;

    }    

    public int getIndex()

    {

      return index;

    }

    private static final Map<Integer,TargetType> lookup 

    = new HashMap<Integer,TargetType>();

    static {

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

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

    }

    public static TargetType get(Integer index)

    {

      return lookup.get(index);

    }  

    }

    /// <summary>

    ///

    /// </summary>

    public static enum ImageType

    {

        /// <summary></summary>

        Normal((byte)0),

        /// <summary></summary>

        Baked ((byte)1);

    private byte index;

    ImageType(byte index)

    {

      this.index = index;

    }    

    public byte getIndex()

    {

      return index;

    }

    private static final Map<Byte,ImageType> lookup  = new HashMap<Byte,ImageType>();

    static {

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

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

    }

    public static ImageType get(Byte index)

    {

      return lookup.get(index);

    }

    }

    /// <summary>

    /// Image file format

    /// </summary>

    public enum ImageCodec

    {

        Invalid((byte)0),

        RGB((byte)1),

        J2C((byte)2),

        BMP((byte)3),

        TGA((byte)4),

        JPEG((byte)5),

        DXT ((byte)6),

        PNG ((byte)7);

       

      private byte index;

      ImageCodec(byte index)

    {

      this.index = index;

    }    

    public byte getIndex()

    {

      return index;

    }

    private static final Map<Byte,ImageCodec> lookup  = new HashMap<Byte,ImageCodec>();

    static {

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

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

    }

    public static ImageCodec get(Byte index)

    {

      return lookup.get(index);

    }

    }

    public static enum TransferError

    {

        None(0),

        Failed(-1),

        AssetNotFound(-3),

        AssetNotFoundInDatabase(-4),

        InsufficientPermissions(-5),

        EOF(-39),

        CannotOpenFile(-42),

        FileNotFound(-43),

        FileIsEmpty(-44),

        TCPTimeout(-23016),

        CircuitGone(-23017);

        private int index;

        TransferError(int index)

    {

      this.index = index;

    }    

    public int getIndex()

    {

      return index;

    }

    private static final Map<Integer,TransferError> lookup 

    = new HashMap<Integer,TransferError>();

    static {

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

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

    }

    public static TransferError get(Integer index)

    {

      return lookup.get(index);

    }

    }

    public static class UploadRequestResult

    {

      UUID transactionID;

      UUID agentID;

     

    public UploadRequestResult() {

      super();

      transactionID = new UUID();

      agentID = new UUID();

    }

   

    public UploadRequestResult(UUID transactionID, UUID agentID) {

      super();

      this.transactionID = transactionID;

      this.agentID = agentID;

    }

    public UUID getTransactionID() {

      return transactionID;

    }

    public void setTransactionID(UUID transactionID) {

      this.transactionID = transactionID;

    }

    public UUID getAgentID() {

      return agentID;

    }

    public void setAgentID(UUID agentID) {

      this.agentID = agentID;

    }

     

    }

   

    //endregion Enums  

   

 

    /// <summary>Number of milliseconds to wait for a transfer header packet if out of order data was received</summary>

    final int TRANSFER_HEADER_TIMEOUT = 1000 * 15;

    //region Delegates

    /// <summary>

    /// Callback used for various asset download requests

    /// </summary>

    /// <param name="transfer">Transfer information</param>

    /// <param name="asset">Downloaded asset, null on fail</param>

   

    public MethodDelegate<Void, AssetReceivedCallbackArgs> assetReceivedCallback;

    /// <summary>

    /// Callback used upon competition of baked texture upload

    /// </summary>

    /// <param name="newAssetID">Asset UUID of the newly uploaded baked texture</param>

    public MethodDelegate<Void, BakedTextureUploadedCallbackArgs> bakedTextureUploadedCallback;

   

    /// <summary>

    /// A callback that fires upon the completition of the RequestMesh call

    /// </summary>

    /// <param name="success">Was the download successfull</param>

    /// <param name="assetMesh">Resulting mesh or null on problems</param>

    public MethodDelegate<Void, MeshDownloadCallbackArgs> meshDownloadCallback;

    //endregion Delegates

    //region Events

    private EventObservable<XferReceivedEventArgs> onXferReceived = new EventObservable<XferReceivedEventArgs>();

    public void registerOnXferReceived(EventObserver<XferReceivedEventArgs> o)

    {

      onXferReceived.addObserver(o);

    }

    public void unregisterOnXferReceived(EventObserver<XferReceivedEventArgs> o)

    {

      onXferReceived.deleteObserver(o);

    }

    private EventObservable<AssetUploadEventArgs> onAssetUploaded = new EventObservable<AssetUploadEventArgs>();

    public void registerOnAssetUploaded(EventObserver<AssetUploadEventArgs> o)

    {

      onAssetUploaded.addObserver(o);

    }

    public void unregisterOnAssetUploaded(EventObserver<AssetUploadEventArgs> o)

    {

      onAssetUploaded.deleteObserver(o);

    }

    private EventObservable<AssetUploadEventArgs> onUploadProgress = new EventObservable<AssetUploadEventArgs>();

    public void registerOnUploadProgress(EventObserver<AssetUploadEventArgs> o)

    {

      onUploadProgress.addObserver(o);

    }

    public void unregisterOnUploadProgress(EventObserver<AssetUploadEventArgs> o)

    {

      onUploadProgress.deleteObserver(o);

    }

    private EventObservable<InitiateDownloadEventArgs> onInitiateDownload = new EventObservable<InitiateDownloadEventArgs>();

    public void registerOnInitiateDownload(EventObserver<InitiateDownloadEventArgs> o)

    {

      onInitiateDownload.addObserver(o);

    }

    public void unregisterOnInitiateDownload(EventObserver<InitiateDownloadEventArgs> o)

    {

      onInitiateDownload.deleteObserver(o);

    }

    private EventObservable<ImageReceiveProgressEventArgs> onImageReceiveProgress = new EventObservable<ImageReceiveProgressEventArgs>();

    public void registerOnImageReceiveProgress(EventObserver<ImageReceiveProgressEventArgs> o)

    {

      onImageReceiveProgress.addObserver(o);

    }

    public void unregisterOnImageReceiveProgress(EventObserver<ImageReceiveProgressEventArgs> o)

    {

      onImageReceiveProgress.deleteObserver(o);

    }

   

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

//    private EventHandler<XferReceivedEventArgs> m_XferReceivedEvent;

//

//    /// <summary>Raises the XferReceived event</summary>

//    /// <param name="e">A XferReceivedEventArgs object containing the

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

//    protected virtual void OnXferReceived(XferReceivedEventArgs e)

//    {

//        EventHandler<XferReceivedEventArgs> handler = m_XferReceivedEvent;

//        if (handler != null)

//            handler(this, e);

//    }

//

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

//    private readonly object m_XferReceivedLock = new object();

//

//    /// <summary>Raised when the simulator responds sends </summary>

//    public event EventHandler<XferReceivedEventArgs> XferReceived

//    {

//        add { lock (m_XferReceivedLock) { m_XferReceivedEvent += value; } }

//        remove { lock (m_XferReceivedLock) { m_XferReceivedEvent -= value; } }

//    }

//    //endregion

//

//    //region AssetUploaded

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

//    private EventHandler<AssetUploadEventArgs> m_AssetUploadedEvent;

//

//    /// <summary>Raises the AssetUploaded event</summary>

//    /// <param name="e">A AssetUploadedEventArgs object containing the

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

//    protected virtual void OnAssetUploaded(AssetUploadEventArgs e)

//    {

//        EventHandler<AssetUploadEventArgs> handler = m_AssetUploadedEvent;

//        if (handler != null)

//            handler(this, e);

//    }

//

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

//    private readonly object m_AssetUploadedLock = new object();

//

//    /// <summary>Raised during upload completes</summary>

//    public event EventHandler<AssetUploadEventArgs> AssetUploaded

//    {

//        add { lock (m_AssetUploadedLock) { m_AssetUploadedEvent += value; } }

//        remove { lock (m_AssetUploadedLock) { m_AssetUploadedEvent -= value; } }

//    }

//    //endregion

//

//    //region UploadProgress

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

//    private EventHandler<AssetUploadEventArgs> m_UploadProgressEvent;

//

//    /// <summary>Raises the UploadProgress event</summary>

//    /// <param name="e">A UploadProgressEventArgs object containing the

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

//    protected virtual void OnUploadProgress(AssetUploadEventArgs e)

//    {

//        EventHandler<AssetUploadEventArgs> handler = m_UploadProgressEvent;

//        if (handler != null)

//            handler(this, e);

//    }

//

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

//    private readonly object m_UploadProgressLock = new object();

//

//    /// <summary>Raised during upload with progres update</summary>

//    public event EventHandler<AssetUploadEventArgs> UploadProgress

//    {

//        add { lock (m_UploadProgressLock) { m_UploadProgressEvent += value; } }

//        remove { lock (m_UploadProgressLock) { m_UploadProgressEvent -= value; } }

//    }

//    //endregion UploadProgress

//

//    //region InitiateDownload

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

//    private EventHandler<InitiateDownloadEventArgs> m_InitiateDownloadEvent;

//

//    /// <summary>Raises the InitiateDownload event</summary>

//    /// <param name="e">A InitiateDownloadEventArgs object containing the

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

//    protected virtual void OnInitiateDownload(InitiateDownloadEventArgs e)

//    {

//        EventHandler<InitiateDownloadEventArgs> handler = m_InitiateDownloadEvent;

//        if (handler != null)

//            handler(this, e);

//    }

//

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

//    private readonly object m_InitiateDownloadLock = new object();

//

//    /// <summary>Fired when the simulator sends an InitiateDownloadPacket, used to download terrain .raw files</summary>

//    public event EventHandler<InitiateDownloadEventArgs> InitiateDownload

//    {

//        add { lock (m_InitiateDownloadLock) { m_InitiateDownloadEvent += value; } }

//        remove { lock (m_InitiateDownloadLock) { m_InitiateDownloadEvent -= value; } }

//    }

//    //endregion InitiateDownload

//

//    //region ImageReceiveProgress

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

//    private EventHandler<ImageReceiveProgressEventArgs> m_ImageReceiveProgressEvent;

//

//    /// <summary>Raises the ImageReceiveProgress event</summary>

//    /// <param name="e">A ImageReceiveProgressEventArgs object containing the

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

//    protected virtual void OnImageReceiveProgress(ImageReceiveProgressEventArgs e)

//    {

//        EventHandler<ImageReceiveProgressEventArgs> handler = m_ImageReceiveProgressEvent;

//        if (handler != null)

//            handler(this, e);

//    }

//

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

//    private readonly object m_ImageReceiveProgressLock = new object();

//

//    /// <summary>Fired when a texture is in the process of being downloaded by the TexturePipeline class</summary>

//    public event EventHandler<ImageReceiveProgressEventArgs> ImageReceiveProgress

//    {

//        add { lock (m_ImageReceiveProgressLock) { m_ImageReceiveProgressEvent += value; } }

//        remove { lock (m_ImageReceiveProgressLock) { m_ImageReceiveProgressEvent -= value; } }

//    }

//    //endregion ImageReceiveProgress

//

//    //endregion Events

   

   

   

  private static ThreadPool threadPool = ThreadPoolFactory.getThreadPool();

   

    /// <summary>Texture download cache</summary>

    public AssetCache Cache;

    private TexturePipeline Texture;

    private DownloadManager HttpDownloads;

    private GridClient Client;

    private Map<UUID, Transfer> Transfers = new HashMap<UUID, Transfer>();

    private AssetUpload PendingUpload;

    private Object PendingUploadLock = new Object();

    private volatile boolean WaitingForUploadConfirm = false;

    /// <summary>

    /// Default constructor

    /// </summary>

    /// <param name="client">A reference to the GridClient object</param>

    public AssetManager(GridClient client)

    {

        Client = client;

        Cache = new AssetCache(client);

        Texture = new TexturePipeline(client);

        HttpDownloads = new DownloadManager();

        //        // Transfer packets for downloading large assets

        //        // Client.network.RegisterCallback(PacketType.TransferInfo, TransferInfoHandler);

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

            {

          @Override

          public void handleEvent(Observable o,PacketReceivedEventArgs arg) {

            try{ TransferInfoHandler(o, arg);}

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

          }}

            );

       

        //        // Client.network.RegisterCallback(PacketType.TransferPacket, TransferPacketHandler);

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

            {

          @Override

          public void handleEvent(Observable o,PacketReceivedEventArgs arg) {

            try{ TransferPacketHandler(o, arg);}

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

          }}

            );

       

        //        // Xfer packets for uploading large assets

        //        // Client.network.RegisterCallback(PacketType.RequestXfer, RequestXferHandler);

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

            {

          @Override

          public void handleEvent(Observable o,PacketReceivedEventArgs arg) {

            try{ RequestXferHandler(o, arg);}

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

          }}

            );

       

        //        // Client.network.RegisterCallback(PacketType.ConfirmXferPacket, ConfirmXferPacketHandler);

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

            {

          @Override

          public void handleEvent(Observable o,PacketReceivedEventArgs arg) {

            try{ ConfirmXferPacketHandler(o, arg);}

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

          }}

            );

        //        // Client.network.RegisterCallback(PacketType.AssetUploadComplete, AssetUploadCompleteHandler);

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

            {

          @Override

          public void handleEvent(Observable o,PacketReceivedEventArgs arg) {

            try{ AssetUploadCompleteHandler(o, arg);}

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

          }}

            );

       

                // Xfer packets for downloading misc assets

        //        // Client.network.RegisterCallback(PacketType.SendXferPacket, SendXferPacketHandler);

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

            {

          @Override

          public void handleEvent(Observable o,PacketReceivedEventArgs arg) {

            try{ SendXferPacketHandler(o, arg);}

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

          }}

            );

       

        //        // Client.network.RegisterCallback(PacketType.AbortXfer, AbortXferHandler);

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

            {

          @Override

          public void handleEvent(Observable o,PacketReceivedEventArgs arg) {

            try{ AbortXferHandler(o, arg);}

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

          }}

            );

       

        //        // Simulator is responding to a request to download a file

        //        // Client.network.RegisterCallback(PacketType.InitiateDownload, InitiateDownloadPacketHandler);

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

            {

          @Override

          public void handleEvent(Observable o,PacketReceivedEventArgs arg) {

            try{ InitiateDownloadPacketHandler(o, arg);}

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

          }}

            );

    }

   

    /// <summary>

    /// Request an asset download

    /// </summary>

    /// <param name="assetID">Asset UUID</param>

    /// <param name="type">Asset type, must be correct for the transfer to succeed</param>

    /// <param name="priority">Whether to give this transfer an elevated priority</param>

    /// <param name="callback">The callback to fire when the simulator responds with the asset data</param>

    public void RequestAsset(UUID assetID, AssetType type, boolean priority,

        MethodDelegate<Void, AssetReceivedCallbackArgs> callback)

    {

        RequestAsset(assetID, type, priority, SourceType.Asset, UUID.Random(), callback);

    }

    /// <summary>

    /// Request an asset download

    /// </summary>

    /// <param name="assetID">Asset UUID</param>

    /// <param name="type">Asset type, must be correct for the transfer to succeed</param>

    /// <param name="priority">Whether to give this transfer an elevated priority</param>

    /// <param name="sourceType">Source location of the requested asset</param>

    /// <param name="callback">The callback to fire when the simulator responds with the asset data</param>

    public void RequestAsset(UUID assetID, AssetType type, boolean priority, SourceType sourceType, MethodDelegate<Void, AssetReceivedCallbackArgs> callback)

    {

        RequestAsset(assetID, type, priority, sourceType, UUID.Random(), callback);

    }

    /// <summary>

    /// Request an asset download

    /// </summary>

    /// <param name="assetID">Asset UUID</param>

    /// <param name="type">Asset type, must be correct for the transfer to succeed</param>

    /// <param name="priority">Whether to give this transfer an elevated priority</param>

    /// <param name="sourceType">Source location of the requested asset</param>

    /// <param name="transactionID">UUID of the transaction</param>

    /// <param name="callback">The callback to fire when the simulator responds with the asset data</param>

    public void RequestAsset(UUID assetID, AssetType type, boolean priority,

        SourceType sourceType, UUID transactionID,

        MethodDelegate<Void, AssetReceivedCallbackArgs> callback)

    {

        AssetDownload transfer = new AssetDownload();

        transfer.ID = transactionID;

        transfer.AssetID = assetID;

        //transfer.AssetType = type; // Set in TransferInfoHandler.

        transfer.Priority = 100.0f + (priority ? 1.0f : 0.0f);

        transfer.Channel = ChannelType.Asset;

        transfer.Source = sourceType;

        transfer.Simulator = Client.network.getCurrentSim();

        transfer.Callback = callback;

        // Check asset cache first

        if (callback != null && Cache.hasAsset(assetID))

        {

            byte[] data = Cache.getCachedAssetBytes(assetID);

            transfer.AssetData = data;

            transfer.Success = true;

            transfer.Status = StatusCode.OK;

            Asset asset = CreateAssetWrapper(type);

            asset.AssetData = data;

            asset.setAssetID(assetID);

            try { callback.execute(new AssetReceivedCallbackArgs(transfer, asset)); }

            catch (Exception e) { JLogger.error(e); }

            return;

        }

        // Add this transfer to the dictionary

        synchronized (Transfers)

        {

          Transfers.put(transfer.ID, transfer);

        }

        // Build the request packet and send it

        TransferRequestPacket request = new TransferRequestPacket();

        request.TransferInfo.ChannelType = (int)transfer.Channel.getIndex();

        request.TransferInfo.Priority = transfer.Priority;

        request.TransferInfo.SourceType = (int)transfer.Source.getIndex();

        request.TransferInfo.TransferID = transfer.ID;

        byte[] paramField = new byte[20];

        Utils.arraycopy(assetID.GetBytes(), 0, paramField, 0, 16);

        Utils.arraycopy(Utils.intToBytes(Utils.ubyteToInt(type.getIndex())), 0, paramField, 16, 4);

        request.TransferInfo.Params = paramField;

        Client.network.SendPacket(request, transfer.Simulator);

    }

    /// <summary>

    /// Request an asset download through the almost deprecated Xfer system

    /// </summary>

    /// <param name="filename">Filename of the asset to request</param>

    /// <param name="deleteOnCompletion">Whether or not to delete the asset

    /// off the server after it is retrieved</param>

    /// <param name="useBigPackets">Use large transfer packets or not</param>

    /// <param name="vFileID">UUID of the file to request, if filename is

    /// left empty</param>

    /// <param name="vFileType">Asset type of <code>vFileID</code>, or

    /// <code>AssetType.Unknown</code> if filename is not empty</param>

    /// <param name="fromCache">Sets the FilePath in the request to Cache

    /// (4) if true, otherwise Unknown (0) is used</param>

    /// <returns></returns>

    public BigInteger RequestAssetXfer(String filename, boolean deleteOnCompletion, boolean useBigPackets, UUID vFileID, AssetType vFileType,

        boolean fromCache)

    {

        UUID uuid = UUID.Random();

        BigInteger id = uuid.GetULong();

        XferDownload transfer = new XferDownload();

        transfer.XferID = id;

        transfer.ID = new UUID(id.longValue()); // Our dictionary tracks transfers with UUIDs, so convert the ulong back

        transfer.Filename = filename;

        transfer.VFileID = vFileID;

        transfer.AssetType = vFileType;

        // Add this transfer to the dictionary

        synchronized(Transfers)

        {

          Transfers.put(transfer.ID, transfer);

        }

        RequestXferPacket request = new RequestXferPacket();

        request.XferID.ID = id;

        request.XferID.Filename = Utils.stringToBytesWithTrailingNullByte(filename);

        request.XferID.FilePath = fromCache ? (byte)4 : (byte)0;

        request.XferID.DeleteOnCompletion = deleteOnCompletion;

        request.XferID.UseBigPackets = useBigPackets;

        request.XferID.VFileID = vFileID;

        request.XferID.VFileType = (short)Utils.ubyteToInt(vFileType.getIndex());

        Client.network.SendPacket(request);

        return id;

    }

    /// <summary>

    ///

    /// </summary>

    /// <param name="assetID">Use UUID.Zero if you do not have the

    /// asset ID but have all the necessary permissions</param>

    /// <param name="itemID">The item ID of this asset in the inventory</param>

    /// <param name="taskID">Use UUID.Zero if you are not requesting an

    /// asset from an object inventory</param>

    /// <param name="ownerID">The owner of this asset</param>

    /// <param name="type">Asset type</param>

    /// <param name="priority">Whether to prioritize this asset download or not</param>

    /// <param name="callback"></param>

    public void RequestInventoryAsset(UUID assetID, UUID itemID, UUID taskID,

        UUID ownerID, AssetType type, boolean priority,

        MethodDelegate<Void, AssetReceivedCallbackArgs> callback)

    {

        AssetDownload transfer = new AssetDownload();

        transfer.ID = UUID.Random();

        transfer.AssetID = assetID;

        //transfer.AssetType = type; // Set in TransferInfoHandler.

        transfer.Priority = 100.0f + (priority ? 1.0f : 0.0f);

        transfer.Channel = ChannelType.Asset;

        transfer.Source = SourceType.SimInventoryItem;

        transfer.Simulator = Client.network.getCurrentSim();

        transfer.Callback = callback;

        // Check asset cache first

        if (callback != null && Cache.hasAsset(assetID))

        {

            byte[] data = Cache.getCachedAssetBytes(assetID);

            transfer.AssetData = data;

            transfer.Success = true;

            transfer.Status = StatusCode.OK;

            Asset asset = CreateAssetWrapper(type);

            asset.AssetData = data;

            asset.setAssetID(assetID);

            try { callback.execute(new AssetReceivedCallbackArgs(transfer, asset)); }

            catch (Exception e) { JLogger.error(e); }

            return;

        }

        // Add this transfer to the dictionary

        synchronized(Transfers)

        {

          Transfers.put(transfer.ID, transfer);

        }

        // Build the request packet and send it

        TransferRequestPacket request = new TransferRequestPacket();

        request.TransferInfo.ChannelType = (int)transfer.Channel.getIndex();

        request.TransferInfo.Priority = transfer.Priority;

        request.TransferInfo.SourceType = (int)transfer.Source.getIndex();

        request.TransferInfo.TransferID = transfer.ID;

        byte[] paramField = new byte[100];

        Utils.arraycopy(Client.self.getAgentID().GetBytes(), 0, paramField, 0, 16);

        Utils.arraycopy(Client.self.getSessionID().GetBytes(), 0, paramField, 16, 16);

        Utils.arraycopy(ownerID.GetBytes(), 0, paramField, 32, 16);

        Utils.arraycopy(taskID.GetBytes(), 0, paramField, 48, 16);

        Utils.arraycopy(itemID.GetBytes(), 0, paramField, 64, 16);

        Utils.arraycopy(assetID.GetBytes(), 0, paramField, 80, 16);

        Utils.arraycopy(Utils.intToBytes(Utils.ubyteToInt(type.getIndex())), 0, paramField, 96, 4);

        request.TransferInfo.Params = paramField;

        Client.network.SendPacket(request, transfer.Simulator);

    }

    public void RequestInventoryAsset(InventoryItem item, boolean priority, MethodDelegate<Void, AssetReceivedCallbackArgs> callback)

    {

        RequestInventoryAsset(item.AssetUUID, item.UUID, UUID.Zero, item.OwnerID, item.AssetType, priority, callback);

    }

    public void RequestEstateAsset() throws Exception

    {

        throw new Exception("This function is not implemented yet!");

    }

    /// <summary>

    /// Used to force asset data into the PendingUpload property, ie: for raw terrain uploads

    /// </summary>

    /// <param name="assetData">An AssetUpload object containing the data to upload to the simulator</param>

    public void SetPendingAssetUploadData(AssetUpload assetData)

    {

        synchronized(PendingUploadLock)

        {

            PendingUpload = assetData;

        }

    }

    /// <summary>

    /// Request an asset be uploaded to the simulator

    /// </summary>

    /// <param name="asset">The <seealso cref="Asset"/> Object containing the asset data</param>

    /// <param name="storeLocal">If True, the asset once uploaded will be stored on the simulator

    /// in which the client was connected in addition to being stored on the asset server</param>

    /// <returns>The <seealso cref="UUID"/> of the transfer, can be used to correlate the upload with

    /// events being fired</returns>

    public UUID RequestUpload(Asset asset, boolean storeLocal)

    {

        if (asset.AssetData == null)

            throw new IllegalArgumentException("Can't upload an asset with no data (did you forget to call Encode?)");

       

        UploadRequestResult uploadResult = RequestUpload(asset.getAssetType(), asset.AssetData, storeLocal);

        asset.setAssetID(uploadResult.getAgentID());

        return uploadResult.getTransactionID();

    }

    /// <summary>

    /// Request an asset be uploaded to the simulator

    /// </summary>

    /// <param name="type">The <seealso cref="AssetType"/> of the asset being uploaded</param>

    /// <param name="data">A byte array containing the encoded asset data</param>

    /// <param name="storeLocal">If True, the asset once uploaded will be stored on the simulator

    /// in which the client was connected in addition to being stored on the asset server</param>

    /// <returns>The <seealso cref="UUID"/> of the transfer, can be used to correlate the upload with

    /// events being fired</returns>

    public UploadRequestResult RequestUpload(AssetType type, byte[] data, boolean storeLocal)

    {

        return RequestUpload(type, data, storeLocal);

    }

//    /// Request an asset be uploaded to the simulator

//    /// </summary>

//    /// <param name="assetID"></param>

//    /// <param name="type">Asset type to upload this data as</param>

//    /// <param name="data">A byte array containing the encoded asset data</param>

//    /// <param name="storeLocal">If True, the asset once uploaded will be stored on the simulator

//    /// in which the client was connected in addition to being stored on the asset server</param>

//    /// <returns>The <seealso cref="UUID"/> of the transfer, can be used to correlate the upload with

//    /// events being fired</returns>

//    public UploadRequestResult RequestUpload(UUID assetID, AssetType type, byte[] data, boolean storeLocal)

//    {

//        return RequestUpload(assetID, type, data, storeLocal, UUID.Random());

//    }

   

    /// <summary>

    /// Initiate an asset upload

    /// </summary>

    /// <param name="assetID">The ID this asset will have if the

    /// upload succeeds</param>

    /// <param name="type">Asset type to upload this data as</param>

    /// <param name="data">Raw asset data to upload</param>

    /// <param name="storeLocal">Whether to store this asset on the local

    /// simulator or the grid-wide asset server</param>

    /// <param name="transactionID">The tranaction id for the upload <see cref="RequestCreateItem"/></param>

    /// <returns>The transaction ID of this transfer</returns>

    public UploadRequestResult RequestUpload(AssetType type, byte[] data, boolean storeLocal,

        UUID transactionID) throws Exception

    {

      UploadRequestResult result = new UploadRequestResult();

        AssetUpload upload = new AssetUpload();

        upload.AssetData = data;

        upload.AssetType = type;

        result.setAgentID(UUID.Combine(transactionID, Client.self.getSecureSessionID()));

        upload.AssetID = result.getAgentID();

        upload.Size = data.length;

        upload.XferID = new BigInteger("0");

        upload.ID = transactionID;

        // Build and send the upload packet

        AssetUploadRequestPacket request = new AssetUploadRequestPacket();

        request.AssetBlock.StoreLocal = storeLocal;

        request.AssetBlock.Tempfile = false; // This field is deprecated

        request.AssetBlock.TransactionID = transactionID;

        request.AssetBlock.Type = type.getIndex();

        boolean isMultiPacketUpload;

        if (data.length + 100 < Settings.MAX_PACKET_SIZE)

        {

            isMultiPacketUpload = false;

            JLogger.info(

                String.format("Beginning asset upload [Single Packet], ID: %s, AssetID: %s, Size: %d",

                upload.ID.toString(), upload.AssetID.toString(), upload.Size));

            Transfers.put(upload.ID, upload);

            // The whole asset will fit in this packet, makes things easy

            request.AssetBlock.AssetData = data;

            upload.Transferred = data.length;

        }

        else

        {

            isMultiPacketUpload = true;

            JLogger.info(

                String.format("Beginning asset upload [Multiple Packets], ID: %s, AssetID: %s, Size: %d",

                upload.ID.toString(), upload.AssetID.toString(), upload.Size));

            // Asset is too big, send in multiple packets

            request.AssetBlock.AssetData = Utils.EmptyBytes;

        }

        // Wait for the previous upload to receive a RequestXferPacket

        synchronized(PendingUploadLock)

        {

            final int UPLOAD_CONFIRM_TIMEOUT = 20 * 1000;

            final int SLEEP_INTERVAL = 50;

            int t = 0;

            AutoResetEvent sleepEvent = new AutoResetEvent(false);

            while (WaitingForUploadConfirm && t < UPLOAD_CONFIRM_TIMEOUT)

            {

                sleepEvent.waitOne(SLEEP_INTERVAL);

                t += SLEEP_INTERVAL;

            }

            if (t < UPLOAD_CONFIRM_TIMEOUT)

            {

                if (isMultiPacketUpload)

                {

                    WaitingForUploadConfirm = true;

                }

                PendingUpload = upload;

                Client.network.SendPacket(request);

                result.setTransactionID(upload.ID);

                return result;

            }

            else

            {

                throw new Exception("Timeout waiting for previous asset upload to begin");

            }

        }

    }

    public void RequestUploadBakedTexture(final byte[] textureData, final MethodDelegate<Void,

        BakedTextureUploadedCallbackArgs> callback) throws Exception

    {

        URI url = null;

        Caps caps = Client.network.getCurrentSim().Caps;

        if (caps != null)

            url = caps.CapabilityURI("UploadBakedTexture");

        if (url != null)

        {

            CapsHttpClient request = new CapsHttpClient(url);

            MethodDelegate<Void, CapsHttpRequestCompletedArg> requestCompleteDelegate

                = new MethodDelegate<Void, CapsHttpRequestCompletedArg>()

                {

            public Void execute(CapsHttpRequestCompletedArg e) {

              OSD result = e.getResult();

              Exception error = e.getError();             

                        if (error == null && (result instanceof OSDMap))

                        {

                            UploadBakedTextureMessage message = new UploadBakedTextureMessage();

                            message.Deserialize((OSDMap)result);

   

                            if (message.Request.State.equals("upload"))

                            {

                                URI uploadUrl = ((UploaderRequestUpload)message.Request).Url;

   

                                if (uploadUrl != null)

                                {

                                    // POST the asset data

                                  CapsHttpClient upload = new CapsHttpClient(uploadUrl);

                                  upload.setRequestCompleteDelegate(new MethodDelegate<Void, CapsHttpRequestCompletedArg>()

                                      {

                            public Void execute(CapsHttpRequestCompletedArg e2) {

                              OSD result2 = e2.getResult();

                              Exception error2 = e2.getError();

                              if (error2 == null && result2 instanceof OSDMap)

                                            {

                                                UploadBakedTextureMessage message2 = new UploadBakedTextureMessage();

                                                message2.Deserialize((OSDMap)result2);

   

                                                if (message2.Request.State.equals("complete"))

                                                {                                                 

                                                    callback.execute(new BakedTextureUploadedCallbackArgs(((UploaderRequestComplete)message2.Request).AssetID));

                                                }

                                            }

                                                return null;

                            }

                                      });

                                    upload.BeginGetResponse(textureData, "application/octet-stream", Client.settings.CAPS_TIMEOUT);

                                    return null;

                                }

                            }

                        }

   

                        JLogger.warn("Bake upload failed during uploader retrieval");

                        callback.execute(new BakedTextureUploadedCallbackArgs(UUID.Zero));

              return null;

            }

                };

                request.setRequestCompleteDelegate(requestCompleteDelegate);

                  request.BeginGetResponse(new OSDMap(), OSDFormat.Xml, Client.settings.CAPS_TIMEOUT);

//                delegate(CapsClient client, OSD result, Exception error)

//                {

//                    if (error == null && result is OSDMap)

//                    {

//                        UploadBakedTextureMessage message = new UploadBakedTextureMessage();

//                        message.Deserialize((OSDMap)result);

//

//                        if (message.Request.State == "upload")

//                        {

//                            Uri uploadUrl = ((UploaderRequestUpload)message.Request).Url;

//

//                            if (uploadUrl != null)

//                            {

//                                // POST the asset data

//                                CapsClient upload = new CapsClient(uploadUrl);

//                                upload.OnComplete +=

//                                    delegate(CapsClient client2, OSD result2, Exception error2)

//                                    {

//                                        if (error2 == null && result2 is OSDMap)

//                                        {

//                                            UploadBakedTextureMessage message2 = new UploadBakedTextureMessage();

//                                            message2.Deserialize((OSDMap)result2);

//

//                                            if (message2.Request.State == "complete")

//                                            {

//                                                callback(((UploaderRequestComplete)message2.Request).AssetID);

//                                                return;

//                                            }

//                                        }

//

//                                        Logger.Log("Bake upload failed during asset upload", Helpers.LogLevel.Warning, Client);

//                                        callback(UUID.Zero);

//                                    };

//                                upload.BeginGetResponse(textureData, "application/octet-stream", Client.Settings.CAPS_TIMEOUT);

//                                return;

//                            }

//                        }

//                    }

//

//                    Logger.Log("Bake upload failed during uploader retrieval", Helpers.LogLevel.Warning, Client);

//                    callback(UUID.Zero);

//                };

//            request.BeginGetResponse(new OSDMap(), OSDFormat.Xml, Client.Settings.CAPS_TIMEOUT);

        }

        else

        {

          JLogger.info("UploadBakedTexture not available, falling back to UDP method");