using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Xenki.Framework;
using System.Windows.Media.Media3D;
using OpenMetaverse;
using OpenMetaverse.Rendering;
using Quaternion = System.Windows.Media.Media3D.Quaternion;
using Material = System.Windows.Media.Media3D.Material;

namespace Xenki.DefaultRenderer
{
    public delegate void OnNewPrimitive(Visual3D visualPrim);

    public class DefaultDataControl
    {
        public static int ModelsCount = 10000;
        public static int ActivePrimCount = 1000;
        public static int TextureCachedCount = 1000;

        //primitives in the scene with visual format
        private readonly Dictionary<uint, Visual3D> m_models = new Dictionary<uint, Visual3D>();
        //primitives in scene with original data format
        private readonly Dictionary<uint, Primitive> m_PrimModelsInScene = new Dictionary<uint, Primitive>();

        //primitives and their parent. key:childlocalid value:parentlocalid
        private readonly Dictionary<uint, uint> primitiveParent = new Dictionary<uint, uint>();

        private readonly Dictionary<uint, Primitive> m_modelsWatingParent = new Dictionary<uint, Primitive>();

        private readonly Dictionary<uint, UUID> m_VisualNeedTextures = new Dictionary<uint, UUID>();
        //texture materials.
        private readonly Dictionary<UUID, Material> m_materials = new Dictionary<UUID, Material>();
        //used for store the models around the first person avatar within a certain distance.
        private readonly Dictionary<uint, Visual3D> m_ActivedModels = new Dictionary<uint, Visual3D>();

        //temp variable store the search result of certain models in scene.
        public Dictionary<uint, Visual3D> workingDictionary_ModelsInscene = new Dictionary<uint, Visual3D>();
        public Dictionary<uint, Visual3D> workingDic_ActivedModels = new Dictionary<uint, Visual3D>();


        public Dictionary<uint, Visual3D>.Enumerator ModelsInScene
        {
            get
            {
                workingDictionary_ModelsInscene.Clear();
                workingDictionary_ModelsInscene = null;

                lock (m_models)
                {
                    workingDictionary_ModelsInscene = m_models.ToDictionary(p => p.Key, v => v.Value);
                }

                return workingDictionary_ModelsInscene.GetEnumerator();
            }
        }

        public Dictionary<uint, Primitive>.Enumerator PrimModelsInScene
        {
            get { return m_PrimModelsInScene.GetEnumerator(); }
        }

        public IEnumerator<Primitive> ModelsWaitingParent
        {
            get { return m_modelsWatingParent.Values.GetEnumerator(); }
        }

        public IEnumerator<uint> ModelsNeedTextures
        {
            get { return m_VisualNeedTextures.Keys.GetEnumerator(); }
        }

        private static readonly DefaultDataControl singleton = new DefaultDataControl();

        public static DefaultDataControl SingleSceneDataManager()
        {
            return singleton;
        }
        private DefaultDataControl() { }

        public void AddNewPrimitive(uint id, Visual3D visual, uint parentID)
        {
            lock (m_models)
            {
                m_models[id] = visual;
                primitiveParent[id] = parentID;
            }
        }

        public bool SceneContainVisual(uint modelid)
        {
            bool b = false;
            lock (m_models)
            {
                b = m_models.ContainsKey(modelid);
            }

            return b;
        }

        public Visual3D GetVisualInScene(uint id)
        {
            Visual3D v = null;
            lock (m_models)
                if (m_models.ContainsKey(id))
                    v = m_models[id];

            return v;
        }

        public void RemoveVisualInScene(uint id)
        {
            lock (m_models)
            {
                m_models.Remove(id);
            }
        }

        public void AddNewPrimitivePrimData(Primitive data)
        {
            lock (m_PrimModelsInScene)
            {
                m_PrimModelsInScene[data.LocalID] = data;
            }
        }
        public void RemovePrimtivePrimData(uint id)
        {
            lock (m_PrimModelsInScene)
                m_PrimModelsInScene.Remove(id);
        }


        public void AddWaitingParentPrimitive(uint id, Primitive data)
        {
            lock (m_modelsWatingParent)
            {
                if (m_modelsWatingParent.ContainsKey(id))
                    m_modelsWatingParent.Remove(id);

                m_modelsWatingParent.Add(id, data);
            }
        }

        public void RemoveWaitingParentPrimitive(uint id)
        {
            lock (m_modelsWatingParent)
            {
                m_modelsWatingParent.Remove(id);
            }
        }
        public IEnumerator<Primitive> GetModelsWaitingParent(uint parentID)
        {
            List<Primitive> list = new List<Primitive>();
            lock (m_modelsWatingParent)
            {
                foreach (Primitive child in m_modelsWatingParent.Values)
                {
                    if (child.ParentID == parentID)
                        list.Add(child);
                }
            }

            return list.GetEnumerator();
        }

        private uint? FindKeyByValue(Visual3D value)
        {
            uint? returnValue = null;
            object obj = value.GetValue(DefaultRenderer.depIdentity);
            if (obj != null)
            {
                returnValue = (uint)obj;
                return returnValue;
            }

            //lock (m_models)
            //{
            //    foreach (KeyValuePair<uint, Visual3D> pair in m_models)
            //    {
            //        if (pair.Value.Equals(value))
            //            returnValue = pair.Key;
            //    }
            //}
            return returnValue;
        }

        public uint? GetKeyInSceneByValue(Visual3D visual)
        {
            return FindKeyByValue(visual);
        }

