using System;
using Chernobyl.Graphics.Texture;
using Chernobyl.Mathematics;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;

namespace Chernobyl.Graphics.Xna
{
    /// <summary>
    /// Methods and other various API to make XNA easier to use with Chernobyl.
    /// </summary>
    public class Utility
    {
        /// <summary>
        /// Converts a Chernobyl.Math matrix (OpenTK matrix) to
        /// a XNA matrix.
        /// </summary>
        /// <param name="xnaMatrix">The matrix that is to take
        /// the conversion.</param>
        /// <param name="matrix">The matrix to convert.</param>
        public static void ToXNAMatrix(out Matrix xnaMatrix, Matrix4 matrix)
        {
            xnaMatrix.M11 = matrix.M11;
            xnaMatrix.M12 = matrix.M12;
            xnaMatrix.M13 = matrix.M13;
            xnaMatrix.M14 = matrix.M14;

            xnaMatrix.M21 = matrix.M21;
            xnaMatrix.M22 = matrix.M22;
            xnaMatrix.M23 = matrix.M23;
            xnaMatrix.M24 = matrix.M24;

            xnaMatrix.M31 = matrix.M31;
            xnaMatrix.M32 = matrix.M32;
            xnaMatrix.M33 = matrix.M33;
            xnaMatrix.M34 = matrix.M34;

            xnaMatrix.M41 = matrix.M41;
            xnaMatrix.M42 = matrix.M42;
            xnaMatrix.M43 = matrix.M43;
            xnaMatrix.M44 = matrix.M44;
        }

        /// <summary>
        /// Converts a Chernobyl TextureFormat to an XNA SurfaceFormat
        /// </summary>
        /// <param name="value">The TextureFormat to convert.</param>
        public static SurfaceFormat ToSurfaceFormat(TextureFormat value)
        {
            switch (value)
            {
                case TextureFormat.Rgb32:
                    return SurfaceFormat.Rgb32;
                case TextureFormat.Argb32:
                    return SurfaceFormat.Color;
                case TextureFormat.Bgr32:
                    return SurfaceFormat.Bgr32;
            }

            throw new ArgumentException("Unable to find a corresponding XNA SurfaceFormat for the Chernobyl TextureFormat provided: " + value.ToString(), "value");
        }

        /// <summary>
        /// Converts a XNA surface format to an Chernobyl TextureFormat
        /// </summary>
        /// <param name="value">The TextureFormat to convert.</param>
        public static TextureFormat ToTextureFormat(SurfaceFormat value)
        {
            switch (value)
            {
                case SurfaceFormat.Rgb32:
                    return TextureFormat.Rgb32;
                case SurfaceFormat.Color:
                    return TextureFormat.Argb32;
                case SurfaceFormat.Bgr32:
                    return TextureFormat.Bgr32;
            }

            throw new ArgumentException("Unable to find a corresponding Chernobyl TextureFormat for the XNA SurfaceFormat provided: " + value.ToString(), "value");
        }

        /// <summary>
        /// Converts a Chernobyl primitive type to an XNA primitive type.
        /// </summary>
        /// <param name="primitiveType">The Chernobyl primitive type to convert.</param>
        /// <returns>The XNA primitive type.</returns>
        public static PrimitiveType ToXnaPrimitiveType(Chernobyl.Graphics.Drawing.PrimitiveType primitiveType)
        {
            PrimitiveType XnaPrimitiveType;
            switch (primitiveType)
            {
                case Chernobyl.Graphics.Drawing.PrimitiveType.LineList:
                    XnaPrimitiveType = PrimitiveType.LineList;
                    break;
                case Chernobyl.Graphics.Drawing.PrimitiveType.LineStrip:
                    XnaPrimitiveType = PrimitiveType.LineStrip;
                    break;
                case Chernobyl.Graphics.Drawing.PrimitiveType.PointList:
                    XnaPrimitiveType = PrimitiveType.PointList;
                    break;
                case Chernobyl.Graphics.Drawing.PrimitiveType.TriangleFan:
                    XnaPrimitiveType = PrimitiveType.TriangleFan;
                    break;
                case Chernobyl.Graphics.Drawing.PrimitiveType.TriangleList:
                    XnaPrimitiveType = PrimitiveType.TriangleList;
                    break;
                case Chernobyl.Graphics.Drawing.PrimitiveType.TriangleStrip:
                    XnaPrimitiveType = PrimitiveType.TriangleStrip;
                    break;
                default:
                    throw new Exception("Unable to convert from an Chernobyl primitive type to an XNA Primitive Type.");
            }
            return XnaPrimitiveType;
        }

