/*
 * Copyright (c) Contributors, http://opensimulator.org/
 * See CONTRIBUTORS.TXT for a full list of copyright holders.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in the
 *       documentation and/or other materials provided with the distribution.
 *     * Neither the name of the OpenSimulator Project nor the
 *       names of its contributors may be used to endorse or promote products
 *       derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

using System;
using System.Timers;
using System.Collections;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.IO;
using System.Net;
using System.Reflection;
using System.Security.Cryptography;
using System.Text;
using System.Web;

using OpenMetaverse;
using OpenMetaverse.StructuredData;
using Nini.Config;
using log4net;

using OpenSim.Framework;
using OpenSim.Framework.Capabilities;
using OpenSim.Region.Framework;
using OpenSim.Region.Framework.Interfaces;
using OpenSim.Region.Framework.Scenes;
using OpenSim.Region.Framework.Scenes.Serialization;
using OpenSim.Framework.Servers;
using OpenSim.Framework.Servers.HttpServer;
using OpenSim.Services.Interfaces;

using Caps = OpenSim.Framework.Capabilities.Caps;
using OSDArray = OpenMetaverse.StructuredData.OSDArray;
using OSDMap = OpenMetaverse.StructuredData.OSDMap;
using PermissionMask = OpenSim.Framework.PermissionMask;

namespace OpenSim.Region.ClientStack.Linden
{
    public delegate void UpLoadedAsset(
        string assetName, string description, UUID assetID, UUID inventoryItem, UUID parentFolder,
        byte[] data, string inventoryType, string assetType,
        int cost, UUID texturesFolder, int nreqtextures, int nreqmeshs, int nreqinstances,
        bool IsAtestUpload, ref string error, ref int nextOwnerMask, ref int groupMask, ref int everyoneMask, int[] meshesSides);

    public delegate void UpdateTaskScript(UUID itemID, UUID primID, bool isScriptRunning, byte[] data, ref ArrayList errors);

    public delegate void NewInventoryItem(UUID userID, InventoryItemBase item, uint cost);

    public delegate void NewAsset(AssetBase asset);

    public delegate ArrayList TaskScriptUpdatedCallback(UUID userID, UUID itemID, UUID primID,
                                                   bool isScriptRunning, byte[] data);

    /// <summary>
    /// XXX Probably not a particularly nice way of allow us to get the scene presence from the scene (chiefly so that
    /// we can popup a message on the user's client if the inventory service has permanently failed).  But I didn't want
    /// to just pass the whole Scene into CAPS.
    /// </summary>
    public delegate IClientAPI GetClientDelegate(UUID agentID);

    public partial class BunchOfCaps
    {
        private static readonly ILog m_log =
            LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);

        private Scene m_Scene;
        private UUID m_AgentID;
        private UUID m_scopeID;
        private Caps m_HostCapsObj;
        private ModelCost m_ModelCost;

        // private static readonly string m_remoteParcelRequestPath = "0009/";// This is in the LandManagementModule.

        // These are callbacks which will be setup by the scene so that we can update scene data when we
        // receive capability calls
        public NewInventoryItem AddNewInventoryItem = null;
        public NewAsset AddNewAsset = null;
        public ItemUpdatedCallback ItemUpdatedCall = null;
        public TaskScriptUpdatedCallback TaskScriptUpdatedCall = null;
        public GetClientDelegate GetClient = null;

        private bool m_persistBakedTextures = false;
        private IAssetService m_assetService;
        private bool m_dumpAssetsToFile = false;
        private string m_regionName;

        private int m_levelUpload = 0;

        private bool m_enableFreeTestUpload = false; // allows "TEST-" prefix hack
        private bool m_ForceFreeTestUpload = false; // forces all uploads to be test

        private bool m_enableModelUploadTextureToInventory = false; // place uploaded textures also in inventory
                                                                    // may not be visible till relog

        private bool m_RestrictFreeTestUploadPerms = false; // reduces also the permitions. Needs a creator defined!!
        private UUID m_testAssetsCreatorID = UUID.Zero;

        private float m_PrimScaleMin = 0.001f;

        private bool m_AllowCapHomeLocation = true;
        private bool m_AllowCapGroupMemberData = true;
        private  IUserManagement m_UserManager;
        private IUserAccountService m_userAccountService;
        private IMoneyModule m_moneyModule;

        private enum FileAgentInventoryState : int
        {
            idle = 0,
            processRequest = 1,
            waitUpload = 2,
            processUpload = 3
        }
        private FileAgentInventoryState m_FileAgentInventoryState = FileAgentInventoryState.idle;

        public BunchOfCaps(Scene scene, UUID agentID, Caps caps)
        {
            m_Scene = scene;
            m_AgentID = agentID;
            m_HostCapsObj = caps;

            // create a model upload cost provider
            m_ModelCost = new ModelCost(scene);

            m_PrimScaleMin = m_ModelCost.PrimScaleMin;

            IConfigSource config = m_Scene.Config;
            if (config != null)
            {
                IConfig sconfig = config.Configs["Startup"];
                if (sconfig != null)
                {
                    m_levelUpload = sconfig.GetInt("LevelUpload", 0);
                }
                if (m_levelUpload == 0)
                {
                    IConfig pconfig = config.Configs["Permissions"];
                    if (pconfig != null)
                    {
                        m_levelUpload = pconfig.GetInt("LevelUpload", 0);
                    }
                }

                IConfig appearanceConfig = config.Configs["Appearance"];
                if (appearanceConfig != null)
                {
                    m_persistBakedTextures = appearanceConfig.GetBoolean("PersistBakedTextures", m_persistBakedTextures);
                }
                // economy for model upload
                IConfig EconomyConfig = config.Configs["Economy"];
                if (EconomyConfig != null)
                {
                    m_ModelCost.Econfig(EconomyConfig);

                    m_enableModelUploadTextureToInventory = EconomyConfig.GetBoolean("MeshModelAllowTextureToInventory", m_enableModelUploadTextureToInventory);

                    m_RestrictFreeTestUploadPerms = EconomyConfig.GetBoolean("m_RestrictFreeTestUploadPerms", m_RestrictFreeTestUploadPerms);
                    m_enableFreeTestUpload = EconomyConfig.GetBoolean("AllowFreeTestUpload", m_enableFreeTestUpload);
                    m_ForceFreeTestUpload = EconomyConfig.GetBoolean("ForceFreeTestUpload", m_ForceFreeTestUpload);
                    string testcreator = EconomyConfig.GetString("TestAssetsCreatorID", "");
                    if (testcreator != "")
                    {
                        UUID id;
                        UUID.TryParse(testcreator, out id);
                        if (id != null)
                            m_testAssetsCreatorID = id;
                    }
                }

                IConfig CapsConfig = config.Configs["ClientStack.LindenCaps"];
                if (CapsConfig != null)
                {
                    string homeLocationUrl = CapsConfig.GetString("Cap_HomeLocation", "localhost");
                    if(homeLocationUrl == String.Empty)
                        m_AllowCapHomeLocation = false;

                    string GroupMemberDataUrl = CapsConfig.GetString("Cap_GroupMemberData", "localhost");
                    if(GroupMemberDataUrl == String.Empty)
                        m_AllowCapGroupMemberData = false;
                }
            }

            m_assetService = m_Scene.AssetService;
            m_regionName = m_Scene.RegionInfo.RegionName;
            m_UserManager = m_Scene.RequestModuleInterface<IUserManagement>();
            m_userAccountService = m_Scene.RequestModuleInterface<IUserAccountService>();
            m_moneyModule = m_Scene.RequestModuleInterface<IMoneyModule>();
            if (m_UserManager == null)
                m_log.Error("[CAPS]: GetDisplayNames disabled because user management component not found");

            UserAccount account = m_userAccountService.GetUserAccount(m_Scene.RegionInfo.ScopeID, m_AgentID);
            if (account == null) // Hypergrid?
                m_scopeID = m_Scene.RegionInfo.ScopeID;
            else
                m_scopeID = account.ScopeID;

            AddNewInventoryItem = m_Scene.AddUploadedInventoryItem;
            ItemUpdatedCall = m_Scene.CapsUpdateItemAsset;
            TaskScriptUpdatedCall = m_Scene.CapsUpdateTaskInventoryScriptAsset;
            GetClient = m_Scene.SceneGraph.GetControllingClient;

            RegisterHandlers();

            m_FileAgentInventoryState = FileAgentInventoryState.idle;
        }

        public string GetNewCapPath()
        {
            return  "/" + UUID.Random();
        }

        /// <summary>
        /// Register a bunch of CAPS http service handlers
        /// </summary>
        public void RegisterHandlers()
        {
            // this path is also defined elsewhere so keeping it
            string seedcapsBase = "/CAPS/" + m_HostCapsObj.CapsObjectPath + "0000";

            m_HostCapsObj.RegisterSimpleHandler("SEED", new SimpleStreamHandler(seedcapsBase, SeedCapRequest));
            // m_log.DebugFormat(
            //     "[CAPS]: Registered seed capability {0} for {1}", seedcapsBase, m_HostCapsObj.AgentID);

            RegisterRegionServiceHandlers();
            RegisterInventoryServiceHandlers();
            RegisterOtherHandlers();
        }

        public void RegisterRegionServiceHandlers()
        {
            try
            {
                m_HostCapsObj.RegisterSimpleHandler("GetObjectPhysicsData",
                    new SimpleOSDMapHandler("POST", GetNewCapPath(), GetObjectPhysicsData));

                m_HostCapsObj.RegisterSimpleHandler("GetObjectCost",
                    new SimpleOSDMapHandler("POST", GetNewCapPath(), GetObjectCost));

                m_HostCapsObj.RegisterSimpleHandler("ResourceCostSelected",
                    new SimpleOSDMapHandler("POST", GetNewCapPath(), ResourceCostSelected));
 
                if(m_AllowCapHomeLocation)
                {
                    m_HostCapsObj.RegisterSimpleHandler("HomeLocation",
                        new SimpleStreamHandler(GetNewCapPath(), HomeLocation));
                }

                if (m_AllowCapGroupMemberData)
                {
                    m_HostCapsObj.RegisterSimpleHandler("GroupMemberData",
                        new SimpleStreamHandler(GetNewCapPath(), GroupMemberData));
                }

            }
            catch (Exception e)
            {
                m_log.Error("[CAPS]: " + e.ToString());
            }
        }

        public void RegisterInventoryServiceHandlers()
        {
            try
            {
                m_HostCapsObj.RegisterHandler("NewFileAgentInventory",
                    new LLSDStreamhandler<LLSDAssetUploadRequest, LLSDAssetUploadResponse>(
                        "POST", GetNewCapPath(), NewAgentInventoryRequest, "NewFileAgentInventory", null));

                SimpleOSDMapHandler oreq;
                if (ItemUpdatedCall != null)
                {
                    // first sets the http handler, others only register the cap, using it
                    oreq = new SimpleOSDMapHandler("POST", GetNewCapPath(), UpdateNotecardItemAsset);
                    m_HostCapsObj.RegisterSimpleHandler("UpdateNotecardAgentInventory", oreq, true);
                    m_HostCapsObj.RegisterSimpleHandler("UpdateNotecardTaskInventory", oreq, false); // a object inv

                    oreq = new SimpleOSDMapHandler("POST", GetNewCapPath(), UpdateAnimSetItemAsset);
                    m_HostCapsObj.RegisterSimpleHandler("UpdateAnimSetAgentInventory", oreq, true);
                    //m_HostCapsObj.RegisterSimpleHandler("UpdateAnimSetTaskInventory", oreq, false);

                    oreq = new SimpleOSDMapHandler("POST", GetNewCapPath(), UpdateScriptItemAsset);
                    m_HostCapsObj.RegisterSimpleHandler("UpdateScriptAgent", oreq, true);
                    m_HostCapsObj.RegisterSimpleHandler("UpdateScriptAgentInventory", oreq, false); //legacy

                    oreq = new SimpleOSDMapHandler("POST", GetNewCapPath(), UpdateSettingsItemAsset);
                    m_HostCapsObj.RegisterSimpleHandler("UpdateSettingsAgentInventory", oreq, true);
                    m_HostCapsObj.RegisterSimpleHandler("UpdateSettingsTaskInventory", oreq, false); // a object inv

                    oreq = new SimpleOSDMapHandler("POST", GetNewCapPath(), UpdateGestureItemAsset);
                    m_HostCapsObj.RegisterSimpleHandler("UpdateGestureAgentInventory", oreq, true);
                    m_HostCapsObj.RegisterSimpleHandler("UpdateGestureTaskInventory", oreq, false);
                }

                if (TaskScriptUpdatedCall != null)
                {
                    oreq = new SimpleOSDMapHandler("POST", GetNewCapPath(), UpdateScriptTaskInventory);
                    m_HostCapsObj.RegisterSimpleHandler("UpdateScriptTask", oreq, true);
                    m_HostCapsObj.RegisterSimpleHandler("UpdateScriptTaskInventory", oreq, true); //legacy
                }

                m_HostCapsObj.RegisterSimpleHandler("UpdateAgentInformation",
                    new SimpleStreamHandler(GetNewCapPath(), UpdateAgentInformation));

                m_HostCapsObj.RegisterSimpleHandler("CopyInventoryFromNotecard",
                    new SimpleOSDMapHandler("POST", GetNewCapPath(), CopyInventoryFromNotecard));

                m_HostCapsObj.RegisterSimpleHandler("CreateInventoryCategory",
                    new SimpleStreamHandler(GetNewCapPath(), CreateInventoryCategory));
            }
            catch (Exception e)
            {
                m_log.Error("[CAPS]: " + e.ToString());
            }
        }

        public void RegisterOtherHandlers()
        {
            try
            {
                if (m_UserManager != null)
                {
                    m_HostCapsObj.RegisterSimpleHandler("GetDisplayNames",
                        new SimpleStreamHandler(GetNewCapPath(), GetDisplayNames));
                }
            }
            catch (Exception e)
            {
                m_log.Error("[CAPS]: " + e.ToString());
            }
        }
        /// <summary>
        /// Construct a client response detailing all the capabilities this server can provide.
        /// </summary>
        /// <param name="request"></param>
        /// <param name="path"></param>
        /// <param name="param"></param>
        /// <param name="httpRequest">HTTP request header object</param>
        /// <param name="httpResponse">HTTP response header object</param>
        /// <returns></returns>
        public void SeedCapRequest(IOSHttpRequest httpRequest, IOSHttpResponse httpResponse)
        {
            UUID agentID = m_HostCapsObj.AgentID;
            m_log.DebugFormat(
                "[CAPS]: Received SEED caps request in {0} for agent {1}", m_regionName, agentID);

            if(httpRequest.HttpMethod != "POST" || httpRequest.ContentType != "application/llsd+xml")
            {
                httpResponse.StatusCode = (int)HttpStatusCode.NotFound;
                return;
            }

            if (!m_HostCapsObj.WaitForActivation())
            {
                httpResponse.StatusCode = (int)HttpStatusCode.ServiceUnavailable;
                httpResponse.AddHeader("Retry-After", "30");
                return;
            }

            if (!m_Scene.CheckClient(agentID, httpRequest.RemoteIPEndPoint))
            {
                m_log.WarnFormat(
                    "[CAPS]: Unauthorized CAPS client {0} from {1}",
                    agentID, httpRequest.RemoteIPEndPoint);
                httpResponse.StatusCode = (int)HttpStatusCode.Forbidden;
                return;
            }

            OSDArray capsRequested;
            try
            {
                capsRequested = (OSDArray)OSDParser.DeserializeLLSDXml(httpRequest.InputStream);
            }
            catch
            {
                httpResponse.StatusCode = (int)HttpStatusCode.BadRequest;
                return;
            }

            List<string> validCaps = new List<string>();

            foreach (OSD c in capsRequested)
            {
                string cstr = c.AsString();
                if (cstr.Equals("ObjectAnimation"))
                    m_HostCapsObj.Flags |= Caps.CapsFlags.ObjectAnim;
                else if (cstr.Equals("EnvironmentSettings"))
                    m_HostCapsObj.Flags |= Caps.CapsFlags.WLEnv;
                else if (cstr.Equals("ExtEnvironment"))
                    m_HostCapsObj.Flags |= Caps.CapsFlags.AdvEnv;
                validCaps.Add(cstr);
            }

            string result = LLSDHelpers.SerialiseLLSDReply(m_HostCapsObj.GetCapsDetails(true, validCaps));
            httpResponse.RawBuffer = Util.UTF8NBGetbytes(result);
            httpResponse.StatusCode = (int)HttpStatusCode.OK;
            //m_log.DebugFormat("[CAPS] CapsRequest {0}", result);

            m_HostCapsObj.Flags |= Caps.CapsFlags.SentSeeds;
        }

        /// <summary>
        ///
        /// </summary>
        /// <param name="llsdRequest"></param>
        /// <returns></returns>
        public LLSDAssetUploadResponse NewAgentInventoryRequest(LLSDAssetUploadRequest llsdRequest)
        {
            //m_log.Debug("[CAPS]: NewAgentInventoryRequest Request is: " + llsdRequest.ToString());
            //m_log.Debug("asset upload request via CAPS" + llsdRequest.inventory_type + " , " + llsdRequest.asset_type);

            // start by getting the client
            IClientAPI client = null;
            m_Scene.TryGetClient(m_HostCapsObj.AgentID, out client);

            // check current state so we only have one service at a time
            lock (m_ModelCost)
            {
                switch (m_FileAgentInventoryState)
                {
                    case FileAgentInventoryState.processRequest:
                    case FileAgentInventoryState.processUpload:
                        LLSDAssetUploadError resperror = new LLSDAssetUploadError();
                        resperror.message = "Uploader busy processing previous request";
                        resperror.identifier = UUID.Zero;

                        LLSDAssetUploadResponse errorResponse = new LLSDAssetUploadResponse();
                        errorResponse.uploader = "";
                        errorResponse.state = "error";
                        errorResponse.error = resperror;
                        return errorResponse;
                    case FileAgentInventoryState.waitUpload:
                        // todo stop current uploader server
                        break;
                    case FileAgentInventoryState.idle:
                    default:
                        break;
                }

                m_FileAgentInventoryState = FileAgentInventoryState.processRequest;
            }

            int cost = 0;
            int nreqtextures = 0;
            int nreqmeshs= 0;
            int nreqinstances = 0;
            bool IsAtestUpload = false;
            int[] meshesSides = null;

            string assetName = llsdRequest.name;

            LLSDAssetUploadResponseData meshcostdata = new LLSDAssetUploadResponseData();

            if (llsdRequest.asset_type == "texture" ||
                llsdRequest.asset_type == "animation" ||
                llsdRequest.asset_type == "animatn" ||    // this is the asset name actually used by viewers
                llsdRequest.asset_type == "mesh" ||
                llsdRequest.asset_type == "sound")
            {
                ScenePresence avatar = null;
                m_Scene.TryGetScenePresence(m_HostCapsObj.AgentID, out avatar);

                // check user level
                if (avatar != null)
                {
                    if (avatar.GodController.UserLevel < m_levelUpload)
                    {
                        LLSDAssetUploadError resperror = new LLSDAssetUploadError();
                        resperror.message = "Insufficient permissions to upload";
                        resperror.identifier = UUID.Zero;

                        LLSDAssetUploadResponse errorResponse = new LLSDAssetUploadResponse();
                        errorResponse.uploader = "";
                        errorResponse.state = "error";
                        errorResponse.error = resperror;
                        lock (m_ModelCost)
                            m_FileAgentInventoryState = FileAgentInventoryState.idle;
                        return errorResponse;
                    }
                }

                // check test upload and funds
                if (client != null)
                {
                    IMoneyModule mm = m_Scene.RequestModuleInterface<IMoneyModule>();

                    int baseCost = 0;
                    if (mm != null)
                        baseCost = mm.UploadCharge;

                    string warning = String.Empty;

                    if (llsdRequest.asset_type == "mesh")
                    {
                        string error;
                        int modelcost;

                        if (!m_ModelCost.MeshModelCost(llsdRequest.asset_resources, baseCost, out modelcost,
                            meshcostdata, out error, ref warning, out meshesSides))
                        {
                            LLSDAssetUploadError resperror = new LLSDAssetUploadError();
                            resperror.message = error;
                            resperror.identifier = UUID.Zero;

                            LLSDAssetUploadResponse errorResponse = new LLSDAssetUploadResponse();
                            errorResponse.uploader = "";
                            errorResponse.state = "error";
                            errorResponse.error = resperror;

                            lock (m_ModelCost)
                                m_FileAgentInventoryState = FileAgentInventoryState.idle;
                            return errorResponse;
                        }
                        cost = modelcost;
                    }
                    else
                    {
                        cost = baseCost;
                    }

                    if (cost > 0 && mm != null)
                    {
                        // check for test upload

                        if (m_ForceFreeTestUpload) // all are test
                        {
                            if (!(assetName.Length > 5 && assetName.StartsWith("TEST-"))) // has normal name lets change it
                                assetName = "TEST-" + assetName;

                            IsAtestUpload = true;
                        }

                        else if (m_enableFreeTestUpload) // only if prefixed with "TEST-"
                        {

                            IsAtestUpload = (assetName.Length > 5 && assetName.StartsWith("TEST-"));
                        }

                        if(IsAtestUpload) // let user know, still showing cost estimation
                            warning += "Upload will have no cost, for testing purposes only. Other uses are prohibited. Items will be local to region only, Inventory entry will be lost on logout";

                        // check funds
                        else
                        {
                            if (!mm.UploadCovered(client.AgentId, (int)cost))
                            {
                                LLSDAssetUploadError resperror = new LLSDAssetUploadError();
                                resperror.message = "Insuficient funds";
                                resperror.identifier = UUID.Zero;

                                LLSDAssetUploadResponse errorResponse = new LLSDAssetUploadResponse();
                                errorResponse.uploader = "";
                                errorResponse.state = "error";
                                errorResponse.error = resperror;
                                lock (m_ModelCost)
                                    m_FileAgentInventoryState = FileAgentInventoryState.idle;
                                return errorResponse;
                            }
                        }
                    }
                    else if (m_enableFreeTestUpload) // only if prefixed with "TEST-"
                    {
                        IsAtestUpload = (assetName.Length > 5 && assetName.StartsWith("TEST-"));
                        if(IsAtestUpload)
                            warning += "Upload for testing purposes only. Items will be local to region only, Inventory entry will be lost on logout";
                    }

                    if (client != null && warning != String.Empty)
                        client.SendAgentAlertMessage(warning, true);
                }
            }

            string assetDes = llsdRequest.description;
            UUID newAsset = UUID.Random();
            UUID newInvItem = UUID.Random();
            UUID parentFolder = llsdRequest.folder_id;
            string uploaderPath = GetNewCapPath();
            UUID texturesFolder = UUID.Zero;

            if(!IsAtestUpload && m_enableModelUploadTextureToInventory)
                texturesFolder = llsdRequest.texture_folder_id;

            AssetUploader uploader =
                new AssetUploader(assetName, assetDes, newAsset, newInvItem, parentFolder, llsdRequest.inventory_type,
                        llsdRequest.asset_type, uploaderPath, m_HostCapsObj.HttpListener, m_dumpAssetsToFile, cost,
                        texturesFolder, nreqtextures, nreqmeshs, nreqinstances, IsAtestUpload,
                        llsdRequest.next_owner_mask, llsdRequest.group_mask, llsdRequest.everyone_mask, meshesSides);

            m_HostCapsObj.HttpListener.AddStreamHandler(
                new BinaryStreamHandler(
                    "POST",
                    uploaderPath,
                    uploader.uploaderCaps,
                    "NewAgentInventoryRequest",
                    m_HostCapsObj.AgentID.ToString()));

            string protocol = "http://";
            if (m_HostCapsObj.SSLCaps)
                protocol = "https://";

            string uploaderURL = protocol + m_HostCapsObj.HostName + ":" + m_HostCapsObj.Port.ToString() + uploaderPath;

            LLSDAssetUploadResponse uploadResponse = new LLSDAssetUploadResponse();
            uploadResponse.uploader = uploaderURL;
            uploadResponse.state = "upload";
            uploadResponse.upload_price = (int)cost;

            if (llsdRequest.asset_type == "mesh")
            {
                uploadResponse.data = meshcostdata;
            }

            uploader.OnUpLoad += UploadCompleteHandler;

            lock (m_ModelCost)
                m_FileAgentInventoryState = FileAgentInventoryState.waitUpload;

            return uploadResponse;
        }

        /// <summary>
        /// Convert raw uploaded data into the appropriate asset and item.
        /// </summary>
        /// <param name="assetID"></param>
        /// <param name="inventoryItem"></param>
        /// <param name="data"></param>
        public void UploadCompleteHandler(string assetName, string assetDescription, UUID assetID,
                                          UUID inventoryItem, UUID parentFolder, byte[] data, string inventoryType,
                                          string assetType, int cost,
                                          UUID texturesFolder, int nreqtextures, int nreqmeshs, int nreqinstances,
                                          bool IsAtestUpload, ref string error,
                                          ref int nextOwnerMask, ref int groupMask, ref int everyoneMask, int[] meshesSides)
        {
            lock (m_ModelCost)
                m_FileAgentInventoryState = FileAgentInventoryState.processUpload;

            m_log.DebugFormat(
                "[BUNCH OF CAPS]: Uploaded asset {0} for inventory item {1}, inv type {2}, asset type {3}",
                assetID, inventoryItem, inventoryType, assetType);

            sbyte assType = 0;
            sbyte inType = 0;

            IClientAPI client = null;

            UUID owner_id = m_HostCapsObj.AgentID;
            UUID creatorID;

            bool istest = IsAtestUpload && m_enableFreeTestUpload;

            bool restrictPerms = m_RestrictFreeTestUploadPerms && istest;

            if (istest && m_testAssetsCreatorID != UUID.Zero)
                creatorID = m_testAssetsCreatorID;
            else
                creatorID = owner_id;

            string creatorIDstr = creatorID.ToString();

            IMoneyModule mm = m_Scene.RequestModuleInterface<IMoneyModule>();
            if (mm != null)
            {
                // make sure client still has enougth credit
                if (!mm.UploadCovered(m_HostCapsObj.AgentID, (int)cost))
                {
                    error = "Insufficient funds.";
                    return;
                }
            }

            // strings to types
            if (inventoryType == "sound")
            {
                inType = (sbyte)InventoryType.Sound;
                assType = (sbyte)AssetType.Sound;
            }
            else if (inventoryType == "snapshot")
            {
                inType = (sbyte)InventoryType.Snapshot;
            }
            else if (inventoryType == "animation")
            {
                inType = (sbyte)InventoryType.Animation;
                assType = (sbyte)AssetType.Animation;
            }
            else if (inventoryType == "animset")
            {
                inType = (sbyte)CustomInventoryType.AnimationSet;
                assType = (sbyte)CustomAssetType.AnimationSet;
                m_log.Debug("got animset upload request");
            }
            else if (inventoryType == "wearable")
            {
                inType = (sbyte)InventoryType.Wearable;
                switch (assetType)
                {
                    case "bodypart":
                        assType = (sbyte)AssetType.Bodypart;
                        break;
                    case "clothing":
                        assType = (sbyte)AssetType.Clothing;
                        break;
                }
            }
            else if (inventoryType == "object")
            {
                if (assetType == "mesh") // this code for now is for mesh models uploads only
                {
                    inType = (sbyte)InventoryType.Object;
                    assType = (sbyte)AssetType.Object;

                    List<Vector3> positions = new List<Vector3>();
                    List<Quaternion> rotations = new List<Quaternion>();
                    OSDMap request = (OSDMap)OSDParser.DeserializeLLSDXml(data);

                    // compare and get updated information
/* does nothing still we do need something to avoid special viewer to upload something diferent from the cost estimation
                    bool mismatchError = true;

                    while (mismatchError)
                    {
                        mismatchError = false;
                    }

                    if (mismatchError)
                    {
                        error = "Upload and fee estimation information don't match";
                        lock (m_ModelCost)
                            m_FileAgentInventoryState = FileAgentInventoryState.idle;

                        return;
                    }
*/
                    OSDArray instance_list = (OSDArray)request["instance_list"];
                    OSDArray mesh_list = (OSDArray)request["mesh_list"];
                    OSDArray texture_list = (OSDArray)request["texture_list"];
                    SceneObjectGroup grp = null;

                    // create and store texture assets
                    bool doTextInv = (!istest && m_enableModelUploadTextureToInventory &&
                                    texturesFolder != UUID.Zero);


                    List<UUID> textures = new List<UUID>();