        public IEnumerator<Visual3D> GetChildrenByVisual3D(Visual3D parent)
        {
            uint? key = FindKeyByValue(parent);
            if (key.HasValue == false)
                return new List<Visual3D>.Enumerator();

            List<Visual3D> children = new List<Visual3D>();
            foreach (KeyValuePair<uint, uint> child in primitiveParent)
            {
                if (child.Value == key.Value)
                    children.Add(m_models[child.Key]);
            }
            return children.GetEnumerator();
        }

        public void AddNeedTextureModel(uint model, UUID textureID)
        {
            lock (m_VisualNeedTextures)
            {
                if (m_VisualNeedTextures.ContainsKey(model) == true)
                    m_VisualNeedTextures.Remove(model);
                m_VisualNeedTextures.Add(model, textureID);
            }
        }
        public void RemoveUnAttachedTexture(uint model)
        {
            lock (m_VisualNeedTextures)
            {
                if (m_VisualNeedTextures.ContainsKey(model))
                    m_VisualNeedTextures.Remove(model);
            }
        }

        public IEnumerator<Primitive> GetVisualByTextureID(UUID textureID)
        {
            List<Primitive> list = new List<Primitive>();
            lock (m_VisualNeedTextures)
            {
                foreach (KeyValuePair<uint, UUID> pair in m_VisualNeedTextures)
                {
                    if (pair.Value == textureID)
                    {
                        if (m_modelsWatingParent.ContainsKey(pair.Key) == true)
                            continue;

                        lock (m_PrimModelsInScene)
                        {
                            if (m_PrimModelsInScene.ContainsKey(pair.Key) == false)
                                continue;
                            list.Add(m_PrimModelsInScene[pair.Key]);
                        }
                    }
                }
            }

            return list.GetEnumerator();
        }

        //public void AddModelsParentPositions(uint id, Vector3 pos)
        //{
        //    lock (m_parentPositions)
        //    {
        //        if (m_parentPositions.ContainsKey(id))
        //            m_parentPositions[id] = pos;
        //        else
        //            m_parentPositions.Add(id, pos);
        //    }
        //}
        //public Vector3 GetModelsParentPosition(uint id)
        //{
        //    Vector3 vec = new Vector3();
        //    lock (m_parentPositions)
        //    {
        //        if (m_parentPositions.ContainsKey(id))
        //            vec = m_parentPositions[id];
        //    }
        //    return vec;
        //}

        public Primitive GetParentRotation(uint parentid)
        {
            uint temp = parentid;
            lock (m_PrimModelsInScene)
                while (m_PrimModelsInScene.ContainsKey(parentid))
                {
                    temp = parentid;
                    parentid = m_PrimModelsInScene[parentid].ParentID;
                }

            return m_PrimModelsInScene[temp];
        }

        public void AddNewMaterial2Cache(UUID textureID, System.Windows.Media.Media3D.Material material)
        {
            lock (m_materials)
            {
                if (m_materials.ContainsKey(textureID) == false)
                {
                    m_materials.Add(textureID, material);
                }
            }
        }
        public Material GetMaterialFromCache(UUID textureID)
        {
            Material m = null;
            lock (m_materials)
                if (m_materials.ContainsKey(textureID))
                    m = m_materials[textureID];


            return m;
        }
        public void RemoveMaterialFromCache(UUID textureID)
        {
            lock (m_materials)
            {
                m_materials.Remove(textureID);
            }
        }

        public void AddActiveModel(Visual3D v)
        {
            uint? key = FindKeyByValue(v);
            if (key.HasValue)
            {
                lock (m_ActivedModels)
                {
                    if (m_ActivedModels.ContainsKey(key.Value))
                        m_ActivedModels.Remove(key.Value);
                    m_ActivedModels.Add(key.Value, v);
                }
            }
        }

        public void RemoveActiveModel(Visual3D v)
        {
            uint? key = FindKeyByValue(v);
            if (key.HasValue)
            {
                lock (m_ActivedModels)
                {
                    m_ActivedModels.Remove(key.Value);
                }
            }

        }

        public Dictionary<uint, Visual3D>.Enumerator GetActivedModelList()
        {
            workingDic_ActivedModels.Clear();

            lock (m_ActivedModels)
                workingDic_ActivedModels = m_ActivedModels.ToDictionary(p => p.Key, v => v.Value);

            return workingDic_ActivedModels.GetEnumerator();
        }

        public Visual3D GetActivedModel(uint localid)
        {
            lock (m_ActivedModels)
                if (m_ActivedModels.ContainsKey(localid))
                    return m_ActivedModels[localid];

            return null;
        }


        public Primitive GetPrimInScene(uint localid)
        {
            lock (m_PrimModelsInScene)
            {
                if (m_PrimModelsInScene.ContainsKey(localid) == false)
                    return null;
            }

            return m_PrimModelsInScene[localid];
        }
        public void RemovePrimInScene(uint localid)
        {
            lock (m_PrimModelsInScene)
                m_PrimModelsInScene.Remove(localid);
        }
        public Dictionary<uint, Primitive>.Enumerator GetPrimChildrenInScene(uint parentid)
        {
            Dictionary<uint, Primitive> result = new Dictionary<uint, Primitive>();
            foreach (KeyValuePair<uint, uint> value in primitiveParent)
                if (value.Value == parentid)
                {

                    lock (m_PrimModelsInScene)
                    {
                        result.Add(value.Key, m_PrimModelsInScene[value.Key]);
                    }
                }
            return result.GetEnumerator();
        }

        #region Friends

        private Dictionary<string, Friend> FriendList = new Dictionary<string, Friend>();

        #endregion
    }
}