OpenSim-Test/OpenSim/Region/ScriptEngine/XEngine/XEngine.cs

using System;
using System.IO;
using System.Threading;
using System.Collections;
using System.Collections.Generic;
using System.Security.Policy;
using System.Reflection;
using System.Xml;
using libsecondlife;
using log4net;
using Nini.Config;
using Amib.Threading;
using OpenSim.Framework;
using OpenSim.Region.Environment;
using OpenSim.Region.Environment.Scenes;
using OpenSim.Region.Environment.Interfaces;
using OpenSim.Region.ScriptEngine.XEngine.Script;

namespace OpenSim.Region.ScriptEngine.XEngine
{
    public class XEngine : IRegionModule
    {
        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);

        private SmartThreadPool m_ThreadPool;
        private int m_MaxScriptQueue;
        private Scene m_Scene;
        private IConfig m_ScriptConfig;
        private Compiler m_Compiler;
        private EventManager m_EventManager;
        private int m_EventLimit;
        private bool m_KillTimedOutScripts;

        private static List<XEngine> m_ScriptEngines =
                new List<XEngine>();
        public AsyncCommandManager m_ASYNCLSLCommandManager;

        // Maps the local id to the script inventory items in it

        private Dictionary<uint, List<LLUUID> > m_PrimObjects =
                new Dictionary<uint, List<LLUUID> >();

        // Maps the LLUUID above to the script instance

        private Dictionary<LLUUID, XScriptInstance> m_Scripts =
                new Dictionary<LLUUID, XScriptInstance>();

        // Maps the asset ID to the assembly

        private Dictionary<LLUUID, string> m_Assemblies =
                new Dictionary<LLUUID, string>();

        // This will list AppDomains by script asset

        private Dictionary<LLUUID, AppDomain> m_AppDomains =
                new Dictionary<LLUUID, AppDomain>();

        // List the scripts running in each appdomain

        private Dictionary<LLUUID, List<LLUUID> > m_DomainScripts =
                new Dictionary<LLUUID, List<LLUUID> >();

        public string ScriptEngineName
        {
            get { return "XEngine"; }
        }

        public Scene World
        {
            get { return m_Scene; }
        }

        public ILog Log
        {
            get { return m_log; }
        }

        public static List<XEngine> ScriptEngines
        {
            get { return m_ScriptEngines; }
        }

        private struct RezScriptParms
        {
            uint LocalID;
            LLUUID ItemID;
            string Script;
        }

        public IConfig ScriptConfigSource
        {
            get { return m_ScriptConfig; }
        }

        //
        // IRegionModule functions
        //
        public void Initialise(Scene scene, IConfigSource configSource)
        {
            AppDomain.CurrentDomain.AssemblyResolve +=
                    OnAssemblyResolve;

            m_log.InfoFormat("[XEngine] Initializing scripts in region {0}",
                    scene.RegionInfo.RegionName);
            m_Scene=scene;

            m_ScriptConfig = configSource.Configs["XEngine"];

            if(m_ScriptConfig == null)
            {
                m_log.ErrorFormat("[XEngine] No script configuration found. Scripts disabled");
                return;
            }

            int minThreads = m_ScriptConfig.GetInt("MinThreads", 2);
            int maxThreads = m_ScriptConfig.GetInt("MaxThreads", 2);
            int idleTimeout = m_ScriptConfig.GetInt("IdleTimeout", 60);
            string priority = m_ScriptConfig.GetString("Priority", "BelowNormal");
            int maxScriptQueue = m_ScriptConfig.GetInt("MaxScriptEventQueue",300);
            int stackSize = m_ScriptConfig.GetInt("ThreadStackSize", 262144);
            int sleepTime = m_ScriptConfig.GetInt("MaintenanceInterval",
                    10)*1000;
            m_EventLimit = m_ScriptConfig.GetInt("EventLimit", 30);
            m_KillTimedOutScripts = m_ScriptConfig.GetBoolean(
                    "KillTimedOutScripts", false);
            int saveTime = m_ScriptConfig.GetInt("SaveInterval", 300)*1000;

            ThreadPriority prio = ThreadPriority.BelowNormal;
            switch(priority)
            {
            case "Lowest":
                prio=ThreadPriority.Lowest;
                break;
            case "BelowNormal":
                prio=ThreadPriority.BelowNormal;
                break;
            case "Normal":
                prio=ThreadPriority.Normal;
                break;
            case "AboveNormal":
                prio=ThreadPriority.AboveNormal;
                break;
            case "Highest":
                prio=ThreadPriority.Highest;
                break;
            default:
                m_log.ErrorFormat("[XEngine] Invalid thread priority: '"+
                        priority+"'. Assuming BelowNormal");
                break;
            }

            lock(m_ScriptEngines)
            {
                m_ScriptEngines.Add(this);
            }

            m_EventManager = new EventManager(this);
            m_ASYNCLSLCommandManager = new AsyncCommandManager(this);

            StartEngine(minThreads, maxThreads, idleTimeout, prio,
                    maxScriptQueue, stackSize);

            m_Compiler = new Compiler(this);

            m_Scene.EventManager.OnRezScript += OnRezScript;
            m_Scene.EventManager.OnRemoveScript += OnRemoveScript;
            m_Scene.EventManager.OnScriptReset += OnScriptReset;

            if(sleepTime > 0)
            {
                m_ThreadPool.QueueWorkItem(new WorkItemCallback(
                        this.DoMaintenance), new Object[] 
                        { sleepTime });
            }

            if(saveTime > 0)
            {
                m_ThreadPool.QueueWorkItem(new WorkItemCallback(
                        this.DoBackup), new Object[] { saveTime });
            }
        }