        /// <summary>
        /// Converts an XNA primitive type to a Chernobyl primitive type.
        /// </summary>
        /// <param name="primitiveType">The XNA primitive type to convert.</param>
        /// <returns>The Chernobyl primitive type.</returns>
        public static Chernobyl.Graphics.Drawing.PrimitiveType ToChernobylPrimitiveType(PrimitiveType primitiveType)
        {
            switch (primitiveType)
            {
                case PrimitiveType.LineList:
                    return Chernobyl.Graphics.Drawing.PrimitiveType.LineList;
                case PrimitiveType.LineStrip:
                    return Chernobyl.Graphics.Drawing.PrimitiveType.LineStrip;
                case PrimitiveType.PointList:
                    return Chernobyl.Graphics.Drawing.PrimitiveType.PointList;
                case PrimitiveType.TriangleFan:
                    return Chernobyl.Graphics.Drawing.PrimitiveType.TriangleFan;
                case PrimitiveType.TriangleList:
                    return Chernobyl.Graphics.Drawing.PrimitiveType.TriangleList;
                case PrimitiveType.TriangleStrip:
                    return Chernobyl.Graphics.Drawing.PrimitiveType.TriangleStrip;
            }
            throw new Exception("Unable to convert from an XNA primitive type to a Chernobyl Primitive Type.");
        }

        /// <summary>
        /// Gets the number of primitives that a drawn for
        /// each primitive type based on the number of
        /// mesh elements.
        /// </summary>
        /// <param name="primitiveType">The primitive type to get the number of elements of.</param>
        /// <param name="numMeshElements">The number of mesh elements in the buffer</param>
        /// <returns>The number of primitives to draw.</returns>
        public static int GetPrimitiveCount(PrimitiveType primitiveType, uint numMeshElements)
        {
            switch (primitiveType)
            {
                case PrimitiveType.LineList:
                    return (int)numMeshElements / 2;
                case PrimitiveType.LineStrip:
                    return (int)numMeshElements - 1;
                case PrimitiveType.PointList:
                    return (int)numMeshElements;
                case PrimitiveType.TriangleFan:
                    return (int)numMeshElements - 2;
                case PrimitiveType.TriangleList:
                    return (int)numMeshElements / 3;
                case PrimitiveType.TriangleStrip:
                    return (int)numMeshElements - 2;
                default:
                    throw new Exception("Unknown XNA primitive type assigned to " + primitiveType.GetType().FullName);
            }
        }

        /// <summary>
        /// Converts a Chernobyl Color to an XNA color.
        /// </summary>
        /// <param name="color">The Chernobyl color to convert.</param>
        /// <returns>The converted XNA color.</returns>
        public static Microsoft.Xna.Framework.Graphics.Color ToXnaColor(Chernobyl.Graphics.Color color)
        {
            return new Microsoft.Xna.Framework.Graphics.Color(color.R, color.G, color.B, color.A);
        }

        /// <summary>
        /// Converts an XNA Color to an Chernobyl color.
        /// </summary>
        /// <param name="color">The XNA color to convert.</param>
        /// <returns>The converted Chernobyl color.</returns>
        public static Color ToChernobylColor(Microsoft.Xna.Framework.Graphics.Color color)
        {
            return new Color(color.R, color.G, color.B, color.A);
        }

        /// <summary>
        /// Converts a XNA Vector2 to a Chernobyl Vector2
        /// </summary>
        /// <param name="chernobylVectorOut">The Chernobyl vector that is to take 
        /// the result of the conversion.</param>
        /// <param name="xnaVector">The XNA Vector2 to convert.</param>
        /// <returns>The converter Chernobyl Vector2.</returns>
        public static void ToChernobylVector(out Mathematics.Vector2 chernobylVectorOut, ref Microsoft.Xna.Framework.Vector2 xnaVector)
        {
            chernobylVectorOut = new Mathematics.Vector2(xnaVector.X, xnaVector.Y);
        }
    }
}