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;

namespace Xenki.DefaultDataControl
{
    public delegate void OnNewPrimitive(uint primid);

    public class DefaultDataControl:IPrimitiveData
    {

        public event OnNewPrimitive onNewPrimitive;

        private readonly Dictionary<uint, Visual3D> m_models = new Dictionary<uint, Visual3D>();
        
        //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> unAttachedTextures = new Dictionary<uint, UUID>();
       
        //private IRendering m_mesher;

        public Dictionary<uint, Visual3D> ModelsInScene
        {
            get { return m_models; }
        }

        public Dictionary<uint, Vector3> ModelsParentPositions
        {
            get { return m_parentPositions; }
        }
        public Dictionary<uint, Primitive> ModelsWaitingParent
        {
            get { return m_modelsWatingParent; }
        }
        //public IRendering Mesher
        //{
        //    set { m_mesher = value; }
        //}

        public Dictionary<uint, UUID> UnAttachedTextures
        {
            get { return unAttachedTextures; }
        }
       
        public void AddNewPrimitive(uint id,Visual3D visual,uint parentID)// Primitive prim)
        { 
            lock (m_models)
            {
                if (m_models.ContainsKey(id))
                    m_models.Remove(id);
                m_models.Add(id,visual);// DefaultRenderer.DefaultUtil.CreateModel(prim, m_mesher));
                if (primitiveParent.ContainsKey(id))
                    primitiveParent.Remove(id);
                primitiveParent.Add(id, parentID);
                        
            }
        }


        /*
        bool Broken =false;
        
        public void AddNewPrimitive(uint id, Primitive prim)
        {
            lock (m_parentPositions)
            {
                m_parentPositions[id] = prim.Position;
            }
            if (Broken)
                return;

            lock (m_models)
            {
                try
                {
                    if (m_models.ContainsKey(id))
                    {
                        m_models.Remove(id);
                    }
                    bool WaitParentIn = true;
                    lock (m_parentPositions)
                    {
                        if (m_parentPositions.ContainsKey(prim.ParentID))
                        {
                            prim.Position += m_parentPositions[prim.ParentID];

                            WaitParentIn = false;
                        }
                        else if (prim.ParentID == 0)
                        {
                            WaitParentIn = false;
                        }
                    }

                    // Add it to the scene appropriately.
                    if (WaitParentIn == false)
                    {
                       ModelVisual3D  model = DefaultRenderer.DefaultUtil.CreateModel(prim,m_mesher);
                         
                        m_models.Add(prim.LocalID,model);

                        foreach (Primitive m in ModelsWaitingParent.Values)
                        {
                            if (m.ParentID == id)
                            {
                                model = DefaultRenderer.DefaultUtil.CreateModel(m, m_mesher);
                                m_models.Add(m.LocalID, model);

                                RemoveWaitingParentPrimitive(m.LocalID);
                            }
                        }
                    }
                    else
                       AddWaitingParentPrimitive(id, prim);

                }
                catch (Exception e)
                {
                    Broken = true;
                }
            }

        }
        */
        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)
            {
                if(m_modelsWatingParent.ContainsKey(id))
                    m_modelsWatingParent.Remove(id);
            }
        }
        public List<Primitive> GetModelsWaitingParent()
        {
           return m_modelsWatingParent.Values.ToList();
        }

        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 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 (unAttachedTextures)
            {
                if (unAttachedTextures.ContainsKey(model) == true)
                    unAttachedTextures.Remove(model);
                unAttachedTextures.Add(model, textureID);
            }
        }

        public List<Visual3D> GetVisualByTextureID(UUID textureID)
        {
            List<Visual3D> list = new List<Visual3D>();
            lock (unAttachedTextures)
            {
                foreach (KeyValuePair<uint,UUID> pair in unAttachedTextures)
                {
                    if (pair.Value == textureID)
                    {
                        if (m_modelsWatingParent.ContainsKey(pair.Key) == true)
                            continue;
                        Visual3D visual = m_models[pair.Key];
                        if (list.Contains(visual) == true)
                            list.Remove(visual);
                        list.Add(visual);
                    }
                }
            }

            return list;
        }
         
    }
}