        public void PostInitialise()
        {
            m_ThreadPool.Start();
        }

        public void Close()
        {
            lock(m_ScriptEngines)
            {
                if(m_ScriptEngines.Contains(this))
                    m_ScriptEngines.Remove(this);
            }
        }

        public object DoBackup(object o)
        {
            Object[] p = (Object[])o;
            int saveTime = (int)p[0];

            System.Threading.Thread.Sleep(saveTime);

//            m_log.Debug("[XEngine] Backing up script states");

            List<XScriptInstance> instances = new List<XScriptInstance>();

            lock(m_Scripts)
            {
                foreach (XScriptInstance instance in m_Scripts.Values)
                    instances.Add(instance);
            }

            foreach (XScriptInstance i in instances)
            {
                string assembly = String.Empty;

                lock(m_Scripts)
                {
                    if(!m_Assemblies.ContainsKey(i.AssetID))
                        continue;
                    assembly = m_Assemblies[i.AssetID];
                }

                i.SaveState(assembly);
            }

            instances.Clear();

            m_ThreadPool.QueueWorkItem(new WorkItemCallback(
                    this.DoBackup), new Object[] { saveTime });

            return 0;
        }

        public object DoMaintenance(object p)
        {
            object[] parms = (object[])p;
            int sleepTime = (int)parms[0];

            foreach (XScriptInstance inst in m_Scripts.Values)
            {
                if(inst.EventTime() > m_EventLimit)
                {
                    inst.Stop(100);
                    if(!m_KillTimedOutScripts)
                        inst.Start();
                }
            }

            System.Threading.Thread.Sleep(sleepTime);

            m_ThreadPool.QueueWorkItem(new WorkItemCallback(
                    this.DoMaintenance), new Object[] 
                    { sleepTime });

            return 0;
        }

        public string Name
        {
            get { return "XEngine"; }
        }

        public bool IsSharedModule
        {
            get { return false; }
        }

        //
        // XEngine functions
        //
        public int MaxScriptQueue
        {
            get { return m_MaxScriptQueue; }
        }

        //
        // Hooks
        //
        public void OnRezScript(uint localID, LLUUID itemID, string script)
        {
            m_ThreadPool.QueueWorkItem(new WorkItemCallback(
                    this.DoOnRezScript), new Object[] 
                    { localID, itemID, script});
        }

        private object DoOnRezScript(object parm)
        {
            Object[] p = (Object[])parm;
            uint localID = (uint)p[0];
            LLUUID itemID = (LLUUID)p[1];
            string script =(string)p[2];

            // Get the asset ID of the script, so we can check if we
            // already have it.

            SceneObjectPart part = m_Scene.GetSceneObjectPart(localID);
            if(part == null)
                return false;

            TaskInventoryItem item = part.GetInventoryItem(itemID);
            if(item == null)
                return false;
            
            LLUUID assetID=item.AssetID;

//            m_log.DebugFormat("[XEngine] Compiling script {0} ({1})",
//                    item.Name, itemID.ToString());

            string assembly="";
            try
            {
                assembly=m_Compiler.PerformScriptCompile(script,
                        assetID.ToString());
                m_log.DebugFormat("[XEngine] Loaded script {0}.{1}",
                        part.ParentGroup.RootPart.Name, item.Name);
            }
            catch (Exception e)
            {
                try
                {
                    // DISPLAY ERROR INWORLD
                    string text = "Error compiling script:\r\n" + e.Message.ToString();
                    if (text.Length > 1400)
                        text = text.Substring(0, 1400);
                    World.SimChat(Helpers.StringToField(text),
                            ChatTypeEnum.DebugChannel, 2147483647,
                            part.AbsolutePosition,
                            part.Name, part.UUID, false);
                }
                catch (Exception e2) // LEGIT: User Scripting
                {
                    m_log.Error("[XEngine]: "+
                            "Error displaying error in-world: " +
                            e2.ToString());
                    m_log.Error("[XEngine]: " +
                            "Errormessage: Error compiling script:\r\n" +
                            e.Message.ToString());
                }

                return false;
            }

