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 DefaultPrimControl
    {
        //private GridClient m_Client;
        //private IRendering m_mesher;
        //public IRendering Mesher
        //{
        //    set { m_mesher = value; }
        //}
        //public GridClient Client
        //{
        //    get { return m_Client; }
        //    set { if (value != null) InitializeClient(value); }
        //}

        //private void InitializeClient(GridClient value)
        //{
        //    m_Client = value;
        //    m_Client.Objects.OnNewPrim += new ObjectManager.NewPrimCallback(Objects_OnNewPrim);
        //}

        //void Objects_OnNewPrim(Simulator simulator, Primitive prim, ulong regionHandle, ushort timeDilation)
        //{
        //    Visual3D visualPrim = CreateModel(prim);
        //    bool waitParent = true;
        //    lock (m_models)
        //    {
        //        if (m_models.ContainsKey(prim.LocalID))
        //            m_models.Remove(prim.LocalID);
        //        m_models.Add(prim.LocalID, visualPrim);

        //        if (prim.ParentID == 0)
        //            waitParent = false;
        //        else if (m_models.ContainsKey(prim.ParentID))
        //            waitParent = false;
        //    }
        //    lock (m_PrimModelsInScene)
        //    {
        //        if (false == m_PrimModelsInScene.ContainsKey(prim.LocalID))
        //            m_PrimModelsInScene.Add(prim.LocalID, prim);
        //    }
        //    if (waitParent == false)//notify Viewport to add visual
        //        if (onNewPrimitive != null)
        //            onNewPrimitive(visualPrim);
        //}

        private Visual3D CreateModel(Primitive data)
        {
            Visual3D model = null;
           //SimpleMesh basic = m_mesher.GenerateSimpleMesh(data, DetailLevel.Medium);
           // lock (m_primitiveData.PrimModelsInScene)
           //     if (m_primitiveData.PrimModelsInScene.ContainsKey(data.ParentID))
           //     {
           //         Primitive parent = m_primitiveData.PrimModelsInScene[data.ParentID];
           //         data.Position *= parent.Rotation;
           //         data.Position += parent.Position;
           //     }

           // mesh = new MeshGeometry3D();
           // triangleModel = new GeometryModel3D();
           // foreach (Vertex v in basic.Vertices)
           // {
           //     Vector3 pos = v.Position;
           //     pos *= data.Scale;
           //     pos *= data.Rotation;//there's something wrong about rotation
           //     pos += data.Position;
           //     Point3D d = new Point3D(pos.X, pos.Y, pos.Z);
           //     mesh.Positions.Add(d);
           //     // These normals dont appear to be working for some reason,
           //     // however the auto-generated normals appear adequate for now.
           //     //Vector3D normal = new Vector3D(v.Normal.X, v.Normal.Y, v.Normal.Z);
           //     //mesh.Normals.Add(normal);
           //     double x = (v.Position.Length() == float.Parse("0")) ? 0 : (v.Position.X / v.Position.Length());
           //     double y = (v.Position.Length() == float.Parse("0")) ? 0 : (v.Position.Y / v.Position.Length());

           //     mesh.TextureCoordinates.Add(new Point(x, y));
           // }

           // foreach (ushort ind in basic.Indices)
           // {
           //     mesh.TriangleIndices.Add(ind);
           // }

           // triangleModel = PatchTexture(data, mesh, triangleModel);

           // model = new ModelVisual3D();
           // model.Content = triangleModel;
           // model.SetValue(dep, data.LocalID);

           // m_primitiveData.AddNewPrimitivePrimData(data);
           // m_primitiveData.RemoveWaitingParentPrimitive(data.LocalID);

             return model;
        }

        public event OnNewPrimitive onNewPrimitive;
        
        //data
        private readonly Dictionary<uint, Visual3D> m_models = new Dictionary<uint, Visual3D>();
        private readonly Dictionary<uint, Primitive> m_PrimModelsInScene = new Dictionary<uint, Primitive>();

        //key:children key value:parent
        private readonly Dictionary<uint, uint> primitiveParent = new Dictionary<uint, uint>();

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

        private readonly Dictionary<uint, UUID> m_VisualNeedTextures = new Dictionary<uint, UUID>();

        private readonly Dictionary<UUID, Material> m_materials = new Dictionary<UUID, Material>();

        public Dictionary<uint, Visual3D> ModelsInScene
        {
            get { return m_models; }
        }
        public Dictionary<uint, Primitive> PrimModelsInScene
        {
            get { return m_PrimModelsInScene; }
        }
        //public Dictionary<uint, Vector3> ModelsParentPositions
        //{
        //    get { return m_parentPositions; }
        //}
        public Dictionary<uint, Primitive> ModelsWaitingParent
        {
            get { return m_modelsWatingParent; }
        }

        public Dictionary<uint, UUID> UnAttachedTextures
        {
            get { return m_VisualNeedTextures; }
        }

       private static readonly DefaultPrimControl singleton = new DefaultPrimControl();

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

        public void AddNewPrimitive(uint id,Visual3D visual,uint parentID)// Primitive prim)
        { 
            lock (m_models)
            {
                m_models[id] = visual;
                primitiveParent[id] = parentID;
            }
        }
        public bool SceneContainVisual(uint primid)
        {
            bool b = false;
            lock (m_models)
            {
                b = m_models.ContainsKey(primid);
            }

            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[id] = null;
               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 List<Primitive> GetModelsWaitingParent(uint parentID)
        {
            List<Primitive> list = new List<Primitive>();
            lock (m_modelsWatingParent)
            {
                foreach (Primitive child in m_modelsWatingParent.Values)
                {
                    if (child.ParentID == 0)
                        throw new Exception("goooooooood");
                    if (child.ParentID == parentID)
                        list.Add(child);
                }
            }
            //lock (primitiveParent)
            //{
            //    if (primitiveParent.ContainsValue(parentID))
            //    { 
                     
            //    }
            //}
            return list;
        }

        private uint? FindKeyByValue(Visual3D value)
        { 
            uint? returnValue=null;
            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 List<Visual3D> GetChildrenByVisual3D(Visual3D parent)
        {
            uint? key = FindKeyByValue(parent);
            if (key.HasValue == false)
                return new List<Visual3D>();

            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;
        }

        public void AddUnAttachedTexture( 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 List<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;
                            Primitive prim = m_PrimModelsInScene[pair.Key];
                            if (list.Contains(prim) == true)
                                list.Remove(prim);
                            list.Add(prim);
                        }
                    }
                }
            }

            return list;
        }

        //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);
            }
        }
    }
}