using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Blacklight.Core;
using Blacklight.Core.Drawables;
using Blacklight.Core.Cameras;
using Azimuth;
using Annulus.CSG;

namespace Blacklight.Testbed
{
    public class World
    {
        Blacklight.Core.Cameras.MicroscopeCamera camera = null;
        
        Scene scene = new Scene();
        Cel cel = new Cel();
        Entity entity = new Entity();
        Collage collage = new Collage();

        WindowHandle viewport = null;

        public World()
        {
            scene.Cels.Add(cel);
            entity.drawable = collage;
            entity.modelToWorld = Matrix.Identity;
            cel.AddEntity(entity);

            Matrix transform;
            DrawPrimitive primitive;
            Matrix rotateBy45degrees = new Matrix(Math.PI / 2, Vector.Zero);

            {
                primitive = new Rectangle();
                primitive.InsideColor = new Blacklight.Core.Color(1, 0, 0.5, 1);
                primitive.ShellColor = new Blacklight.Core.Color(0, 1, 0.5, 1);
                primitive.ShellModelSpaceThickness = 0.1;
                primitive.ShellPixelThickness = 3;
                transform = new Matrix(.7, new Vector(50, 50), 10);
                primitive.Antialiased = true;
                transform.M00 *= 1.112233;
                transform.M01 *= 3;
                transform.M10 *= 4;
                transform.M11 *= 10;
                transform = rotateBy45degrees * transform;


                collage.AddDrawable(primitive, transform);
            }

            {
                primitive = new Rectangle();
                primitive.InsideColor = new Blacklight.Core.Color(1, 0, 0.5, 1);
                primitive.ShellColor = new Blacklight.Core.Color(0, 1, 0.5, 1);
                primitive.ShellPixelThickness = 20;
                transform = new Matrix(.7, new Vector(-150, -150), 10);
                transform.M00 *= 1.112233;
                transform.M01 *= 3;
                transform.M10 *= 4;
                transform.M11 *= 10;
                transform = rotateBy45degrees * transform;
                primitive.Antialiased = true;
                collage.AddDrawable(primitive, transform);
            }

            {
                primitive = new Ellipse();
                primitive.InsideColor = new Blacklight.Core.Color(1, 0, 0.5, 1);
                primitive.ShellColor = new Blacklight.Core.Color(0, 1, 0.5, 1);
                //primitive.ShellModelSpaceThickness = 0.1;
                primitive.ShellPixelThickness = 2;
                transform = new Matrix(0, new Vector(50, -200), 10);
                primitive.Antialiased = true;
                //transform.M00 *= 1.001;
                //transform.M10 *= 2;

                //transform.M01 *= 0.3;
                //transform.M11 *= 0.3;
                /*transform.M00 *= 1.112233;
                transform.M01 *= 3;
                transform.M10 *= 4;
                transform.M11 *= 10;*/
                //transform = rotateBy45degrees * transform;


                collage.AddDrawable(primitive, transform);
            }

            {
                primitive = new Ellipse();
                primitive.InsideColor = new Blacklight.Core.Color(1, 0, 0, 0);
                primitive.ShellColor = new Blacklight.Core.Color(0, 1, 0.5, 1);
                primitive.ShellPixelThickness = 2;
                //primitive.ShellModelSpaceThickness = 0.1;
                transform = new Matrix(.7, new Vector(50, -400), 10);
                transform.M00 *= 1.112233;
                transform.M01 *= 3;
                transform.M10 *= 4;
                transform.M11 *= 10;
                transform = rotateBy45degrees * transform;
                primitive.Antialiased = true;
                collage.AddDrawable(primitive, transform);
            }

            {
                const int levels = 31;
                ulong runningSum = 0;
                const ulong divisor = 0x1 << (levels / 2);
                int j = levels - 1;
                for (int i = levels / 2; i >= -levels / 2; --i, --j)
                {
                    ulong currentLevel = (ulong)(0x1 << j);

                    double radius = (double)(currentLevel) / (double)(divisor);

                    primitive = new Ellipse();
                    primitive.InsideColor = new Blacklight.Core.Color(1, 1, 0, 0.5);
                    primitive.ShellColor = new Blacklight.Core.Color(0, 1, 1, 0.5);
                    //primitive.ShellPixelThickness = ;
                    primitive.ShellModelSpaceThickness = 0.5;
                    transform = new Matrix(0, new Vector(250 + (double)runningSum / (double)divisor + radius, 150), radius);
                    primitive.Antialiased = true;
                    collage.AddDrawable(primitive, transform);

                    runningSum += 2 * currentLevel;
                }
            }

            // Test triangle
            {
                primitive = new Triangle();
                primitive.InsideColor = new Blacklight.Core.Color(1, 1, 1, 1);
                primitive.ShellColor = new Blacklight.Core.Color(0, 0, 0, 1);
                primitive.ShellPixelThickness = 2;
                primitive.ShellModelSpaceThickness = 0.1;
                transform = new Matrix(.7, new Vector(50, -400), 10);
                transform.M00 *= 1.112233;
                transform.M01 *= 3;
                transform.M10 *= 4;
                transform.M11 *= 10;
                transform = rotateBy45degrees * transform;
                primitive.Antialiased = true;
                collage.AddDrawable(primitive, transform);
            }

            // Test polygon
            {
                var expectedVerts = new Annulus.Polygon(new Vector[]
                {
                    new Vector(0, 2),
                    new Vector(1, 1),
                    new Vector(2, 1),
                    new Vector(3, 1),
                    new Vector(4, 1),
                    new Vector(5, 1),
                    new Vector(6, 1),
                    new Vector(6, -1),
                    new Vector(5, -1),
                    new Vector(5, 1),
                    new Vector(4, 1),
                    new Vector(4, -1),
                    new Vector(3, -1),
                    new Vector(3, 1),
                    new Vector(2, 1),
                    new Vector(2, -1),
                    new Vector(1, -1),
                    new Vector(1, 1),
                    new Vector(0, 2),
                    new Vector(0, -2),
                    new Vector(7, -2),
                    new Vector(7, 2),
                });

                var expected = new Triangulation.Triangle[]
                {
                    new Triangulation.Triangle
                    {
                        vertices = expectedVerts,
                        indices = new int[] { 1, 2, 18},
                    },
                    new Triangulation.Triangle
                    {
                        vertices = expectedVerts,
                        indices = new int[] { 14, 3, 0},
                    },
                    new Triangulation.Triangle
                    {
                        vertices = expectedVerts,
                        indices = new int[] { 3, 4, 0},
                    },
                    new Triangulation.Triangle
                    {
                        vertices = expectedVerts,
                        indices = new int[] { 10, 5, 0},
                    },
                    new Triangulation.Triangle
                    {
                        vertices = expectedVerts,
                        indices = new int[] { 5, 6, 0},
                    },
                    new Triangulation.Triangle
                    {
                        vertices = expectedVerts,
                        indices = new int[] { 8, 9, 4},
                    },
                    new Triangulation.Triangle
                    {
                        vertices = expectedVerts,
                        indices = new int[] { 10, 11, 8},
                    },
                    new Triangulation.Triangle
                    {
                        vertices = expectedVerts,
                        indices = new int[] { 12, 13, 2},
                    },
                    new Triangulation.Triangle
                    {
                        vertices = expectedVerts,
                        indices = new int[] { 14, 15, 12},
                    },
                    new Triangulation.Triangle
                    {
                        vertices = expectedVerts,
                        indices = new int[] { 16, 17, 0},
                    },
                    new Triangulation.Triangle
                    {
                        vertices = expectedVerts,
                        indices = new int[] { 18, 19, 16},
                    },
                    new Triangulation.Triangle
                    {
                        vertices = expectedVerts,
                        indices = new int[] { 19, 20, 16, },
                    },
                    new Triangulation.Triangle
                    {
                        vertices = expectedVerts,
                        indices = new int[] { 21, 0, 6 },
                    },
                    new Triangulation.Triangle
                    {
                        vertices = expectedVerts,
                        indices = new int[] { 6, 7, 21 },
                    },
                    new Triangulation.Triangle
                    {
                        vertices = expectedVerts,
                        indices = new int[] { 15, 16, 20, },
                    },
                    new Triangulation.Triangle
                    {
                        vertices = expectedVerts,
                        indices = new int[] { 20, 21, 7, },
                    },
                    new Triangulation.Triangle
                    {
                        vertices = expectedVerts,
                        indices = new int[] { 7, 8, 20, },
                    },
                    new Triangulation.Triangle
                    {
                        vertices = expectedVerts,
                        indices = new int[] { 20, 8, 11, },
                    },
                    new Triangulation.Triangle
                    {
                        vertices = expectedVerts,
                        indices = new int[] { 11, 12, 20, },
                    },
                    new Triangulation.Triangle
                    {
                        vertices = expectedVerts,
                        indices = new int[] { 20, 12, 15, },
                    },
                };

                var indices = new List<int>();
                for (int i = 0; i < expected.Length; ++i)
                {
                    indices.AddRange(expected[i].indices);
                }

                {
                    Polygon poly = new Polygon
                    {
                        Vertices = expectedVerts.Vertices,
                        Indices = indices,
                    };
                    primitive = poly;
                    primitive.InsideColor = new Blacklight.Core.Color(0, 1, 1, 1);
                    primitive.ShellColor = new Blacklight.Core.Color(1, 1, 0, 1);
                    primitive.ShellPixelThickness = 5;
                    primitive.ShellModelSpaceThickness = 0;
                    transform = new Matrix(.7, new Vector(50, -40), 10);
                    /*transform.M00 *= 1.112233;
                    transform.M01 *= 3;
                    transform.M10 *= 4;
                    transform.M11 *= 10;*/
                    //transform = rotateBy45degrees * transform;
                    primitive.Antialiased = false;
                    collage.AddDrawable(primitive, transform);
                }

                //{
                //    Polygon poly = new Polygon
                //    {
                //        Vertices = expectedVerts,
                //        Indices = indices,
                //    };
                //    primitive = poly;
                //    primitive.InsideColor = new Blacklight.Core.Color(1, 0, 0, 1);
                //    primitive.ShellColor = new Blacklight.Core.Color(1, 0, 0, 1);
                //    primitive.ShellPixelThickness = 0;
                //    primitive.ShellModelSpaceThickness = 0;
                //    transform = new Matrix(.7, new Vector(50, -40), 10);
                //    /*transform.M00 *= 1.112233;
                //    transform.M01 *= 3;
                //    transform.M10 *= 4;
                //    transform.M11 *= 10;*/
                //    //transform = rotateBy45degrees * transform;
                //    primitive.Antialiased = false;
                //    collage.AddDrawable(primitive, transform);
                //}


            }

            //{
            //    primitive = new Rectangle();
            //    primitive.InsideColor = new Blacklight.Core.Color(0.5, 1, 0.5, 0);
            //    transform = new Matrix(0, new Vector(-10, 10), 5);
            //    collage.AddDrawable(primitive, transform);
            //}
        }

        public void BindToViewport(WindowHandle handle)
        {
            camera = new Blacklight.Core.Cameras.MicroscopeCamera(handle);
            
            this.viewport = handle;
        }

        public void DrawScene()
        {
            viewport.DrawScene(scene, camera);
        }
    }
}