            lock(m_Scripts)
            {
                // Create the object record
                
                if(!m_PrimObjects.ContainsKey(localID))
                    m_PrimObjects[localID] = new List<LLUUID>();

                if(!m_PrimObjects[localID].Contains(itemID))
                    m_PrimObjects[localID].Add(itemID);

                if(!m_Assemblies.ContainsKey(assetID))
                    m_Assemblies[assetID] = assembly;

                if((!m_Scripts.ContainsKey(itemID)) ||
                   (m_Scripts[itemID].AssetID != assetID))
                {
                    LLUUID appDomain=assetID;

                    if(part.ParentGroup.RootPart.m_IsAttachment)
                        appDomain=part.ParentGroup.RootPart.UUID;
                    
                    if(!m_AppDomains.ContainsKey(appDomain))
                    {
                        try
                        {
                            AppDomainSetup appSetup = new AppDomainSetup();
//                            appSetup.ApplicationBase = Path.Combine(
//                                    "ScriptEngines",
//                                    m_Scene.RegionInfo.RegionID.ToString());

                            Evidence baseEvidence =
                                    AppDomain.CurrentDomain.Evidence;
                            Evidence evidence = new Evidence(baseEvidence);

                            m_AppDomains[appDomain] =
                                AppDomain.CreateDomain(
                                        m_Scene.RegionInfo.RegionID.ToString(),
                                        evidence, appSetup);

                            m_AppDomains[appDomain].AssemblyResolve +=
                                    new ResolveEventHandler(
                                    AssemblyResolver.OnAssemblyResolve);
                            m_DomainScripts[appDomain] = new List<LLUUID>();
                        }
                        catch (Exception e)
                        {
                            m_log.Error("[XEngine] Exception creating app domain:\n"+e.ToString());
                            return false;
                        }
                    }
                    m_DomainScripts[appDomain].Add(itemID);


                    XScriptInstance instance = new XScriptInstance(this,localID,
                            part.UUID, itemID, assetID, assembly,
                            m_AppDomains[appDomain]);

                    instance.AppDomain = appDomain;

                    m_Scripts[itemID] = instance;
                }
            }
            return true;
        }

        public void OnRemoveScript(uint localID, LLUUID itemID)
        {
            lock(m_Scripts)
            {
                // Do we even have it?
                if(!m_Scripts.ContainsKey(itemID))
                    return;

                m_ASYNCLSLCommandManager.RemoveScript(localID, itemID);

                XScriptInstance instance=m_Scripts[itemID];
                m_Scripts.Remove(itemID);

                instance.ClearQueue();
                instance.Stop(0);

                SceneObjectPart part =
                        m_Scene.GetSceneObjectPart(localID);

                if(part != null)
                    part.RemoveScriptEvents(itemID);

                // Remove the script from it's prim
                if(m_PrimObjects.ContainsKey(localID))
                {
                    // Remove inventory item record
                    if(m_PrimObjects[localID].Contains(itemID))
                        m_PrimObjects[localID].Remove(itemID);

                    // If there are no more scripts, remove prim
                    if(m_PrimObjects[localID].Count == 0)
                    {
                        m_PrimObjects.Remove(localID);
                    }
                }

                m_DomainScripts[instance.AppDomain].Remove(instance.ItemID);
                if(m_DomainScripts[instance.AppDomain].Count == 0)
                {
                    m_DomainScripts.Remove(instance.AppDomain);
                    UnloadAppDomain(instance.AppDomain);
                }

                instance = null;

                CleanAssemblies();
            }
        }

        public void OnScriptReset(uint localID, LLUUID itemID)
        {
            ResetScript(itemID);
        }

        private void CleanAssemblies()
        {
            List<LLUUID> assetIDList = new List<LLUUID>(m_Assemblies.Keys);

            foreach (XScriptInstance i in m_Scripts.Values)
            {
                if(assetIDList.Contains(i.AssetID))
                    assetIDList.Remove(i.AssetID);
            }

            foreach (LLUUID assetID in assetIDList)
            {
//                m_log.DebugFormat("[XEngine] Removing unreferenced assembly {0}", m_Assemblies[assetID]);
                try
                {
                    if(File.Exists(m_Assemblies[assetID]))
                        File.Delete(m_Assemblies[assetID]);
                    if(File.Exists(m_Assemblies[assetID]+".state"))
                        File.Delete(m_Assemblies[assetID]+".state");
                    if(File.Exists(m_Assemblies[assetID]+".mdb"))
                        File.Delete(m_Assemblies[assetID]+".mdb");
                }
                catch (Exception e)
                {
                }
                m_Assemblies.Remove(assetID);
            }
        }

        private void UnloadAppDomain(LLUUID id)
        {
            if(m_AppDomains.ContainsKey(id))
            {
                AppDomain domain=m_AppDomains[id];
                m_AppDomains.Remove(id);

                AppDomain.Unload(domain);
                domain = null;
//                m_log.DebugFormat("[XEngine] Unloaded app domain {0}", id.ToString());
            }
        }

