using System;
using System.Collections.Generic;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Media;
using System.Windows.Media.Media3D;
using System.Windows.Threading;
using OpenMetaverse;
using OpenMetaverse.Rendering;
using Xenki.Framework;
using Quaternion=System.Windows.Media.Media3D.Quaternion;
using System.IO;
using System.Windows.Media.Imaging;
using OpenMetaverse.Imaging;
using Material = System.Windows.Media.Media3D.Material;

namespace Xenki.DefaultRenderer
{
    class DefaultRenderer : IRenderer 
    {
        private readonly Viewport3D m_viewport;
        private readonly PerspectiveCamera m_camera;
        private CameraControl m_cameracontrol;
        private IRendering m_mesher;
        private ITextureManage m_textureManager;

        public ITextureManage TextureManager
        {
            set { m_textureManager = value; }
        }

        private bool Broken;

        private readonly Point3D[,] m_heightmapPoints = new Point3D[256,256];
        private double[,] m_heightmap = new double[256,256];
        private ModelVisual3D m_terrain;

        private readonly Dictionary<uint, Visual3D> m_models = new Dictionary<uint, Visual3D>();
        private readonly Dictionary<uint, Vector3> m_parentPositions = new Dictionary<uint, Vector3>();
        

        private readonly Material m_defaultMaterial;
        private readonly DiffuseMaterial m_terrainMaterial;

        public DefaultRenderer(Viewport3D m_viewport)
        {
            // Viewport
            this.m_viewport = m_viewport;
           // m_viewport.ClipToBounds = false;
            m_viewport.IsHitTestVisible = true;

            // Camera Issues
            Point3D CameraPos = new Point3D(0,0,50);
            Point3D CameraLook = new Point3D(128,128,10);

            m_camera = new PerspectiveCamera(new Point3D(0, 0, 0), new Vector3D(0, 0, 0),
                                             new Vector3D(0, 0, 1), 90);
            
            m_camera.Position = CameraPos;
            m_camera.LookDirection = new Vector3D(CameraLook.X - m_camera.Position.X, CameraLook.Y - m_camera.Position.Y, CameraLook.Z - m_camera.Position.Z); 

            m_camera.FarPlaneDistance = 1024;
            m_camera.NearPlaneDistance = 0.01;
            m_viewport.Camera = m_camera;

            // Setup Camera Control
            m_cameracontrol = new CameraControl(m_camera);
           // m_camera.Transform = m_cameracontrol.Transform;
            m_cameracontrol.EventSource = m_viewport;
             
            // Default Material Properties
            m_defaultMaterial = new DiffuseMaterial(
                new SolidColorBrush(Colors.DarkKhaki));

            GradientBrush terGrad = new RadialGradientBrush(Colors.ForestGreen, Colors.SandyBrown);
            m_terrainMaterial = new DiffuseMaterial(
                terGrad);

            // Scene Lighting
            ModelVisual3D lights = new ModelVisual3D();
            lights.Content = new DirectionalLight(Colors.White, new Vector3D(-20, -30, -10));

            ModelVisual3D point = new ModelVisual3D();
            PointLight pointLight = new PointLight(Colors.WhiteSmoke, new Point3D(128, 128, 80));
            point.Content = pointLight;

            ModelVisual3D ambient = new ModelVisual3D();
            AmbientLight ambientLight = new AmbientLight(Color.FromArgb(0xFF, 0x40, 0x40, 0x40));
            ambient.Content = ambientLight;
            
            m_viewport.Children.Add(lights);
            m_viewport.Children.Add(point);
            m_viewport.Children.Add(ambient);


            // Terrain Base
            for(int x=0;x<256;x++)
            {
                for(int y=0;y<256;y++)
                {
                    m_heightmap[x, y] = 30.0;
                }
            }

            m_terrain = CreateTerrain(m_heightmap);
            m_viewport.Children.Add(m_terrain);

            // Water Plane
            SolidColorBrush brush = new SolidColorBrush(Color.FromArgb(128, 0, 128, 255));
            DiffuseMaterial material = new DiffuseMaterial(brush);

            //m_viewport.Children.Add(DefaultUtil.CreateCube(new Point3D(0,0,0), new Point3D(256,256,20),
            //    material));
        }
    
        public IRendering Mesher
        {
            set { m_mesher = value; }
        }

