using System;
using System.Collections.Generic;
using System.Text;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework;

namespace DrawLines
{
    class Box
    {
        float x;

        public float X
        {
            get
            {
                return x;
            }
            set
            {
                x = value;
                setVertextPositions();
            }
        }

        float y;

        public float Y
        {
            get
            {
                return y;
            }
            set
            {
                y = value;
                setVertextPositions();
            }
        }

        float z;

        public float Z
        {
            get
            {
                return z;
            }
            set
            {
                z = value;
                setVertextPositions();
            }
        }

        Color topColor;
        public Color TopColor
        {
            get
            {
                return topColor;
            }
            set
            {
                topColor = value;
                setVertextPositions();
            }
        }

        Color leftColor;
        public Color LeftColor
        {
            get
            {
                return leftColor;
            }
            set
            {
                leftColor = value;
                setVertextPositions();
            }
        }

        Color rightColor;
        public Color RightColor
        {
            get
            {
                return rightColor;
            }
            set
            {
                rightColor = value;
                setVertextPositions();
            }
        }

        Color bottomColor;
        public Color BottomColor
        {
            get
            {
                return bottomColor;
            }
            set
            {
                bottomColor = value;
                setVertextPositions();
            }
        }

        Color frontColor;
        public Color FrontColor
        {
            get
            {
                return frontColor;
            }
            set
            {
                frontColor = value;
                setVertextPositions();
            }
        }

        Color backColor;
        public Color BackColor
        {
            get
            {
                return backColor;
            }
            set
            {
                backColor = value;
                setVertextPositions();
            }
        }

        float width;

        public float Width
        {
            get
            {
                return width;
            }
            set
            {
                width = value;
                setVertextPositions();
            }
        }

        float heigth;
        public float Heigth
        {
            get
            {
                return heigth;
            }
            set
            {
                heigth = value;
                setVertextPositions();
            }
        }

        float depth;
        float Depth
        {
            get
            {
                return depth;
            }
            set
            {
                depth = value;
                setVertextPositions();
            }
        }

        //Back
        Vector3 upperLeftBack;
        Vector3 upperRightBack;
        Vector3 lowerLeftBack;
        Vector3 lowerRightBack;

        //Front
        Vector3 upperLeftFront;
        Vector3 upperRightFront;
        Vector3 lowerLeftFront;
        Vector3 lowerRightFront;

        VertexPositionColor[] vertices;

        BasicEffect basicEffect;
        GraphicsDevice device;
        int primitiveCount = 0;

        public Matrix View
        {
            get
            {
                return basicEffect.View;
            }
            set
            {
                basicEffect.View = value;
            }
        }

        public Matrix Projection
        {
            get
            {
                return basicEffect.Projection;
            }
            set
            {
                basicEffect.Projection = value;
            }
        }

        public Box(GraphicsDevice device, float x, float y, float z, float width, float heigth, float depth, Color color)
        {
            this.x = x;
            this.y = y;
            this.z = z;
            this.width = width;
            this.heigth = heigth;
            this.depth = depth;
            this.device = device;

            setAllColors(color);

            setVertextPositions();

            basicEffect = new BasicEffect(device, null);
            basicEffect.VertexColorEnabled = true;
            

            basicEffect.Projection = Matrix.CreateOrthographicOffCenter
                (0, device.Viewport.Width,
                device.Viewport.Height, 0,
                0, 1);
        }

        public void SetAllColors(Color color)
        {
            setAllColors(color);
            setVertextPositions();
        }

        private void setAllColors(Color color)
        {
            topColor = color;
            frontColor = color;
            leftColor = color;
            rightColor = color;
            bottomColor = color;
            backColor = color;
        }