        //
        // Start processing
        //
        private void StartEngine(int minThreads, int maxThreads,
                int idleTimeout, ThreadPriority threadPriority,
                int maxScriptQueue, int stackSize)
        {
            m_MaxScriptQueue=maxScriptQueue;

            STPStartInfo startInfo = new STPStartInfo();
            startInfo.IdleTimeout = idleTimeout;
            startInfo.MaxWorkerThreads = maxThreads;
            startInfo.MinWorkerThreads = minThreads;
            startInfo.ThreadPriority = threadPriority;
            startInfo.StackSize = stackSize;
            startInfo.StartSuspended = true;
            
            m_ThreadPool = new SmartThreadPool(startInfo);
        }

        //
        // Used by script instances to queue event handler jobs
        //
        public IWorkItemResult QueueEventHandler(object parms)
        {
            return m_ThreadPool.QueueWorkItem(new WorkItemCallback(
                    this.ProcessEventHandler), parms);
        }

        //
        // The main script engine worker
        //
        private object ProcessEventHandler(object parms)
        {
            XScriptInstance instance=(XScriptInstance)parms;
            
            return instance.EventProcessor();
        }

        //
        // Post event to an entire prim
        //
        public bool PostObjectEvent(uint localID, XEventParams p)
        {
            bool result = false;

            if(!m_PrimObjects.ContainsKey(localID))
                return false;

            foreach (LLUUID itemID in m_PrimObjects[localID])
            {
                if(m_Scripts.ContainsKey(itemID))
                {
                    XScriptInstance instance = m_Scripts[itemID];
                    if(instance != null)
                    {
                        instance.PostEvent(p);
                        result = true;
                    }
                }
            }
            return result;
        }

        //
        // Post an event to a single script
        //
        public bool PostScriptEvent(LLUUID itemID, XEventParams p)
        {
            if(m_Scripts.ContainsKey(itemID))
            {
                XScriptInstance instance = m_Scripts[itemID];
                if(instance != null)
                    instance.PostEvent(p);
                return true;
            }
            return false;
        }

        public Assembly OnAssemblyResolve(object sender,
                ResolveEventArgs args)
        {
            if(!(sender is System.AppDomain))
                return null;

            string[] pathList=new string[] {"bin", "ScriptEngines",
                    Path.Combine("ScriptEngines",
                    m_Scene.RegionInfo.RegionID.ToString())};

            string assemblyName = args.Name;
            if(assemblyName.IndexOf(",") != -1)
                assemblyName=args.Name.Substring(0, args.Name.IndexOf(","));

            foreach (string s in pathList)
            {
                string path=Path.Combine(Directory.GetCurrentDirectory(),
                        Path.Combine(s, assemblyName))+".dll";

                if(File.Exists(path))
                    return Assembly.LoadFrom(path);
            }

            return null;
        }

        private XScriptInstance GetInstance(LLUUID itemID)
        {
            XScriptInstance instance;
            lock(m_Scripts)
            {
                if(!m_Scripts.ContainsKey(itemID))
                    return null;
                instance = m_Scripts[itemID];
            }
            return instance;
        }

        public void SetScriptState(LLUUID itemID, bool running)
        {
            XScriptInstance instance = GetInstance(itemID);
            if(instance != null)
            {
                if(running)
                    instance.Start();
                else
                    instance.Stop(500);
            }
        }

        public bool GetScriptState(LLUUID itemID)
        {
            XScriptInstance instance = GetInstance(itemID);
            if(instance != null)
                return instance.Running;
            return false;
        }

        public void ResetScript(LLUUID itemID)
        {
            XScriptInstance instance = GetInstance(itemID);
            if(instance != null)
                instance.ResetScript();
        }

        public XDetectParams GetDetectParams(LLUUID itemID, int idx)
        {
            XScriptInstance instance = GetInstance(itemID);
            if(instance != null)
                return instance.GetDetectParams(idx);
            return new XDetectParams();
        }