        public void AddPrimitive(uint id, Primitive data)
        {
           //lock (DefaultNetwork.DefaultNetwork.m_primitiveData.ModelsParentPositions)
            {
               // DefaultNetwork.DefaultNetwork.m_primitiveData.ModelsParentPositions[id] = data.Position;
            }
          
            if(Broken)
                return;

            m_viewport.Dispatcher.Invoke(
                DispatcherPriority.Normal,
                new System.Windows.Forms.MethodInvoker
                    (delegate
                         {
                             //lock (DefaultNetwork.DefaultNetwork.m_primitiveData.ModelsInScene)
                             {
                                 try
                                 {
                                     bool WaitParentIn = true;

                                     lock (DefaultNetwork.DefaultNetwork.m_primitiveData.ModelsParentPositions)
                                     {
                                         if (data.ParentID<=0)
                                         {
                                             WaitParentIn = false;
                                         }
                                         else if (DefaultNetwork.DefaultNetwork.m_primitiveData.ModelsParentPositions.ContainsKey(data.ParentID))
                                         {
                                             data.Position += DefaultNetwork.DefaultNetwork.m_primitiveData.ModelsParentPositions[data.ParentID];

                                             WaitParentIn = false;
                                         }

                                         DefaultNetwork.DefaultNetwork.m_primitiveData.ModelsParentPositions[id] = data.Position;
                                     }

                                     if (WaitParentIn == false)
                                     {
                                         ModelVisual3D model = CreateModel(data);
                                         if (model == null)
                                             return;
                                         m_viewport.Children.Add(model);
                                         DefaultNetwork.DefaultNetwork.m_primitiveData.AddNewPrimitive(id,model,data.ParentID);
                                         DefaultNetwork.DefaultNetwork.m_primitiveData.AddNewPrimitivePrimData(data);

                                         List<Primitive> waiting = DefaultNetwork.DefaultNetwork.m_primitiveData.GetModelsWaitingParent(data.LocalID);

                                         for (int i = 0; i < waiting.Count; i++)
                                         {
                                             Primitive child = waiting[i];
                                             
                                             lock( DefaultNetwork.DefaultNetwork.m_primitiveData.ModelsParentPositions)
                                                 DefaultNetwork.DefaultNetwork.m_primitiveData.ModelsParentPositions[child.LocalID] = child.Position;

                                            
                                             model = CreateModel(child);
                                             if (model == null)
                                                 return;
                                             
                                             child.Position += data.Position;
                                             m_viewport.Children.Add(model);

                                             DefaultNetwork.DefaultNetwork.m_primitiveData.AddNewPrimitive(id, model, waiting[i].ParentID);
                                             DefaultNetwork.DefaultNetwork.m_primitiveData.AddNewPrimitivePrimData(child); 
                                             DefaultNetwork.DefaultNetwork.m_primitiveData.RemoveWaitingParentPrimitive(waiting[i].LocalID);
                                         }
                                     }
                                     else
                                         DefaultNetwork.DefaultNetwork.m_primitiveData.AddWaitingParentPrimitive(id, data);

                                 }
                                 catch (Exception e)
                                 {
                                     MessageBox.Show(e.ToString());
                                     Broken = true;
                                 }
                             }
                         }
                    )
                );
        }