//                    if (doTextInv)
                        m_Scene.TryGetClient(m_HostCapsObj.AgentID, out client);

                    if(client == null) // don't put textures in inventory if there is no client
                        doTextInv = false;

                    for (int i = 0; i < texture_list.Count; i++)
                    {
                        AssetBase textureAsset = new AssetBase(UUID.Random(), assetName, (sbyte)AssetType.Texture, creatorIDstr);
                        textureAsset.Data = texture_list[i].AsBinary();
                        if (istest)
                            textureAsset.Local = true;
                        m_assetService.Store(textureAsset);
                        textures.Add(textureAsset.FullID);

                        if (doTextInv)
                        {
                            string name = assetName;
                            if (name.Length > 25)
                                name = name.Substring(0, 24);
                            name += "_Texture#" + i.ToString();
                            InventoryItemBase texitem = new InventoryItemBase();
                            texitem.Owner = m_HostCapsObj.AgentID;
                            texitem.CreatorId = creatorIDstr;
                            texitem.CreatorData = String.Empty;
                            texitem.ID = UUID.Random();
                            texitem.AssetID = textureAsset.FullID;
                            texitem.Description = "mesh model texture";
                            texitem.Name = name;
                            texitem.AssetType = (int)AssetType.Texture;
                            texitem.InvType = (int)InventoryType.Texture;
                            texitem.Folder = texturesFolder;

                            texitem.CurrentPermissions
                                = (uint)(PermissionMask.Move | PermissionMask.Copy | PermissionMask.Modify | PermissionMask.Transfer | PermissionMask.Export);

                            texitem.BasePermissions = (uint)PermissionMask.All | (uint)PermissionMask.Export;
                            texitem.EveryOnePermissions = 0;
                            texitem.NextPermissions = (uint)PermissionMask.All;
                            texitem.CreationDate = Util.UnixTimeSinceEpoch();

                            m_Scene.AddInventoryItem(client, texitem);
                            texitem = null;
                        }
                    }

                    // create and store meshs assets
                    List<UUID> meshAssets = new List<UUID>();
                    List<bool> meshAvatarSkeletons = new List<bool>();
                    List<bool> meshAvatarColliders = new List<bool>();

                    bool curAvSkeleton;
                    bool curAvCollider;
                    for (int i = 0; i < mesh_list.Count; i++)
                    {
                        curAvSkeleton = false;
                        curAvCollider = false;

                        // we do need to parse the mesh now
                        OSD osd = OSDParser.DeserializeLLSDBinary(mesh_list[i]);
                        if (osd is OSDMap)
                        {
                            OSDMap mosd = (OSDMap)osd;
                            if (mosd.ContainsKey("skeleton"))
                            {
                                OSDMap skeleton = (OSDMap)mosd["skeleton"];
                                int sksize = skeleton["size"].AsInteger();
                                if (sksize > 0)
                                    curAvSkeleton = true;
                            }
                        }

                        AssetBase meshAsset = new AssetBase(UUID.Random(), assetName, (sbyte)AssetType.Mesh, creatorIDstr);
                        meshAsset.Data = mesh_list[i].AsBinary();
                        if (istest)
                            meshAsset.Local = true;
                        m_assetService.Store(meshAsset);
                        meshAssets.Add(meshAsset.FullID);
                        meshAvatarSkeletons.Add(curAvSkeleton);
                        meshAvatarColliders.Add(curAvCollider);

                        // test code
                        if (curAvSkeleton && client != null)
                        {
                            string name = assetName;
                            if (name.Length > 25)
                                name = name.Substring(0, 24);
                            name += "_Mesh#" + i.ToString();
                            InventoryItemBase meshitem = new InventoryItemBase();
                            meshitem.Owner = m_HostCapsObj.AgentID;
                            meshitem.CreatorId = creatorIDstr;
                            meshitem.CreatorData = String.Empty;
                            meshitem.ID = UUID.Random();
                            meshitem.AssetID = meshAsset.FullID;
                            meshitem.Description = "mesh ";
                            meshitem.Name = name;
                            meshitem.AssetType = (int)AssetType.Mesh;
                            meshitem.InvType = (int)InventoryType.Mesh;
                            //                            meshitem.Folder = UUID.Zero; // send to default

                            meshitem.Folder = parentFolder; // dont let it go to folder Meshes that viewers dont show

                            // If we set PermissionMask.All then when we rez the item the next permissions will replace the current
                            // (owner) permissions.  This becomes a problem if next permissions are changed.
                            meshitem.CurrentPermissions
                                = (uint)(PermissionMask.Move | PermissionMask.Copy | PermissionMask.Modify | PermissionMask.Transfer);

                            meshitem.BasePermissions = (uint)PermissionMask.All;
                            meshitem.EveryOnePermissions = 0;
                            meshitem.NextPermissions = (uint)PermissionMask.All;
                            meshitem.CreationDate = Util.UnixTimeSinceEpoch();

                            m_Scene.AddInventoryItem(client, meshitem);
                            meshitem = null;
                        }
                    }

                    int skipedMeshs = 0;
                    // build prims from instances
                    for (int i = 0; i < instance_list.Count; i++)
                    {
                        OSDMap inner_instance_list = (OSDMap)instance_list[i];

                        // skip prims that are 2 small
                        Vector3 scale = inner_instance_list["scale"].AsVector3();

                        if (scale.X < m_PrimScaleMin || scale.Y < m_PrimScaleMin || scale.Z < m_PrimScaleMin)
                        {
                            skipedMeshs++;
                            continue;
                        }

                        OSDArray face_list = (OSDArray)inner_instance_list["face_list"];

                        PrimitiveBaseShape pbs = null;
                        if (inner_instance_list.ContainsKey("mesh")) // seems to happen always but ...
                        {
                            int meshindx = inner_instance_list["mesh"].AsInteger();
                            if (meshAssets.Count > meshindx)
                            {
                                if(meshesSides != null && meshesSides.Length > meshindx)
                                    pbs = PrimitiveBaseShape.CreateMesh(meshesSides[i], meshAssets[meshindx]);
                                else
                                    pbs = PrimitiveBaseShape.CreateMesh(face_list.Count, meshAssets[meshindx]);
                            }
                        }
                        if(pbs == null) // fallback
                            pbs = PrimitiveBaseShape.CreateBox();

                        Primitive.TextureEntry textureEntry
                            = new Primitive.TextureEntry(Primitive.TextureEntry.WHITE_TEXTURE);

                        for (uint face = 0; face < face_list.Count; face++)
                        {
                            OSDMap faceMap = (OSDMap)face_list[(int)face];

                            Primitive.TextureEntryFace f = textureEntry.CreateFace(face); //clone the default
                            if (faceMap.ContainsKey("fullbright"))
                                f.Fullbright = faceMap["fullbright"].AsBoolean();
                            if (faceMap.ContainsKey("diffuse_color"))
                                f.RGBA = faceMap["diffuse_color"].AsColor4();

                            int textureNum = faceMap["image"].AsInteger();
                            float imagerot = faceMap["imagerot"].AsInteger();
                            float offsets = (float)faceMap["offsets"].AsReal();
                            float offsett = (float)faceMap["offsett"].AsReal();
                            float scales = (float)faceMap["scales"].AsReal();
                            float scalet = (float)faceMap["scalet"].AsReal();

                            if (imagerot != 0)
                                f.Rotation = imagerot;

                            if (offsets != 0)
                                f.OffsetU = offsets;

                            if (offsett != 0)
                                f.OffsetV = offsett;

                            if (scales != 0)
                                f.RepeatU = scales;

                            if (scalet != 0)
                                f.RepeatV = scalet;

                            if (textures.Count > textureNum)
                                f.TextureID = textures[textureNum];
 
                            textureEntry.FaceTextures[face] = f;
                        }

                        if(face_list.Count > 0)
                        {
                            int last = face_list.Count - 1;
                            // we do need a better te compacting code
                            textureEntry.DefaultTexture = textureEntry.FaceTextures[last];
                            textureEntry.FaceTextures[last] = null;
                            pbs.TextureEntry = textureEntry.GetBytes(last);
                        }

                        Vector3 position = inner_instance_list["position"].AsVector3();
                        Quaternion rotation = inner_instance_list["rotation"].AsQuaternion();

                        byte physicsShapeType = (byte)PhysShapeType.convex; // default is simple convex
                        if (inner_instance_list.ContainsKey("physics_shape_type"))
                            physicsShapeType = (byte)inner_instance_list["physics_shape_type"].AsInteger();
                        byte material = (byte)Material.Wood;
                        if (inner_instance_list.ContainsKey("material"))
                            material = (byte)inner_instance_list["material"].AsInteger();

                        SceneObjectPart prim
                            = new SceneObjectPart(owner_id, pbs, position, Quaternion.Identity, Vector3.Zero);

                        prim.Scale = scale;
                        rotations.Add(rotation);
                        positions.Add(position);
                        prim.UUID = UUID.Random();
                        prim.CreatorID = creatorID;
                        prim.OwnerID = owner_id;
                        prim.GroupID = UUID.Zero;
                        prim.LastOwnerID = creatorID;
                        prim.RezzerID = creatorID;
                        prim.CreationDate = Util.UnixTimeSinceEpoch();

                        if (grp == null)
                            prim.Name = assetName;
                        else
                            prim.Name = assetName + "#" + i.ToString();

                        prim.EveryoneMask = 0;
                        prim.GroupMask = 0;

                        if (restrictPerms)
                        {
                            prim.BaseMask = (uint)(PermissionMask.Move | PermissionMask.Modify);
                            prim.OwnerMask = (uint)(PermissionMask.Move | PermissionMask.Modify);
                            prim.NextOwnerMask = 0;
                        }
                        else
                        {
                            prim.BaseMask = (uint)PermissionMask.All | (uint)PermissionMask.Export;
                            prim.OwnerMask = (uint)PermissionMask.All | (uint)PermissionMask.Export;
                            prim.GroupMask = prim.BaseMask & (uint)groupMask;
                            prim.EveryoneMask = prim.BaseMask & (uint)everyoneMask;
                            prim.NextOwnerMask = prim.BaseMask & (uint)nextOwnerMask;
                            // If the viewer gives us bogus permissions, revert to the SL
                            // default of transfer only.
                            if ((prim.NextOwnerMask & (uint)PermissionMask.All) == 0)
                                prim.NextOwnerMask = (uint)PermissionMask.Transfer;
                        }

                        if(istest)
                            prim.Description = "For testing only. Other uses are prohibited";
                        else
                            prim.Description = "";

                        prim.Material = material;
                        prim.PhysicsShapeType = physicsShapeType;

//                    prim.BaseMask = (uint)base_mask;
//                    prim.EveryoneMask = (uint)everyone_mask;
//                    prim.GroupMask = (uint)group_mask;
//                    prim.NextOwnerMask = (uint)next_owner_mask;
//                    prim.OwnerMask = (uint)owner_mask;

                        if (grp == null)
                        {
                            grp = new SceneObjectGroup(prim);
                            grp.LastOwnerID = creatorID;
                            grp.RezzerID = creatorID;
                        }
                        else
                            grp.AddPart(prim);
                    }

                    Vector3 rootPos = positions[0];

                    if (grp.Parts.Length > 1)
                    {
                        // Fix first link number
                        grp.RootPart.LinkNum++;

                        Quaternion rootRotConj = Quaternion.Conjugate(rotations[0]);
                        Quaternion tmprot;
                        Vector3 offset;

                        // fix children rotations and positions
                        for (int i = 1; i < rotations.Count; i++)
                        {
                            tmprot = rotations[i];
                            tmprot = rootRotConj * tmprot;

                            grp.Parts[i].RotationOffset = tmprot;

                            offset = positions[i] - rootPos;

                            offset *= rootRotConj;
                            grp.Parts[i].OffsetPosition = offset;
                        }

                        grp.AbsolutePosition = rootPos;
                        grp.UpdateGroupRotationR(rotations[0]);
                    }
                    else
                    {
                        grp.AbsolutePosition = rootPos;
                        grp.UpdateGroupRotationR(rotations[0]);
                    }

                    data = ASCIIEncoding.ASCII.GetBytes(SceneObjectSerializer.ToOriginalXmlFormat(grp));
                }

                else // not a mesh model
                {
                    m_log.ErrorFormat("[CAPS Asset Upload] got unsuported assetType for object upload");
                    return;
                }
            }

            AssetBase asset;
            asset = new AssetBase(assetID, assetName, assType, creatorIDstr);
            asset.Data = data;
            if (istest)
                asset.Local = true;
            if (AddNewAsset != null)
                AddNewAsset(asset);
            else if (m_assetService != null)
                m_assetService.Store(asset);

            InventoryItemBase item = new InventoryItemBase();
            item.Owner = m_HostCapsObj.AgentID;
            item.CreatorId = creatorIDstr;
            item.CreatorData = String.Empty;
            item.ID = inventoryItem;
            item.AssetID = asset.FullID;
            if (istest)
            {
                item.Description = "For testing only. Other uses are prohibited";
                item.Flags = (uint) (InventoryItemFlags.SharedSingleReference);
            }
            else
                item.Description = assetDescription;
            item.Name = assetName;
            item.AssetType = assType;
            item.InvType = inType;
            item.Folder = parentFolder;

            // If we set PermissionMask.All then when we rez the item the next permissions will replace the current
            // (owner) permissions.  This becomes a problem if next permissions are changed.

            if (inType == (sbyte)CustomInventoryType.AnimationSet)
            {
                AnimationSet.setCreateItemPermitions(item);
            }

            else if (restrictPerms)
            {
                item.BasePermissions = (uint)(PermissionMask.Move | PermissionMask.Modify);
                item.CurrentPermissions = (uint)(PermissionMask.Move | PermissionMask.Modify);
                item.GroupPermissions = 0;
                item.EveryOnePermissions = 0;
                item.NextPermissions = 0;
            }
            else
            {
                item.BasePermissions = (uint)PermissionMask.All | (uint)PermissionMask.Export;
                item.CurrentPermissions = (uint)PermissionMask.All | (uint)PermissionMask.Export;
                item.GroupPermissions = item.BasePermissions & (uint)groupMask;
                item.EveryOnePermissions = item.BasePermissions & (uint)everyoneMask;
                item.NextPermissions = item.BasePermissions & (uint)nextOwnerMask;
                if ((item.NextPermissions & (uint)PermissionMask.All) == 0)
                    item.NextPermissions = (uint)PermissionMask.Transfer;
            }

            item.CreationDate = Util.UnixTimeSinceEpoch();

            everyoneMask = (int)item.EveryOnePermissions;
            groupMask = (int)item.GroupPermissions;
            nextOwnerMask = (int)item.NextPermissions;

            m_Scene.TryGetClient(m_HostCapsObj.AgentID, out client);

            if (AddNewInventoryItem != null)
            {
                if (istest)
                {
                    m_Scene.AddInventoryItem(client, item);
/*
                    AddNewInventoryItem(m_HostCapsObj.AgentID, item, 0);
                    if (client != null)
                        client.SendAgentAlertMessage("Upload will have no cost, for personal test purposes only. Other uses are forbiden. Items may not work on a another region" , true);
 */
                }
                else
                {
                    AddNewInventoryItem(m_HostCapsObj.AgentID, item, (uint)cost);
//                    if (client != null)
//                    {
//                        // let users see anything..  i don't so far
//                        string str;
//                        if (cost > 0)
//                            // dont remember where is money unit name to put here
//                            str = "Upload complete. charged " + cost.ToString() + "$";
//                        else
//                            str = "Upload complete";
//                        client.SendAgentAlertMessage(str, true);
//                    }
                }
            }

            lock (m_ModelCost)
                m_FileAgentInventoryState = FileAgentInventoryState.idle;
        }

        public void CreateInventoryCategory(IOSHttpRequest httpRequest, IOSHttpResponse httpResponse)
        {
            if(httpRequest.HttpMethod != "POST")
            {
                httpResponse.StatusCode = (int)HttpStatusCode.NotFound;
                return;
            }
            if (m_Scene.InventoryService == null)
            {
                httpResponse.StatusCode = (int)HttpStatusCode.NotImplemented;
                return;
            }

            ScenePresence sp = m_Scene.GetScenePresence(m_AgentID);
            if (sp == null || sp.IsDeleted)
            {
                httpResponse.StatusCode = (int)HttpStatusCode.ServiceUnavailable;
                httpResponse.AddHeader("Retry-After", "60");
                return;
            }

            OSDMap req;
            OSD tmp;
            try
            {
                req = (OSDMap)OSDParser.DeserializeLLSDXml(httpRequest.InputStream);
            }
            catch
            {
                httpResponse.StatusCode = (int)HttpStatusCode.BadRequest;
                return;
            }

            try
            {
                while (true) // kinda goto
                {
                    if (!req.TryGetValue("folder_id", out tmp) || !(tmp is OSDUUID))
                        break;
                    UUID folderID = tmp.AsUUID();

                    if(folderID == UUID.Zero)
                        break;

                    if (!req.TryGetValue("parent_id", out tmp) || !(tmp is OSDUUID))
                        break;
                    UUID parentID = tmp.AsUUID();

                    if (!req.TryGetValue("name", out tmp) || !(tmp is OSDString))
                        break;
                    string folderName = tmp.AsString();

                    if(string.IsNullOrEmpty(folderName))
                        break;

                    if(folderName.Length > 63)
                        folderName = folderName.Substring(0, 63);

                    if (!req.TryGetValue("type", out tmp) || !(tmp is OSDInteger))
                        break;
                    int folderType = tmp.AsInteger();

                    InventoryFolderBase folder = new InventoryFolderBase(folderID, folderName, m_AgentID, (short)folderType, parentID, 1);
                    if (!m_Scene.InventoryService.AddFolder(folder))
                        break;

                    // costly double check plus possible service changes
                    folder = m_Scene.InventoryService.GetFolder(m_AgentID, folderID);
                    if (folder == null)
                        break;

                    StringBuilder sb = LLSDxmlEncode.Start();
                    LLSDxmlEncode.AddMap(sb);
                    LLSDxmlEncode.AddElem("folder_id", folder.ID, sb);
                    LLSDxmlEncode.AddElem("name", folder.Name, sb);
                    LLSDxmlEncode.AddElem("parent_id", folder.ParentID, sb);
                    LLSDxmlEncode.AddElem("type", folder.Type, sb);
                    LLSDxmlEncode.AddEndMap(sb);

                    httpResponse.RawBuffer = LLSDxmlEncode.EndToNBBytes(sb);
                    httpResponse.StatusCode = (int)HttpStatusCode.OK;
                    return;
                }
            }
            catch { }

            m_log.Debug("[CAPS]: CreateInventoryCategory failed to process request");
            httpResponse.StatusCode = (int)HttpStatusCode.BadRequest;
        }

        /// <summary>
        /// Called by the CopyInventoryFromNotecard caps handler.
        /// </summary>
        /// <param name="request"></param>
        /// <param name="path"></param>
        /// <param name="param"></param>

        public void CopyInventoryFromNotecard(IOSHttpRequest httpRequest, IOSHttpResponse httpResponse, OSDMap content)
        {
            InventoryItemBase copyItem = null;
            IClientAPI client = null;

            httpResponse.StatusCode = (int)HttpStatusCode.OK;

            try
            {
                UUID objectID = content["object-id"].AsUUID();
                UUID notecardID = content["notecard-id"].AsUUID();
                UUID folderID = content["folder-id"].AsUUID();
                UUID itemID = content["item-id"].AsUUID();

                //  m_log.InfoFormat("[CAPS]: CopyInventoryFromNotecard, FolderID:{0}, ItemID:{1}, NotecardID:{2}, ObjectID:{3}", folderID, itemID, notecardID, objectID);

                UUID noteAssetID = UUID.Zero;
                UUID agentID = m_HostCapsObj.AgentID;

                m_Scene.TryGetClient(agentID, out client);

                if (objectID != UUID.Zero)
                {
                    SceneObjectPart part = m_Scene.GetSceneObjectPart(objectID);
                    if(part == null)
                        throw new Exception("failed to find object with notecard item" + notecardID.ToString());

                    TaskInventoryItem taskItem = part.Inventory.GetInventoryItem(notecardID);
                    if (taskItem == null || taskItem.AssetID == UUID.Zero)
                        throw new Exception("Failed to find notecard item" + notecardID.ToString());

                    if (!m_Scene.Permissions.CanCopyObjectInventory(notecardID, objectID, agentID))
                        throw new Exception("No permission to copy notecard from object");

                    noteAssetID = taskItem.AssetID;
                }
                else
                {
                    // we may have the item around...
                    InventoryItemBase localitem = m_Scene.InventoryService.GetItem(agentID, itemID);
                    if (localitem != null)
                    {
                        string message;
                        copyItem = m_Scene.GiveInventoryItem(agentID, localitem.Owner, itemID, folderID, out message);
                        if (copyItem == null)
                            throw new Exception("Failed to find notecard item" + notecardID.ToString());

                        m_log.InfoFormat("[CAPS]: CopyInventoryFromNotecard, ItemID:{0}, FolderID:{1}", copyItem.ID, copyItem.Folder);
                        if (client != null)
                            client.SendBulkUpdateInventory(copyItem);
                        return;
                    }

                    if (notecardID != UUID.Zero)
                    {
                        InventoryItemBase noteItem = m_Scene.InventoryService.GetItem(agentID, notecardID);
                        if (noteItem == null || noteItem.AssetID == UUID.Zero)
                            throw new Exception("Failed to find notecard item" + notecardID.ToString());
                        noteAssetID = noteItem.AssetID;
                    }
                }

                AssetBase noteAsset = m_Scene.AssetService.Get(noteAssetID.ToString());
                if (noteAsset == null || noteAsset.Type != (sbyte)AssetType.Notecard)
                    throw new Exception("Failed to find the notecard asset" + notecardID.ToString());

                InventoryItemBase item = SLUtil.GetEmbeddedItem(noteAsset.Data, itemID);
                if(item == null)
                    throw new Exception("Failed to find the notecard item" + notecardID.ToString());

                if (!m_Scene.Permissions.CanTransferUserInventory(itemID, item.Owner, agentID))
                    throw new Exception("Notecard item permissions check fail" + notecardID.ToString());

                if (!m_Scene.Permissions.BypassPermissions())
                {
                    if ((item.CurrentPermissions & (uint)PermissionMask.Transfer) == 0)
                        throw new Exception("Notecard item permissions check fail" + notecardID.ToString());
                }

                // check if we do have the item asset
                noteAsset = m_Scene.AssetService.Get(item.AssetID.ToString());
                if (noteAsset == null)
                    throw new Exception("Failed to find the notecard " + notecardID.ToString() +" item asset");

                // find where to put it
                InventoryFolderBase folder = null;
                if (folderID != UUID.Zero)
                    folder = m_Scene.InventoryService.GetFolder(agentID, folderID);

                if (folder == null && Enum.IsDefined(typeof(FolderType), (sbyte)item.AssetType))
                    folder = m_Scene.InventoryService.GetFolderForType(agentID, (FolderType)item.AssetType);

                if (folder == null)
                    folder = m_Scene.InventoryService.GetRootFolder(agentID);

                if (folder == null)
                    throw new Exception("Failed to find a folder for the notecard item" + notecardID.ToString());

                item.Folder = folder.ID;

                // do change owner permissions (c&p from scene inventory code)
                if (m_Scene.Permissions.PropagatePermissions() && item.Owner != agentID)
                {
                    uint permsMask = ~((uint)PermissionMask.Copy |
                                        (uint)PermissionMask.Transfer |
                                        (uint)PermissionMask.Modify |
                                        (uint)PermissionMask.Export);

                    uint nextPerms = permsMask | (item.NextPermissions &
                                        ((uint)PermissionMask.Copy |
                                        (uint)PermissionMask.Transfer |
                                        (uint)PermissionMask.Modify));

                    if (nextPerms == permsMask)
                        nextPerms |= (uint)PermissionMask.Transfer;

                    uint basePerms = item.BasePermissions | (uint)PermissionMask.Move;
                    uint ownerPerms = item.CurrentPermissions;

                    uint foldedPerms = (item.CurrentPermissions & (uint)PermissionMask.FoldedMask) << (int)PermissionMask.FoldingShift;
                    if (foldedPerms != 0 && item.InvType == (int)InventoryType.Object)
                    {
                        foldedPerms |= permsMask;

                        bool isRootMod = (item.CurrentPermissions &
                                            (uint)PermissionMask.Modify) != 0 ?
                                            true : false;

                        ownerPerms &= foldedPerms;
                        basePerms &= foldedPerms;

                        if (isRootMod)
                        {
                            ownerPerms |= (uint)PermissionMask.Modify;
                            basePerms |= (uint)PermissionMask.Modify;
                        }
                    }

                    ownerPerms &= nextPerms;
                    basePerms &= nextPerms;
                    basePerms &= ~(uint)PermissionMask.FoldedMask;
                    basePerms |= ((basePerms >> 13) & 7) | (((basePerms & (uint)PermissionMask.Export) != 0) ? (uint)PermissionMask.FoldedExport : 0);
                    item.BasePermissions = basePerms;
                    item.CurrentPermissions = ownerPerms;
                    item.Flags |= (uint)InventoryItemFlags.ObjectSlamPerm;
                    item.Flags &= ~(uint)(InventoryItemFlags.ObjectOverwriteBase | InventoryItemFlags.ObjectOverwriteOwner | InventoryItemFlags.ObjectOverwriteGroup | InventoryItemFlags.ObjectOverwriteEveryone | InventoryItemFlags.ObjectOverwriteNextOwner);
                    item.NextPermissions = item.NextPermissions;
                    item.EveryOnePermissions = item.EveryOnePermissions & nextPerms;
                }
                else
                {
                    //??
                    item.EveryOnePermissions &= item.NextPermissions;
                }

                item.GroupPermissions = 0; // we killed the group
                item.Owner = agentID;

                if (!m_Scene.InventoryService.AddItem(item))
                    throw new Exception("Failed create the notecard item" + notecardID.ToString());

                m_log.InfoFormat("[CAPS]: CopyInventoryFromNotecard, ItemID:{0} FolderID:{1}", item.ID, item.Folder);
                if (client != null)
                    client.SendBulkUpdateInventory(item);
                return;
            }
            catch (Exception e)
            {
                m_log.ErrorFormat("[CAPS]: CopyInventoryFromNotecard : {0}", e.Message);
                copyItem = null;
            }

            if(copyItem == null)
            {
                if (client != null)
                    client.SendAlertMessage("Failed to retrieve item");
                httpResponse.StatusCode = (int)HttpStatusCode.BadRequest;
            }
        }

        public void GetObjectPhysicsData(IOSHttpRequest httpRequest, IOSHttpResponse httpResponse, OSDMap req)
        {
            OSDArray object_ids;
            try
            {
                object_ids = (OSDArray)req["object_ids"];
            }
            catch
            {
                httpResponse.StatusCode = (int)HttpStatusCode.BadRequest;
                return;
            }

            StringBuilder lsl = LLSDxmlEncode.Start();
            
            if(object_ids.Count == 0)
                LLSDxmlEncode.AddEmptyMap(lsl);
            else
            {
                LLSDxmlEncode.AddMap(lsl);
                for (int i = 0 ; i < object_ids.Count ; i++)
                {
                    UUID uuid = object_ids[i].AsUUID();

                    SceneObjectPart obj = m_Scene.GetSceneObjectPart(uuid);
                    if (obj != null)
                    {                  
                        LLSDxmlEncode.AddMap(uuid.ToString(),lsl);

                        LLSDxmlEncode.AddElem("PhysicsShapeType", obj.PhysicsShapeType, lsl);
                        LLSDxmlEncode.AddElem("Density", obj.Density, lsl);
                        LLSDxmlEncode.AddElem("Friction", obj.Friction, lsl);
                        LLSDxmlEncode.AddElem("Restitution", obj.Restitution, lsl);
                        LLSDxmlEncode.AddElem("GravityMultiplier", obj.GravityModifier, lsl);

                        LLSDxmlEncode.AddEndMap(lsl);
                    }
                LLSDxmlEncode.AddEndMap(lsl);
                }
            }

            httpResponse.RawBuffer = LLSDxmlEncode.EndToNBBytes(lsl);
            httpResponse.StatusCode = (int)HttpStatusCode.OK;
        }

        public void GetObjectCost(IOSHttpRequest httpRequest, IOSHttpResponse httpResponse, OSDMap req)
        {
            OSDArray object_ids;
            try
            {
                object_ids = (OSDArray)req["object_ids"];
            }
            catch
            {
                httpResponse.StatusCode = (int)HttpStatusCode.BadRequest;
                return;
            }

            StringBuilder lsl = LLSDxmlEncode.Start(512);
            
            if(object_ids.Count == 0)
                LLSDxmlEncode.AddEmptyMap(lsl);
            else
            {
                bool haveone = false;
                LLSDxmlEncode.AddMap(lsl);
                for (int i = 0; i < object_ids.Count; i++)
                {
                    UUID uuid = object_ids[i].AsUUID();

                    SceneObjectPart part = m_Scene.GetSceneObjectPart(uuid);
                    SceneObjectGroup grp = null;
                    if (part != null)
                        grp = part.ParentGroup;
                    if (grp != null)
                    {
                        haveone = true;
                        float linksetCost;
                        float linksetPhysCost;
                        float partCost;
                        float partPhysCost;

                        grp.GetResourcesCosts(part,out linksetCost,out linksetPhysCost,out partCost,out partPhysCost);

                        LLSDxmlEncode.AddMap(uuid.ToString(), lsl);

                        LLSDxmlEncode.AddElem("linked_set_resource_cost", linksetCost, lsl);
                        LLSDxmlEncode.AddElem("resource_cost", partCost, lsl);
                        LLSDxmlEncode.AddElem("physics_cost", partPhysCost, lsl);
                        LLSDxmlEncode.AddElem("linked_set_physics_cost", linksetPhysCost, lsl);
                        LLSDxmlEncode.AddElem("resource_limiting_type", "legacy", lsl);

                        LLSDxmlEncode.AddEndMap(lsl);
                    }
                }
                if(!haveone)
                {
                    LLSDxmlEncode.AddMap(UUID.Zero.ToString(), lsl);
                    LLSDxmlEncode.AddElem("linked_set_resource_cost", 0, lsl);
                    LLSDxmlEncode.AddElem("resource_cost", 0, lsl);
                    LLSDxmlEncode.AddElem("physics_cost", 0, lsl);
                    LLSDxmlEncode.AddElem("linked_set_physics_cost", 0, lsl);
                    LLSDxmlEncode.AddElem("resource_limiting_type", "legacy", lsl);
                    LLSDxmlEncode.AddEndMap(lsl);
                }
                LLSDxmlEncode.AddEndMap(lsl);
            }

            httpResponse.RawBuffer = LLSDxmlEncode.EndToNBBytes(lsl);
            httpResponse.StatusCode = (int)HttpStatusCode.OK;
        }

        public void ResourceCostSelected(IOSHttpRequest httpRequest,IOSHttpResponse httpResponse, OSDMap req)
        {
            float phys=0;
            float stream=0;
            float simul=0;

            if (req.ContainsKey("selected_roots"))
            {
                OSDArray object_ids = (OSDArray)req["selected_roots"];

                // should go by SOG suming costs for all parts
                // ll v3 works ok with several objects select we get the list and adds ok
                // FS calls per object so results are wrong guess fs bug
                for (int i = 0; i < object_ids.Count; i++)
                {
                    UUID uuid = object_ids[i].AsUUID();
                    float Physc;
                    float simulc;
                    float streamc;

                    SceneObjectGroup grp = m_Scene.GetGroupByPrim(uuid);
                    if (grp != null)
                    {
                        grp.GetSelectedCosts(out Physc, out streamc, out simulc);
                        phys += Physc;
                        stream += streamc;
                        simul += simulc;
                    }
                }
            }
            else if (req.ContainsKey("selected_prims"))
            {
                OSDArray object_ids = (OSDArray)req["selected_prims"];

                // don't see in use in any of the 2 viewers
                // guess it should be for edit linked but... nothing
                // should go to SOP per part
                for (int i = 0; i < object_ids.Count; i++)
                {
                    UUID uuid = object_ids[i].AsUUID();

                    SceneObjectPart part = m_Scene.GetSceneObjectPart(uuid);
                    if (part != null)
                    {
                        phys += part.PhysicsCost;
                        stream += part.StreamingCost;
                        simul += part.SimulationCost;
                    }
                }
            }

            StringBuilder lsl = LLSDxmlEncode.Start();
            LLSDxmlEncode.AddMap(lsl);

            LLSDxmlEncode.AddMap("selected", lsl);

            LLSDxmlEncode.AddElem("physics", phys, lsl);
            LLSDxmlEncode.AddElem("streaming", stream, lsl);
            LLSDxmlEncode.AddElem("simulation", simul, lsl);

            LLSDxmlEncode.AddEndMap(lsl);
            LLSDxmlEncode.AddEndMap(lsl);

            // resp["transaction_id"] = "undef";
            httpResponse.RawBuffer = LLSDxmlEncode.EndToNBBytes(lsl);
            httpResponse.StatusCode = (int)HttpStatusCode.OK;
        }

        public void UpdateAgentInformation(IOSHttpRequest httpRequest, IOSHttpResponse httpResponse)
        {
            if (httpRequest.HttpMethod != "POST")
            {
                httpResponse.StatusCode = (int)HttpStatusCode.NotFound;
                return;
            }

            // this is wrong now ignores request and sends same result for all
            // we don't store and worse don't use that to filter contents

            // OSDMap req = (OSDMap)OSDParser.DeserializeLLSDXml(request);
            OSDMap resp = new OSDMap();

            OSDMap accessPrefs = new OSDMap();
            accessPrefs["max"] = "A";

            resp["access_prefs"] = accessPrefs;

            httpResponse.RawBuffer = OSDParser.SerializeLLSDXmlBytes(resp);
            httpResponse.StatusCode = (int)HttpStatusCode.OK;
        }

        public bool OSDMapTOVector3(OSDMap map, out Vector3 v)
        {
            v = Vector3.Zero;
            if(!map.ContainsKey("X"))
                return false;
            if(!map.ContainsKey("Y"))
                return false;
            if(!map.ContainsKey("Z"))
                return false;
            v.X = (float)map["X"].AsReal();
            v.Y = (float)map["Y"].AsReal();
            v.Z = (float)map["Z"].AsReal();
            return true;
        }

        public void HomeLocation(IOSHttpRequest httpRequest, IOSHttpResponse httpResponse)
        {
            if (httpRequest.HttpMethod != "POST")
            {
                httpResponse.StatusCode = (int)HttpStatusCode.NotFound;
                return;
            }

            bool fail = true;
            string message = "Set Home request failed";
            //int locationID = 1;
            Vector3 pos = Vector3.Zero;
            Vector3 lookAt = Vector3.Zero;

            IClientAPI client = null;
            ScenePresence sp;

            while(true)
            {
                if(m_Scene.GridUserService == null)
                    break;

                if(m_Scene.UserManagementModule == null)
                    break;

                m_Scene.TryGetScenePresence(m_AgentID, out sp);
                if(sp == null || sp.IsChildAgent || sp.IsDeleted)
                    break;

                if(sp.IsInTransit && !sp.IsInLocalTransit)
                    break;

                client = sp.ControllingClient;

                if(!m_Scene.UserManagementModule.IsLocalGridUser(m_AgentID))
                    break;

                OSDMap req;
                try
                {
                    req = (OSDMap)OSDParser.DeserializeLLSDXml(httpRequest.InputStream);
                }
                catch
                {
                    httpResponse.StatusCode = (int)HttpStatusCode.BadRequest;
                    return;
                }

                OSD tmp;
                if (!req.TryGetValue("HomeLocation", out tmp) || !(tmp is OSDMap))
                    break;

                OSDMap HLocation = (OSDMap)tmp;

                if(!HLocation.TryGetValue("LocationPos", out tmp) || !(tmp is OSDMap))
                    break;
                if (!OSDMapTOVector3((OSDMap)tmp, out pos))
                    break;

                if (!HLocation.TryGetValue("LocationLookAt", out tmp) || !(tmp is OSDMap))
                    break;
                if (!OSDMapTOVector3((OSDMap)tmp, out lookAt))
                    break;

                //locationID = HLocation["LocationId"].AsInteger();

                ILandObject land = m_Scene.LandChannel.GetLandObject(pos);
                if(land == null)
                    break;

                ulong gpowers = client.GetGroupPowers(land.LandData.GroupID);
                SceneObjectGroup telehub = null;
                if (m_Scene.RegionInfo.RegionSettings.TelehubObject != UUID.Zero)
                // Does the telehub exist in the scene?
                    telehub = m_Scene.GetSceneObjectGroup(m_Scene.RegionInfo.RegionSettings.TelehubObject);

                if (!m_Scene.Permissions.IsAdministrator(m_AgentID) && // (a) gods and land managers can set home
                    !m_Scene.Permissions.IsGod(m_AgentID) &&
                    m_AgentID != land.LandData.OwnerID && // (b) land owners can set home
                    // (c) members of the land-associated group in roles that can set home
                    ((gpowers & (ulong)GroupPowers.AllowSetHome) != (ulong)GroupPowers.AllowSetHome) &&
                    // (d) parcels with telehubs can be the home of anyone
                    (telehub == null || !land.ContainsPoint((int)telehub.AbsolutePosition.X, (int)telehub.AbsolutePosition.Y)))
                {
                    message = "You are not allowed to set your home location in this parcel.";
                    break;
                }

                string userId;
                UUID test;
                if (!m_Scene.UserManagementModule.GetUserUUI(m_AgentID, out userId))
                {
                    message = "Set Home request failed. (User Lookup)";
                    break;
                }

                if (!UUID.TryParse(userId, out test))
                {
                    message = "Set Home request failed. (HG visitor)";
                    break;
                }

                if (m_Scene.GridUserService.SetHome(userId, land.RegionUUID, pos, lookAt))
                    fail = false;

                break;
            }

            OSDMap resp = new OSDMap();

            if(fail)
            {
                if(client != null)
                    client.SendAlertMessage(message);
                resp["success"] = "false";
            }
            else
            {
                // so its http but still needs a udp reply to inform user? crap :p
                if(client != null)
                   client.SendAlertMessage("Home position set.","HomePositionSet");

                resp["success"] = "true";
                OSDMap homeloc = new OSDMap();
                OSDMap homelocpos = new OSDMap();
                // for some odd reason viewers send pos as reals but read as integer
                homelocpos["X"] = new OSDReal(pos.X);
                homelocpos["Y"] = new OSDReal(pos.Y);
                homelocpos["Z"] = new OSDReal(pos.Z);
                homeloc["LocationPos"] = homelocpos;

                resp["HomeLocation"] = homeloc;
            }

            httpResponse.RawBuffer = Util.UTF8NBGetbytes(OSDParser.SerializeLLSDXmlString(resp));
            httpResponse.StatusCode = (int)HttpStatusCode.OK;
        }

        private static int CompareRolesByMembersDesc(GroupRolesData x, GroupRolesData y)
        {
            return -(x.Members.CompareTo(y.Members));
        }

        public void GroupMemberData(IOSHttpRequest httpRequest, IOSHttpResponse httpResponse)
        {
            if (httpRequest.HttpMethod != "POST")
            {
                httpResponse.StatusCode = (int)HttpStatusCode.NotFound;
                return;
            }

            OSDMap resp = new OSDMap();

            bool fail = true;
            IClientAPI client = null;
            ScenePresence sp;
            IGroupsModule m_GroupsModule;
            UUID groupID = UUID.Zero;

            while(true)
            {
                m_GroupsModule = m_Scene.RequestModuleInterface<IGroupsModule>();
                if(m_GroupsModule == null)
                    break;

                m_Scene.TryGetScenePresence(m_AgentID, out sp);
                if(sp == null || sp.IsChildAgent || sp.IsDeleted)
                    break;
                
                if(sp.IsInTransit && !sp.IsInLocalTransit)
                    break;

                client = sp.ControllingClient;

                OSDMap req;
                try
                {
                    req = (OSDMap)OSDParser.DeserializeLLSDXml(httpRequest.InputStream);
                }
                catch
                {
                    httpResponse.StatusCode = (int)HttpStatusCode.BadRequest;
                    return;
                }

                OSD tmp;
                if(!req.TryGetValue("group_id", out tmp) || !(tmp is OSDUUID))
                    break;

                groupID = tmp.AsUUID();
                if(groupID == UUID.Zero)
                    break;

                List<GroupRolesData> roles = m_GroupsModule.GroupRoleDataRequest(client, groupID);
                if(roles == null || roles.Count == 0)
                    break;

                List<GroupMembersData> members = m_GroupsModule.GroupMembersRequest(client, groupID);
                if(members == null || members.Count == 0)
                    break;

                int memberCount = members.Count;

                Dictionary<string,int> titles = new Dictionary<string,int>();
                int i = 0;

                ulong defaultPowers = 0;


                // build titles array and index
                roles.Sort(CompareRolesByMembersDesc);

                OSDArray osdtitles = new OSDArray();
                foreach(GroupRolesData grd in roles)
                {
                    if(grd.Title == null)
                        continue;
                    string title = grd.Title;
                    if(i==0)
                        defaultPowers = grd.Powers;

                    if(!titles.ContainsKey(title))
                    {
                        titles[title] = i++;
                        osdtitles.Add(new OSDString(title));
                    }
                }

                if(titles.Count == 0)
                    break;

                OSDMap osdmembers = new OSDMap();
                foreach(GroupMembersData gmd in members)
                {
                    OSDMap m = new OSDMap();
                    if(gmd.OnlineStatus != null && gmd.OnlineStatus != "")
                        m["last_login"] = new OSDString(gmd.OnlineStatus);
                    if(gmd.AgentPowers != defaultPowers)
                        m["powers"] = new OSDString((gmd.AgentPowers).ToString("X"));
                    if(gmd.Title != null && titles.ContainsKey(gmd.Title) && titles[gmd.Title] != 0)
                        m["title"] = new OSDInteger(titles[gmd.Title]);
                    if(gmd.IsOwner)
                        m["owner"] = new OSDString("true");
                    if(gmd.Contribution != 0)
                        m["donated_square_meters"] = new OSDInteger(gmd.Contribution);

                    osdmembers[(gmd.AgentID).ToString()] = m;
                }

                OSDMap osddefaults = new OSDMap();
                osddefaults["default_powers"] = new OSDString(defaultPowers.ToString("X"));

                resp["group_id"] = new OSDUUID(groupID);
                resp["agent_id"] = new OSDUUID(m_AgentID);
                resp["member_count"] = new OSDInteger(memberCount);
                resp["defaults"] = osddefaults;
                resp["titles"] = osdtitles;
                resp["members"] = osdmembers;

                fail = false;
                break;
            }

            if(fail)
            {
                resp["group_id"] = new OSDUUID(groupID);
                resp["agent_id"] = new OSDUUID(m_AgentID);
                resp["member_count"] = new OSDInteger(0);
                resp["defaults"] = new OSDMap();
                resp["titles"] = new OSDArray();
                resp["members"] = new OSDMap();
            }

            httpResponse.RawBuffer = Util.UTF8NBGetbytes(OSDParser.SerializeLLSDXmlString(resp));
            httpResponse.StatusCode = (int)HttpStatusCode.OK;
        }

        public void GetDisplayNames(IOSHttpRequest httpRequest, IOSHttpResponse httpResponse)
        {
            if (httpRequest.HttpMethod != "GET")
            {
                httpResponse.StatusCode = (int)HttpStatusCode.NotFound;
                return;
            }

            ScenePresence sp = m_Scene.GetScenePresence(m_AgentID);
            if(sp == null || sp.IsDeleted)
            {
                httpResponse.StatusCode = (int)HttpStatusCode.Gone;
                return;
            }
            if(sp.IsInTransit && !sp.IsInLocalTransit)
            {
                httpResponse.StatusCode = (int)HttpStatusCode.ServiceUnavailable;
                httpResponse.AddHeader("Retry-After","30");
                return;
            }

            // Full content request
            NameValueCollection query = httpRequest.QueryString;
            string[] ids = query.GetValues("ids");

            Dictionary<UUID,string> names = m_UserManager.GetUsersNames(ids, m_scopeID);
            StringBuilder lsl = LLSDxmlEncode.Start(names.Count * 256 + 256);
            LLSDxmlEncode.AddMap(lsl);
            int ct = 0;
            if(names.Count == 0)
                LLSDxmlEncode.AddEmptyArray("agents", lsl);
            else
            {
                LLSDxmlEncode.AddArray("agents", lsl);

                foreach (KeyValuePair<UUID,string> kvp in names)
                {
                    string[] parts = kvp.Value.Split(new char[] {' '});
                    string fullname = kvp.Value;

                    if (string.IsNullOrEmpty(kvp.Value))
                    {
                        parts = new string[] {"(hippos)", ""};
                        fullname = "(hippos)";
                    }

                    if(kvp.Key == UUID.Zero)
                        continue;

                // dont tell about unknown users, we can't send them back on Bad either
                    if(parts[0] == "Unknown")
                         continue;

                    LLSDxmlEncode.AddMap(lsl);
                    LLSDxmlEncode.AddElem("display_name_next_update", DateTime.UtcNow.AddDays(8), lsl);
                    LLSDxmlEncode.AddElem("display_name_expires", DateTime.UtcNow.AddMonths(1), lsl);
                    LLSDxmlEncode.AddElem("display_name", fullname, lsl);
                    LLSDxmlEncode.AddElem("legacy_first_name", parts[0], lsl);
                    LLSDxmlEncode.AddElem("legacy_last_name", parts[1], lsl);
                    LLSDxmlEncode.AddElem("username", fullname, lsl);
                    LLSDxmlEncode.AddElem("id", kvp.Key, lsl);
                    LLSDxmlEncode.AddElem("is_display_name_default", true, lsl);
                    LLSDxmlEncode.AddEndMap(lsl);
                    ct++;
                }
                LLSDxmlEncode.AddEndArray(lsl);
            }
        
            LLSDxmlEncode.AddEndMap(lsl);

            httpResponse.RawBuffer = LLSDxmlEncode.EndToNBBytes(lsl);
            httpResponse.ContentType = "application/llsd+xml";
            httpResponse.StatusCode = (int)HttpStatusCode.OK;
        }
    }

    public class AssetUploader
    {
        private static readonly ILog m_log =
            LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);


        public event UpLoadedAsset OnUpLoad;
        private UpLoadedAsset handlerUpLoad = null;

        private string uploaderPath = String.Empty;
        private UUID newAssetID;
        private UUID inventoryItemID;
        private UUID parentFolder;
        private IHttpServer httpListener;
        private bool m_dumpAssetsToFile;
        private string m_assetName = String.Empty;
        private string m_assetDes = String.Empty;

        private string m_invType = String.Empty;
        private string m_assetType = String.Empty;
        private int m_cost;
        private string m_error = String.Empty;

        private Timer m_timeoutTimer = new Timer();
        private UUID m_texturesFolder;
        private int m_nreqtextures;
        private int m_nreqmeshs;
        private int m_nreqinstances;
        private bool m_IsAtestUpload;

        private int m_nextOwnerMask;
        private int m_groupMask;
        private int m_everyoneMask;
        private int[] m_meshesSides;

        public AssetUploader(string assetName, string description, UUID assetID, UUID inventoryItem,
                                UUID parentFolderID, string invType, string assetType, string path,
                                IHttpServer httpServer, bool dumpAssetsToFile,
                                int totalCost, UUID texturesFolder, int nreqtextures, int nreqmeshs, int nreqinstances,
                                bool IsAtestUpload, int nextOwnerMask, int groupMask, int everyoneMask, int[] meshesSides)
        {
            m_assetName = assetName;
            m_assetDes = description;
            newAssetID = assetID;
            inventoryItemID = inventoryItem;
            uploaderPath = path;
            httpListener = httpServer;
            parentFolder = parentFolderID;
            m_assetType = assetType;
            m_invType = invType;
            m_dumpAssetsToFile = dumpAssetsToFile;
            m_cost = totalCost;

            m_texturesFolder = texturesFolder;
            m_nreqtextures = nreqtextures;
            m_nreqmeshs = nreqmeshs;
            m_nreqinstances = nreqinstances;
            m_IsAtestUpload = IsAtestUpload;

            m_timeoutTimer.Elapsed += TimedOut;
            m_timeoutTimer.Interval = 120000;
            m_timeoutTimer.AutoReset = false;
            m_timeoutTimer.Start();

            m_nextOwnerMask = nextOwnerMask;
            m_groupMask = groupMask;
            m_everyoneMask = everyoneMask;

            m_meshesSides = meshesSides;
        }

        /// <summary>
        /// Handle raw asset upload data via the capability.
        /// </summary>
        /// <param name="data"></param>
        /// <param name="path"></param>
        /// <param name="param"></param>
        /// <returns></returns>
        public string uploaderCaps(byte[] data, string path, string param)
        {
            UUID inv = inventoryItemID;
            string res = String.Empty;
            LLSDAssetUploadComplete uploadComplete = new LLSDAssetUploadComplete();
/*
            uploadComplete.new_asset = newAssetID.ToString();
            uploadComplete.new_inventory_item = inv;
            uploadComplete.state = "complete";

            res = LLSDHelpers.SerialiseLLSDReply(uploadComplete);
*/
            m_timeoutTimer.Stop();
            httpListener.RemoveStreamHandler("POST", uploaderPath);

            // TODO: probably make this a better set of extensions here
            string extension = ".jp2";
            if (m_invType != "image")
            {
                extension = ".dat";
            }

            if (m_dumpAssetsToFile)
            {
                SaveAssetToFile(m_assetName + extension, data);
            }
            handlerUpLoad = OnUpLoad;
            if (handlerUpLoad != null)
            {
                handlerUpLoad(m_assetName, m_assetDes, newAssetID, inv, parentFolder, data, m_invType, m_assetType,
                    m_cost, m_texturesFolder, m_nreqtextures, m_nreqmeshs, m_nreqinstances, m_IsAtestUpload,
                    ref m_error, ref m_nextOwnerMask, ref m_groupMask, ref m_everyoneMask, m_meshesSides);
            }

            uploadComplete.new_next_owner_mask = m_nextOwnerMask;
            uploadComplete.new_group_mask = m_groupMask;
            uploadComplete.new_everyone_mask = m_everyoneMask;

            if (m_error == String.Empty)
            {
                uploadComplete.new_asset = newAssetID.ToString();
                uploadComplete.new_inventory_item = inv;
                //                if (m_texturesFolder != UUID.Zero)
                //                    uploadComplete.new_texture_folder_id = m_texturesFolder;
               if (m_IsAtestUpload)
               {
                  LLSDAssetUploadError resperror = new LLSDAssetUploadError();
                  resperror.message = "Upload SUCCESSFUL for testing purposes only. Other uses are prohibited. Item will not work after 48 hours or on other regions";
                  resperror.identifier = inv;
                    
                  uploadComplete.error = resperror;
               }
               uploadComplete.state = "complete";
            }
            else
            {
                LLSDAssetUploadError resperror = new LLSDAssetUploadError();
                resperror.message = m_error;
                resperror.identifier = inv;

                uploadComplete.error = resperror;
                uploadComplete.state = "failed";
            }

            res = LLSDHelpers.SerialiseLLSDReply(uploadComplete);
            return res;
        }

        private void TimedOut(object sender, ElapsedEventArgs args)
        {
            m_log.InfoFormat("[CAPS]: Removing URL and handler for timed out mesh upload");
            httpListener.RemoveStreamHandler("POST", uploaderPath);
        }

        private static void SaveAssetToFile(string filename, byte[] data)
        {
            string assetPath = "UserAssets";
            if (!Directory.Exists(assetPath))
            {
                Directory.CreateDirectory(assetPath);
            }
            FileStream fs = File.Create(Path.Combine(assetPath, Util.safeFileName(filename)));
            BinaryWriter bw = new BinaryWriter(fs);
            bw.Write(data);
            bw.Close();
            fs.Close();
        }
    }
}