        public LLUUID GetDetectID(LLUUID itemID, int idx)
        {
            XScriptInstance instance = GetInstance(itemID);
            if(instance != null)
                return instance.GetDetectID(idx);
            return LLUUID.Zero;
        }
    }

    public struct XDetectParams
    {
        public LLUUID Key;
        public LSL_Types.Vector3 OffsetPos;
    }

    public class XEventParams
    {
        public XEventParams(string eventName, Object[] eventParams, XDetectParams[] detectParams)
        {
            EventName=eventName;
            Params=eventParams;
            DetectParams=detectParams;
        }

        public string EventName;
        public Object[] Params;
        public XDetectParams[] DetectParams;
    }

    public class XScriptInstance
    {
        private XEngine m_Engine;
        private IWorkItemResult m_CurrentResult=null;
        private Queue m_EventQueue=new Queue(32);
        private bool m_RunEvents=false;
        private LLUUID m_ItemID;
        private uint m_LocalID;
        private LLUUID m_ObjectID;
        private LLUUID m_AssetID;
        private IScript m_Script;
        private LSL_ScriptCommands m_LSLCommands;
        private OSSL_ScriptCommands m_OSSLCommands;
        private Executor m_Executor;
        private LLUUID m_AppDomain;
        private XDetectParams[] m_DetectParams;
        private bool m_TimerQueued;
        private DateTime m_EventStart;
        private bool m_InEvent;

        // Script state
        private string m_State="default";

        public Object[] PluginData = new Object[0];

        public bool Running
        {
            get { return m_RunEvents; }
        }

        public string State
        {
            get { return m_State; }
            set { m_State = value; }
        }

        public XEngine Engine
        {
            get { return m_Engine; }
        }

        public LLUUID AppDomain
        {
            get { return m_AppDomain; }
            set { m_AppDomain = value; }
        }

        public LLUUID ItemID
        {
            get { return m_ItemID; }
        }

        public LLUUID ObjectID
        {
            get { return m_ObjectID; }
        }

        public uint LocalID
        {
            get { return m_LocalID; }
        }

        public LLUUID AssetID
        {
            get { return m_AssetID; }
        }

        public Queue EventQueue
        {
            get { return m_EventQueue; }
        }

        public void ClearQueue()
        {
            m_TimerQueued = false;
            m_EventQueue.Clear();
        }

        public XScriptInstance(XEngine engine, uint localID, LLUUID objectID,
                LLUUID itemID, LLUUID assetID, string assembly, AppDomain dom)
        {
            m_Engine=engine;

            m_LocalID = localID;
            m_ObjectID = objectID;
            m_ItemID = itemID;
            m_AssetID = assetID;

            SceneObjectPart part=engine.World.GetSceneObjectPart(localID);
            if(part == null)
            {
                engine.Log.Error("[XEngine] SceneObjectPart unavailable. Script NOT started.");
                return;
            }

            m_LSLCommands = new LSL_ScriptCommands(engine, this, part, localID,
                    itemID);
            m_OSSLCommands = new OSSL_ScriptCommands(engine, this, part,
                    localID, itemID);

            try
            {
                m_Script = (IScript)dom.CreateInstanceAndUnwrap(
                        Path.GetFileNameWithoutExtension(assembly),
                        "SecondLife.Script");
            }
            catch (Exception e)
            {
                m_Engine.Log.ErrorFormat("[XEngine] Error loading assembly {0}\n"+e.ToString(), assembly);
            }

            try
            {
                m_Script.Start(m_LSLCommands, m_OSSLCommands);

                m_Executor = new Executor(m_Script);

//                m_Engine.Log.Debug("[XEngine] Script instance created");

                part.SetScriptEvents(m_ItemID,
                        (int)m_Executor.GetStateEventFlags());
            }
            catch (Exception e)
            {
                m_Engine.Log.Error("Error loading script instance\n"+e.ToString());
            }

            string savedState = assembly+".state";
            if(File.Exists(savedState))
            {
                string xml = String.Empty;

                try
                {
                    FileInfo fi = new FileInfo(savedState);
                    int size=(int)fi.Length;
                    if(size < 130000)
                    {
                        using (FileStream fs = File.Open(savedState,
                                FileMode.Open, FileAccess.Read, FileShare.None))
                        {
                            System.Text.ASCIIEncoding enc =
                                    new System.Text.ASCIIEncoding();

                            Byte[] data=new Byte[size];
                            fs.Read(data, 0, size);

                            xml=enc.GetString(data);

                            ScriptSerializer.Deserialize(xml, this);

                            m_Engine.m_ASYNCLSLCommandManager.CreateFromData(
                                    m_LocalID, m_ItemID, m_ObjectID,
                                    PluginData);
                        }
                    }
                    else
                    {
                        m_Engine.Log.Error("Unable to load script state: Memory limit exceeded");
                        PostEvent(new XEventParams("state_entry",
                                new Object[0], new XDetectParams[0]));
                    }
                }
                catch (Exception e)
                {
                    m_Engine.Log.ErrorFormat("Unable to load script state from xml: {0}\n"+e.ToString(), xml);
                    PostEvent(new XEventParams("state_entry",
                            new Object[0], new XDetectParams[0]));
                }
            }
            else
            {
                PostEvent(new XEventParams("state_entry",
                        new Object[0], new XDetectParams[0]));
            }
            Start();
        }

        public void VarDump(Dictionary<string, object> vars)
        {
            Console.WriteLine("Variable dump for script {0}", m_ItemID.ToString());
            foreach (KeyValuePair<string, object> v in vars)
            {
                Console.WriteLine("Variable: {0} = '{1}'", v. Key,
                        v.Value.ToString());
            }
        }

        public void Start()
        {
            lock(m_EventQueue)
            {
                if(Running)
                    return;

                m_RunEvents=true;

                if(m_EventQueue.Count > 0)
                {
                    if(m_CurrentResult == null)
                        m_CurrentResult=m_Engine.QueueEventHandler(this);
                }
            }
        }

        public bool Stop(int timeout)
        {
            IWorkItemResult result;

            lock(m_EventQueue)
            {
                if(!Running)
                    return true;

                if(m_CurrentResult == null)
                {
                    m_RunEvents=false;
                    return true;
                }

                if(m_CurrentResult.Cancel())
                {
                    m_CurrentResult=null;
                    m_RunEvents=false;
                    return true;
                }

                result=m_CurrentResult;
                m_RunEvents=false;
            }

            if(SmartThreadPool.WaitAll(new IWorkItemResult[] {result}, new TimeSpan((long)timeout*100000), false))
            {
                return true;
            }

            lock(m_EventQueue)
            {
                if(m_CurrentResult != null)
                    m_CurrentResult.Abort();
                else
                    return true;
            }

            return true;
        }

        public void SetState(string state)
        {
            PostEvent(new XEventParams("state_exit", new Object[0],
                    new XDetectParams[0]));
            PostEvent(new XEventParams("state", new Object[] { state },
                    new XDetectParams[0]));
            PostEvent(new XEventParams("state_entry", new Object[0],
                    new XDetectParams[0]));
        }

        public void PostEvent(XEventParams data)
        {
            lock(m_EventQueue)
            {
                if(m_EventQueue.Count >= m_Engine.MaxScriptQueue)
                    return;

                m_EventQueue.Enqueue(data);
                if(data.EventName == "timer")
                {
                    if(m_TimerQueued)
                        return;
                    m_TimerQueued = true;
                }

                if(!m_RunEvents)
                    return;

                if(m_CurrentResult == null)
                {
                    m_CurrentResult=m_Engine.QueueEventHandler(this);
                }
            }
        }

        public object EventProcessor()
        {
            XEventParams data=null;

            lock(m_EventQueue)
            {
                data=(XEventParams)m_EventQueue.Dequeue();
                if(data == null) // Shouldn't happen
                {
                    m_CurrentResult=null;
                    return 0;
                }
                if(data.EventName == "timer")
                    m_TimerQueued = false;
            }

            m_DetectParams=data.DetectParams;

            if(data.EventName == "state") // Hardcoded state change
            {
                m_State=data.Params[0].ToString();
                m_Engine.m_ASYNCLSLCommandManager.RemoveScript(
                        m_LocalID, m_ItemID);

                SceneObjectPart part=m_Engine.World.GetSceneObjectPart(
                        m_LocalID);
                if(part != null)
                {
                    part.SetScriptEvents(m_ItemID,
                            (int)m_Executor.GetStateEventFlags());
                }
            }
            else
            {
//                m_Engine.Log.DebugFormat("[XEngine] Processed event {0}", data.EventName);
                SceneObjectPart part=m_Engine.World.GetSceneObjectPart(
                        m_LocalID);
                try
                {
                    m_EventStart = DateTime.Now;
                    m_InEvent = true;
                    m_Executor.ExecuteEvent(data.EventName, data.Params);
                    m_InEvent = false;
                }
                catch (Exception e)
                {
                    m_InEvent = false;
                    if(e is System.Threading.ThreadAbortException)
                    {
                        lock(m_EventQueue)
                        {
                            if((m_EventQueue.Count > 0) && m_RunEvents)
                            {
                                m_CurrentResult=m_Engine.QueueEventHandler(this);
                            }
                            else
                            {
                                m_CurrentResult=null;
                            }
                        }

                        m_DetectParams=null;

                        return 0;
                    }

                    try
                    {
                        // DISPLAY ERROR INWORLD
                        string text = "Runtime error:\n" + e.ToString();
                        if (text.Length > 1400)
                            text = text.Substring(0, 1400);
                        m_Engine.World.SimChat(Helpers.StringToField(text),
                                ChatTypeEnum.DebugChannel, 2147483647,
                                part.AbsolutePosition,
                                part.Name, part.UUID, false);
                    }
                    catch (Exception e2) // LEGIT: User Scripting
                    {
                        m_Engine.Log.Error("[XEngine]: "+
                                "Error displaying error in-world: " +
                                e2.ToString());
                        m_Engine.Log.Error("[XEngine]: " +
                                "Errormessage: Error compiling script:\r\n" +
                                e.ToString());
                    }
                }
            }

            lock(m_EventQueue)
            {
                if((m_EventQueue.Count > 0) && m_RunEvents)
                {
                    m_CurrentResult=m_Engine.QueueEventHandler(this);
                }
                else
                {
                    m_CurrentResult=null;
                }
            }

            m_DetectParams=null;

            return 0;
        }

        public int EventTime()
        {
            if(!m_InEvent)
                return 0;

            return (DateTime.Now - m_EventStart).Seconds;
        }

        public void ResetScript()
        {
            Stop(0);
            m_Engine.m_ASYNCLSLCommandManager.RemoveScript(m_LocalID, m_ItemID);
            m_EventQueue.Clear();
            m_Script.ResetVars();
            m_State = "default";
            Start();
            PostEvent(new XEventParams("state_entry",
                    new Object[0], new XDetectParams[0]));
        }

        public Dictionary<string, object> GetVars()
        {
            return m_Script.GetVars();
        }

        public void SetVars(Dictionary<string, object> vars)
        {
            m_Script.SetVars(vars);
        }

        public XDetectParams GetDetectParams(int idx)
        {
            if(idx < 0 || idx >= m_DetectParams.Length)
                return new XDetectParams();

            return m_DetectParams[idx];
        }

        public LLUUID GetDetectID(int idx)
        {
            if(idx < 0 || idx >= m_DetectParams.Length)
                return LLUUID.Zero;

            return m_DetectParams[idx].Key;
        }

        public void SaveState(string assembly)
        {
            PluginData =
                    m_Engine.m_ASYNCLSLCommandManager.GetSerializationData(
                    m_ItemID);

            string xml=ScriptSerializer.Serialize(this);

            try
            {
                FileStream fs = File.Create(assembly+".state");
                System.Text.ASCIIEncoding enc = new System.Text.ASCIIEncoding();
                Byte[] buf=enc.GetBytes(xml);
                fs.Write(buf, 0, buf.Length);
                fs.Close();
            }
            catch(Exception)
            {
                return;
            }
        }
    }

    public class ScriptSerializer
    {
        public static string Serialize(XScriptInstance instance)
        {
            instance.Stop(50);

            XmlDocument xmldoc = new XmlDocument();

            XmlNode xmlnode = xmldoc.CreateNode(XmlNodeType.XmlDeclaration,
                    "", "");
            xmldoc.AppendChild(xmlnode);

            XmlElement rootElement = xmldoc.CreateElement("", "ScriptState",
                    "");
            xmldoc.AppendChild(rootElement);

            XmlElement state = xmldoc.CreateElement("", "State", "");
            state.AppendChild(xmldoc.CreateTextNode(instance.State));

            rootElement.AppendChild(state);

            Dictionary<string, Object> vars = instance.GetVars();

            XmlElement variables = xmldoc.CreateElement("", "Variables", "");

            foreach (KeyValuePair<string, Object> var in vars)
                WriteTypedValue(xmldoc, variables, "Variable", var.Key,
                        var.Value);

            rootElement.AppendChild(variables);

            XmlElement queue = xmldoc.CreateElement("", "Queue", "");

            int count = instance.EventQueue.Count;
            
            while(count > 0)
            {
                XEventParams ep = (XEventParams)instance.EventQueue.Dequeue();
                instance.EventQueue.Enqueue(ep);
                count--;

                XmlElement item = xmldoc.CreateElement("", "Item", "");
                XmlAttribute itemEvent = xmldoc.CreateAttribute("", "event",
                        "");
                itemEvent.Value=ep.EventName;
                item.Attributes.Append(itemEvent);

                XmlElement parms = xmldoc.CreateElement("", "Params", "");

                foreach (Object o in ep.Params)
                    WriteTypedValue(xmldoc, parms, "Param", String.Empty, o);

                item.AppendChild(parms);

                XmlElement detect = xmldoc.CreateElement("", "Detected", "");

                foreach (XDetectParams det in ep.DetectParams)
                {
                    XmlElement objectElem = xmldoc.CreateElement("", "Object",
                            "");
                    XmlAttribute pos = xmldoc.CreateAttribute("", "pos", "");
                    pos.Value=det.OffsetPos.ToString();
                    objectElem.Attributes.Append(pos);
                    objectElem.AppendChild(
                            xmldoc.CreateTextNode(det.Key.ToString()));

                    detect.AppendChild(objectElem);
                }

                item.AppendChild(detect);

                queue.AppendChild(item);
            }

            rootElement.AppendChild(queue);

            XmlNode plugins = xmldoc.CreateElement("", "Plugins", "");
            if(instance.PluginData.Length > 0)
                DumpList(xmldoc, plugins,
                        new LSL_Types.list(instance.PluginData));

            rootElement.AppendChild(plugins);

            instance.Start();

            return xmldoc.InnerXml;
        }

        public static void Deserialize(string xml, XScriptInstance instance)
        {
            XmlDocument doc = new XmlDocument();

            Dictionary<string, object> vars = instance.GetVars();

            instance.PluginData = new Object[0];

            doc.LoadXml(xml);
            
            XmlNodeList rootL = doc.GetElementsByTagName("ScriptState");
            if(rootL.Count != 1)
            {
                return;
            }
            XmlNode rootNode = rootL[0];

            if(rootNode != null)
            {
                object varValue;
                XmlNodeList partL = rootNode.ChildNodes;

                foreach (XmlNode part in partL)
                {
                    switch(part.Name)
                    {
                    case "State":
                        instance.State=part.InnerText;
                        break;
                    case "Variables":
                        XmlNodeList varL = part.ChildNodes;
                        foreach (XmlNode var in varL)
                        {
                            string varName;
                            varValue=ReadTypedValue(var, out varName);

                            if(vars.ContainsKey(varName))
                                vars[varName] = varValue;
                        }
                        instance.SetVars(vars);
                        break;
                    case "Queue":
                        XmlNodeList itemL = part.ChildNodes;
                        foreach (XmlNode item in itemL)
                        {
                            List<Object> parms = new List<Object>();
                            List<XDetectParams> detected =
                                    new List<XDetectParams>();

                            string eventName =
                                    item.Attributes.GetNamedItem("event").Value;
                            XmlNodeList eventL = item.ChildNodes;
                            foreach (XmlNode evt in eventL)
                            {
                                switch(evt.Name)
                                {
                                case "Params":
                                    XmlNodeList prms = evt.ChildNodes;
                                    foreach (XmlNode pm in prms)
                                        parms.Add(ReadTypedValue(pm));

                                    break;
                                case "Detected":
                                    XmlNodeList detL = evt.ChildNodes;
                                    foreach (XmlNode det in detL)
                                    {
                                        string vect =
                                                det.Attributes.GetNamedItem(
                                                "pos").Value;
                                        LSL_Types.Vector3 v =
                                                new LSL_Types.Vector3(vect);
                                        LLUUID uuid = new LLUUID();
                                        LLUUID.TryParse(det.InnerText,
                                                out uuid);

                                        XDetectParams d;
                                        d.Key = uuid;
                                        d.OffsetPos = v;

                                        detected.Add(d);
                                    }
                                    break;
                                }
                            }
                            XEventParams ep = new XEventParams(
                                    eventName, parms.ToArray(),
                                    detected.ToArray());
                            instance.EventQueue.Enqueue(ep);
                        }
                        break;
                    case "Plugins":
                        instance.PluginData = ReadList(part).Data;
                        break;
                    }
                }
            }
        }

        private static void DumpList(XmlDocument doc, XmlNode parent,
                LSL_Types.list l)
        {
            foreach (Object o in l.Data)
                WriteTypedValue(doc, parent, "ListItem", "", o);
        }

        private static LSL_Types.list ReadList(XmlNode parent)
        {
            List<Object> olist = new List<Object>();

            XmlNodeList itemL = parent.ChildNodes;
            foreach(XmlNode item in itemL)
                olist.Add(ReadTypedValue(item));

            return new LSL_Types.list(olist.ToArray());
        }

        private static void WriteTypedValue(XmlDocument doc, XmlNode parent,
                string tag, string name, object value)
        {
            Type t=value.GetType();
            XmlAttribute typ = doc.CreateAttribute("", "type", "");
            XmlNode n = doc.CreateElement("", tag, "");

            if(value is LSL_Types.list)
            {
                typ.Value = "list";
                n.Attributes.Append(typ);

                DumpList(doc, n, (LSL_Types.list) value);

                if(name != String.Empty)
                {
                    XmlAttribute nam = doc.CreateAttribute("", "name", "");
                    nam.Value = name;
                    n.Attributes.Append(nam);
                }

                parent.AppendChild(n);
                return;
            }

            n.AppendChild(doc.CreateTextNode(value.ToString()));

            typ.Value = t.ToString();
            n.Attributes.Append(typ);
            if(name != String.Empty)
            {
                XmlAttribute nam = doc.CreateAttribute("", "name", "");
                nam.Value = name;
                n.Attributes.Append(nam);
            }

            parent.AppendChild(n);
        }

        private static object ReadTypedValue(XmlNode tag, out string name)
        {
            name = tag.Attributes.GetNamedItem("name").Value;

            return ReadTypedValue(tag);
        }

        private static object ReadTypedValue(XmlNode tag)
        {
            Object varValue;
            string assembly;

            string itemType = tag.Attributes.GetNamedItem("type").Value;

            if(itemType == "list")
                return ReadList(tag);

            if(itemType == "libsecondlife.LLUUID")
            {
                LLUUID val = new LLUUID();
                LLUUID.TryParse(tag.InnerText, out val);
                
                return val;
            }

            Type itemT = Type.GetType(itemType);
            if(itemT == null)
            {
                Object[] args =
                    new Object[] { tag.InnerText };

                assembly = itemType+", OpenSim.Region.ScriptEngine.XEngine.Script";
                itemT = Type.GetType(assembly);
                if(itemT == null)
                    return null;

                varValue = Activator.CreateInstance(itemT, args);

                if(varValue == null)
                    return null;
            }
            else
            {
                varValue = Convert.ChangeType(tag.InnerText, itemT);
            }
            return varValue;
        }
    }
}