        private ModelVisual3D CreateTerrain(double[,] map)
        {
            MeshGeometry3D mesh = new MeshGeometry3D();

            for (int y = 0; y < 256; y++)
            {
                for (int x = 0; x < 256; x++)
                {
                    m_heightmapPoints[y, x] = new Point3D(x, y, map[x, y]);
                    mesh.Positions.Add(m_heightmapPoints[y, x]);

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

            for(int x=0;x<255;x++)
            {
                for(int y=0;y<255;y++)
                {
                    int p0 = (x*256) + y;
                    int p1 = (x*256) + (y + 1);
                    int p2 = ((x + 1)*256) + y;
                    int p3 = ((x + 1)*256) + (y + 1);


                    // Δ 013 |\
                    mesh.TriangleIndices.Add(p1); //#0

                    mesh.TriangleIndices.Add(p3); //#1

                    mesh.TriangleIndices.Add(p2); //#3

                    
                    // Δ 023
                    mesh.TriangleIndices.Add(p0); //#0

                    mesh.TriangleIndices.Add(p1); //#2

                    mesh.TriangleIndices.Add(p2); //#3
                    

                    
                }
            }

            GeometryModel3D triangleModel = new GeometryModel3D(
                mesh, m_terrainMaterial);

            ModelVisual3D model = new ModelVisual3D();
            model.Content = triangleModel;

            return model;
        }

        private ModelVisual3D CreateModel(Primitive data)
        {
            
            //SimpleMesh basic = m_mesher.GenerateSimpleMesh(data, DetailLevel.Medium);
            FacetedMesh faceMesh = m_mesher.GenerateFacetedMesh(data, DetailLevel.Medium);

            // Translation
            TranslateTransform3D tt = new TranslateTransform3D(
                new Vector3D(data.Position.X, data.Position.Y, data.Position.Z)
                );

            Quaternion rot = new Quaternion(data.Rotation.X, data.Rotation.Y, data.Rotation.Z, data.Rotation.W);

            RotateTransform3D rt = new RotateTransform3D(
                new AxisAngleRotation3D(rot.Axis, rot.Angle)
                );

            // Scale
            ScaleTransform3D st = new ScaleTransform3D(
                new Vector3D(data.Scale.X, data.Scale.Y, data.Scale.Z));

            //foreach (Vertex v in basic.Vertices)
            //{
            //    Point3D d = new Point3D(
            //        v.Position.X,
            //        v.Position.Y,
            //        v.Position.Z);

            //    // Scale
            //    d = st.Transform(d);
            //    // Rotate
            //    d = rt.Transform(d);
            //    // Move
            //    d = tt.Transform(d);

            //    mesh.Positions.Add(d);  
            //    // These normals dont appear to be working for some reason,
            //    // however the auto-generated normals appear adequate for now.
            //    //mesh.Normals.Add(new Vector3D(v.Normal.X, v.Normal.Y, v.Normal.Z));
            //    mesh.TextureCoordinates.Add(new Point(v.TexCoord.X, v.TexCoord.Y));
            //}

            //foreach (ushort ind in basic.Indices)
            //{
            //    mesh.TriangleIndices.Add(ind);
            //}
            ModelVisual3D model = new ModelVisual3D();
            GeometryModel3D triangleModel = new GeometryModel3D();
           
            // Draw the prim faces
            for (int j = 0; j < faceMesh.Faces.Count; j++)
            {
                MeshGeometry3D mesh = new MeshGeometry3D();
                Face face = faceMesh.Faces[j];
                
                foreach (Vertex v in face.Vertices)
                {
                    Point3D d = new Point3D(
                   v.Position.X,
                   v.Position.Y,
                   v.Position.Z);

                    // Scale
                    d = st.Transform(d);
                    // Rotate
                    d = rt.Transform(d);
                    // Move
                    d = tt.Transform(d);

                    mesh.Positions.Add(d);
                    // These normals dont appear to be working for some reason,
                    // however the auto-generated normals appear adequate for now.
                    //mesh.Normals.Add(new Vector3D(v.Normal.X, v.Normal.Y, v.Normal.Z));
                   // mesh.TextureCoordinates.Add(new Point(v.TexCoord.X, v.TexCoord.Y));
                }
                mesh.TextureCoordinates.Add(new Point(0, 0));
                mesh.TextureCoordinates.Add(new Point(1, 0));
                mesh.TextureCoordinates.Add(new Point(0, 1));
                mesh.TextureCoordinates.Add(new Point(1, 1));

                //mesh.TextureCoordinates.Add(new Point(0, 0));
                //mesh.TextureCoordinates.Add(new Point(1, 0));
                //mesh.TextureCoordinates.Add(new Point(0, 1));
                //mesh.TextureCoordinates.Add(new Point(1, 1));

                foreach (ushort ind in face.Indices)
                {
                    mesh.TriangleIndices.Add(ind);
                }
                Color col = Colors.YellowGreen;
                if (face.TextureFace.TextureID != null)
                {
                    ModelVisual3D visual = new ModelVisual3D();

                    string bitmapPath = System.IO.Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "texture\\" + face.TextureFace.TextureID.ToString() + ".bmp");
                    if (File.Exists(bitmapPath) == false)
                    {
                        col = Color.FromScRgb(data.Textures.DefaultTexture.RGBA.A,
                                      data.Textures.DefaultTexture.RGBA.R,
                                      data.Textures.DefaultTexture.RGBA.G,
                                      data.Textures.DefaultTexture.RGBA.B);

                        triangleModel = new GeometryModel3D(
                            mesh, new DiffuseMaterial(new SolidColorBrush(col)));
                        visual.Content = triangleModel;

                        model.Children.Add(visual);
                        //ADD the visual to the needUpdateTexute list.when the texture downloaded update it.
                        DefaultNetwork.DefaultNetwork.m_primitiveData.AddUnAttachedTexture(data.LocalID, data.Textures.DefaultTexture.TextureID);
                        continue;
                    }
                    ImageSource imagesource = new BitmapImage(new Uri(bitmapPath));
                    ImageBrush brush = new ImageBrush(imagesource);

                    triangleModel = new GeometryModel3D(
                        mesh, new DiffuseMaterial(brush));
                    visual.Content = triangleModel;

                    model.Children.Add(visual);
                }
            } 
           

            //if (data.Textures != null &&
            //    data.Textures.FaceTextures != null &&
            //    data.Textures.FaceTextures.Length > 0)
            //{

            //    string bitmapPath = System.IO.Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "texture\\" + data.Textures.DefaultTexture.TextureID.ToString() + ".bmp");

            //    if (File.Exists(bitmapPath))
            //    {
            //        ImageSource imagesource = new BitmapImage(new Uri(bitmapPath));

            //        ImageBrush brush = new ImageBrush(imagesource);
            //        triangleModel = new GeometryModel3D(
            //            mesh, new DiffuseMaterial(brush));
            //    }
            //    else
            //    {
            //        col = Color.FromScRgb(data.Textures.DefaultTexture.RGBA.A,
            //                             data.Textures.DefaultTexture.RGBA.R,
            //                             data.Textures.DefaultTexture.RGBA.G,
            //                             data.Textures.DefaultTexture.RGBA.B);

            //        triangleModel = new GeometryModel3D(
            //            mesh, new DiffuseMaterial(new SolidColorBrush(col)));

            //    }
            //}
            //else
            //{
            //    col = Color.FromScRgb(data.Textures.DefaultTexture.RGBA.A,
            //                          data.Textures.DefaultTexture.RGBA.R,
            //                          data.Textures.DefaultTexture.RGBA.G,
            //                          data.Textures.DefaultTexture.RGBA.B);

            //    triangleModel = new GeometryModel3D(
            //        mesh, new DiffuseMaterial(new SolidColorBrush(col)));

            //    //ADD the visual to the needUpdateTexute list.when the texture downloaded update it.
            //    DefaultNetwork.DefaultNetwork.m_primitiveData.AddUnAttachedTexture(data.LocalID, data.Textures.DefaultTexture.TextureID);
            //}



            //*/
            /*
            GradientBrush Grad = new LinearGradientBrush(Colors.Red, Colors.Blue, 90);
            Material mat = new DiffuseMaterial(Grad);
            
            triangleModel = new GeometryModel3D(
                mesh, mat);
            */
            
            //model.Content = triangleModel;

            return model;
        }

        public void UpdatePrimTexture(UUID textureID)
        {
            List<Primitive> NeedUpdateVisuals = DefaultNetwork.DefaultNetwork.m_primitiveData.GetVisualByTextureID(textureID);

            foreach (Primitive visual in NeedUpdateVisuals)
            {
                AddPrimitive(visual.LocalID, visual);
            //    visual.Dispatcher.Invoke(
            //        DispatcherPriority.Normal,
            //        new System.Windows.Forms.MethodInvoker(delegate
            //    {
            //        ModelVisual3D model = visual as ModelVisual3D;
            //        if (model == null)
            //            return;
            //        GeometryModel3D gTexture = model.Content as GeometryModel3D;
            //        if (gTexture == null)
            //            return;
            //        string bitmapPath = System.IO.Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "texture\\" + textureID.ToString() + ".bmp");

            //        if (File.Exists(bitmapPath))
            //        {
            //            try
            //            {
            //                ImageSource imagesource = new BitmapImage(new Uri(bitmapPath));
            //                ImageBrush brush = new ImageBrush(imagesource);
            //                gTexture.Material = new DiffuseMaterial(brush);

            //                model.Content = gTexture;

            //                uint? key = DefaultNetwork.DefaultNetwork.m_primitiveData.GetKeyInSceneByValue(model);
            //                if (key.HasValue)
            //                    DefaultNetwork.DefaultNetwork.m_primitiveData.RemoveUnAttachedTexture(key.Value);
            //            }
            //            catch (Exception er)
            //            {
            //                MessageBox.Show(er.ToString());
            //            }
            //        }

            //    }));
            }


        }

        public void RemovePrimitive(uint id)
        {
            m_viewport.Dispatcher.Invoke(
                DispatcherPriority.Normal,
                new System.Windows.Forms.MethodInvoker
                    (delegate
                         {
                             if(m_models.ContainsKey(id))
                             {
                                 // Remove from scene and models list
                                 m_viewport.Children.Remove(m_models[id]);
                                 m_models.Remove(id);
                             }
                         }
                    )
                );
        }

        public void SetTerrain(int x, int y, double val)
        {
            m_heightmap[x, y] = val;
        }

        public void SetTerrain(double[,] map)
        {
            m_heightmap = map;

            m_viewport.Dispatcher.Invoke(
                DispatcherPriority.Normal,
                new System.Windows.Forms.MethodInvoker
                    (delegate
                         {
                             m_viewport.Children.Remove(m_terrain);
                             m_terrain = CreateTerrain(map);
                             m_viewport.Children.Add(m_terrain);
                         }
                    )
                );
        }
    }
}