        private void setVertextPositions()
        {
            float realX = x - width / 2f;
            float realY = y - heigth / 2f;
            float realZ = z - depth / 2f;
            upperLeftBack = new Vector3(realX, realY, realZ);
            upperRightBack = new Vector3(realX + width, realY, realZ);
            lowerLeftBack = new Vector3(realX, realY + heigth, realZ);
            lowerRightBack = new Vector3(realX + width, realY + heigth, realZ);

            upperLeftFront = new Vector3(realX, realY, realZ + depth);
            upperRightFront = new Vector3(realX + width, realY, realZ + depth);
            lowerLeftFront = new Vector3(realX, realY + heigth, realZ + depth);
            lowerRightFront = new Vector3(realX + width, realY + heigth, realZ + depth);

            vertices = new VertexPositionColor[]{ 
                                                //Cube
                                                #region front
                                                //new triangle
                                                new VertexPositionColor(upperRightFront, frontColor),
                                                new VertexPositionColor(upperLeftFront, frontColor),
                                                new VertexPositionColor(lowerLeftFront, frontColor),
                                                //new triangle
                                                new VertexPositionColor(upperRightFront, frontColor),
                                                new VertexPositionColor(lowerLeftFront, frontColor),
                                                new VertexPositionColor(lowerRightFront, frontColor),
                                                #endregion

                                                #region bottom
                                                //new triangle
                                                new VertexPositionColor(lowerRightBack, bottomColor),
                                                new VertexPositionColor(lowerLeftFront, bottomColor),
                                                new VertexPositionColor(lowerLeftBack, bottomColor),
                                                //new triangle
                                                new VertexPositionColor(lowerRightFront, bottomColor),
                                                new VertexPositionColor(lowerLeftFront, bottomColor),
                                                new VertexPositionColor(lowerRightBack, bottomColor),
                                                #endregion

                                                #region Right
                                                //new triangle
                                                new VertexPositionColor(upperRightBack, rightColor),
                                                new VertexPositionColor(lowerRightFront, rightColor),
                                                new VertexPositionColor(lowerRightBack, rightColor),
                                                //new triangle
                                                new VertexPositionColor(lowerRightFront, rightColor),
                                                new VertexPositionColor(upperRightBack, rightColor),
                                                new VertexPositionColor(upperRightFront, rightColor),
                                                #endregion

                                                #region Top
                                                //new triangle
                
                                                new VertexPositionColor(upperRightFront, topColor),
                                                new VertexPositionColor(upperRightBack, topColor),
                                                new VertexPositionColor(upperLeftBack, topColor),
                                                //new triangle
                
                                                new VertexPositionColor(upperRightFront, topColor),
                                                new VertexPositionColor(upperLeftBack, topColor),
                                                new VertexPositionColor(upperLeftFront, topColor),
                                                #endregion

                                                #region Left
                                                //new triangle
                
                                                new VertexPositionColor(upperLeftFront, leftColor),
                                                new VertexPositionColor(upperLeftBack, leftColor),
                                                new VertexPositionColor(lowerLeftBack, leftColor),
                                                //new triangle
                
                                                new VertexPositionColor(lowerLeftFront, leftColor),
                                                new VertexPositionColor(upperLeftFront, leftColor),
                                                new VertexPositionColor(lowerLeftBack, leftColor),
                                                #endregion

                                                #region Back
                                                //new triangle
                
                                                new VertexPositionColor(upperLeftBack, backColor),
                                                new VertexPositionColor(upperRightBack, backColor),
                                                new VertexPositionColor(lowerLeftBack, backColor),
                                                //new triangle
                
                                                new VertexPositionColor(upperRightBack, backColor),
                                                new VertexPositionColor(lowerRightBack, backColor),
                                                new VertexPositionColor(lowerLeftBack, backColor),
                                                #endregion
            };
            primitiveCount = vertices.Length / 3;

            
        }

        public void Draw()
        {
            //basicEffect.EnableDefaultLighting(); //If uncommented exception is thrown at device.DrawUserPrimitives..
            //basicEffect.PreferPerPixelLighting = true;

            device.RenderState.DepthBufferEnable = true;
            basicEffect.Begin();
            basicEffect.CurrentTechnique.Passes[0].Begin();
            device.DrawUserPrimitives<VertexPositionColor>(PrimitiveType.TriangleList, vertices, 0,
               primitiveCount);
            basicEffect.CurrentTechnique.Passes[0].End();
            basicEffect.End();

            
        }
    }
}