using OpenTK;
using OpenTK.Graphics;
using OpenTK.Graphics.OpenGL;
using OpenTK.Input;
using System;
using System.Drawing;
using System.Drawing.Imaging;
using System.IO;
using System.Text.RegularExpressions;
using GDIPixelFormat = System.Drawing.Imaging.PixelFormat;
using GLPixelFormat = OpenTK.Graphics.OpenGL.PixelFormat;

namespace TFMV
{
    class Program
    {
        class Mesh
        {
            public int normalIndicesCount, normalIndicesOffset;
            public int positionIndicesCount, positionIndicesOffset;
            public int tangentIndicesCount, tangentIndicesOffset;
            public int uvIndicesCount, uvIndicesOffset;

            public int normalCount, normalOffset;
            public int positionCount, positionOffset;
            public int tangentCount, tangentOffset;
            public int uvCount, uvOffset;
        }

        class MeshData
        {
            public int[] normalIndices;
            public int[] positionIndices;
            public int[] tangentIndices;
            public int[] uvIndices;

            public Vector3[] normal;
            public Vector3[] position;
            public Vector4[] tangent;
            public Vector2[] uv;
        }

        static Mesh ReadMsh(string FileName)
        {
            string data = File.ReadAllText(FileName);
            data = Regex.Replace(data, "[\\s\\n\\r\\t]+", " ");

            Mesh mesh = new Mesh();
            string[] splitedData = data.Split(' ');

            string str = Regex.Match(data, "normal\\s=\\s{\\scount\\s=\\s\\d+,\\soffset\\s=\\s\\d+,\\s}", RegexOptions.IgnorePatternWhitespace).Value;
            MatchCollection match = Regex.Matches(str, "\\d+");
            mesh.normalIndicesCount = Convert.ToInt32(match[0].Value);
            mesh.normalIndicesOffset = Convert.ToInt32(match[1].Value);

            str = Regex.Match(data, "position\\s=\\s{\\scount\\s=\\s\\d+,\\soffset\\s=\\s\\d+,\\s}", RegexOptions.IgnorePatternWhitespace).Value;
            match = Regex.Matches(str, "\\d+");
            mesh.positionIndicesCount = Convert.ToInt32(match[0].Value);
            mesh.positionIndicesOffset = Convert.ToInt32(match[1].Value);

            str = Regex.Match(data, "tangent\\s=\\s{\\scount\\s=\\s\\d+,\\soffset\\s=\\s\\d+,\\s}", RegexOptions.IgnorePatternWhitespace).Value;
            match = Regex.Matches(str, "\\d+");
            mesh.tangentIndicesCount = Convert.ToInt32(match[0].Value);
            mesh.tangentIndicesOffset = Convert.ToInt32(match[1].Value);

            str = Regex.Match(data, "uv0\\s=\\s{\\scount\\s=\\s\\d+,\\soffset\\s=\\s\\d+,\\s}", RegexOptions.IgnorePatternWhitespace).Value;
            match = Regex.Matches(str, "\\d+");
            mesh.uvIndicesCount = Convert.ToInt32(match[1].Value);
            mesh.uvIndicesOffset = Convert.ToInt32(match[2].Value);

            str = Regex.Match(data, "normal\\s=\\s{\\scount\\s=\\s\\d+,\\snumComp\\s=\\s\\d+,\\soffset\\s=\\s\\d+,\\s}", RegexOptions.IgnorePatternWhitespace).Value;
            match = Regex.Matches(str, "\\d+");
            mesh.normalCount = Convert.ToInt32(match[0].Value);
            mesh.normalOffset = Convert.ToInt32(match[2].Value);

            str = Regex.Match(data, "position\\s=\\s{\\scount\\s=\\s\\d+,\\snumComp\\s=\\s\\d+,\\soffset\\s=\\s\\d+,\\s}", RegexOptions.IgnorePatternWhitespace).Value;
            match = Regex.Matches(str, "\\d+");
            mesh.positionCount = Convert.ToInt32(match[0].Value);
            mesh.positionOffset = Convert.ToInt32(match[2].Value);

            str = Regex.Match(data, "tangent\\s=\\s{\\scount\\s=\\s\\d+,\\snumComp\\s=\\s\\d+,\\soffset\\s=\\s\\d+,\\s}", RegexOptions.IgnorePatternWhitespace).Value;
            match = Regex.Matches(str, "\\d+");
            mesh.tangentCount = Convert.ToInt32(match[0].Value);
            mesh.tangentOffset = Convert.ToInt32(match[2].Value);

            str = Regex.Match(data, "uv0\\s=\\s{\\scount\\s=\\s\\d+,\\snumComp\\s=\\s\\d+,\\soffset\\s=\\s\\d+,\\s}", RegexOptions.IgnorePatternWhitespace).Value;
            match = Regex.Matches(str, "\\d+");
            mesh.uvCount = Convert.ToInt32(match[1].Value);
            mesh.uvOffset = Convert.ToInt32(match[3].Value);

            return mesh;
        }

        static byte[] ReadBlob(string FileName)
        {
            return File.ReadAllBytes(FileName);
        }

        static MeshData ParseBlob(byte[] data, Mesh mesh)
        {
            MeshData meshData = new MeshData();

            meshData.normalIndices = new int[mesh.normalIndicesCount / 4];
            meshData.positionIndices = new int[mesh.positionIndicesCount / 4];
            meshData.tangentIndices = new int[mesh.tangentIndicesCount / 4];
            meshData.uvIndices = new int[mesh.uvIndicesCount / 4];

            for (int i = mesh.normalIndicesOffset, j = 0; j < mesh.normalIndicesCount / 4; i += 4, j++)
                meshData.normalIndices[j] = BitConverter.ToInt32(data, i);

            for (int i = mesh.positionIndicesOffset, j = 0; j < mesh.positionIndicesCount / 4; i += 4, j++)
                meshData.positionIndices[j] = BitConverter.ToInt32(data, i);

            for (int i = mesh.tangentIndicesOffset, j = 0; j < mesh.tangentIndicesCount / 4; i += 4, j++)
                meshData.tangentIndices[j] = BitConverter.ToInt32(data, i);

            for (int i = mesh.uvIndicesOffset, j = 0; j < mesh.uvIndicesCount / 4; i += 4, j++)
                meshData.uvIndices[j] = BitConverter.ToInt32(data, i);

            meshData.normal = new Vector3[mesh.normalCount / 3];
            meshData.position = new Vector3[mesh.positionCount / 3];
            meshData.tangent = new Vector4[mesh.tangentCount / 4];
            meshData.uv = new Vector2[mesh.uvCount / 2];

            for (int i = mesh.normalOffset, j = 0; j < mesh.normalCount / 3 / 4; i += 12, j++)
                meshData.normal[j] = new Vector3(BitConverter.ToSingle(data, i), BitConverter.ToSingle(data, i + 4), BitConverter.ToSingle(data, i + 8));

            for (int i = mesh.positionOffset, j = 0; j < mesh.positionCount / 3 / 4; i += 12, j++)
                meshData.position[j] = new Vector3(BitConverter.ToSingle(data, i), BitConverter.ToSingle(data, i + 4), BitConverter.ToSingle(data, i + 8));

            for (int i = mesh.tangentOffset, j = 0; j < mesh.tangentCount / 4 / 4; i += 16, j++)
                meshData.tangent[j] = new Vector4(BitConverter.ToSingle(data, i), BitConverter.ToSingle(data, i + 4), BitConverter.ToSingle(data, i + 8), BitConverter.ToSingle(data, i + 12));

            for (int i = mesh.uvOffset, j = 0; j < mesh.uvCount / 2 / 4; i += 8, j++)
                meshData.uv[j] = new Vector2(BitConverter.ToSingle(data, i), BitConverter.ToSingle(data, i + 4));

            return meshData;
        }

        static int TextureHandle = -1;

        static void Main(string[] Args)
        {
            Args = new[] { "E:\\Games\\Train Fever\\res\\models\\mesh\\vehicle\\train\\db_v100\\lod_1_v100.msh", "E:\\Games\\Train Fever\\res\\textures\\models\\vehicle\\train\\train_db_v100.tga" };

            if (Args.Length < 1)
            {
                Console.WriteLine("Usage: TFMV.exe msh_model [tga_texture]");
                Console.ReadKey(true);
                return;
            }

            string meshFileName = Args[0];
            string blobFileName = Args[0] + ".blob";

            if (!File.Exists(meshFileName))
            {
                Console.WriteLine("File {0} not found. Exiting", meshFileName);
                Console.ReadKey(true);
                return;
            }

            if (!File.Exists(blobFileName))
            {
                Console.WriteLine("File {0} not found. Exiting", blobFileName);
                Console.ReadKey(true);
                return;
            }

            Mesh mesh = ReadMsh(meshFileName);
            byte[] blob = ReadBlob(blobFileName);
            MeshData meshData = ParseBlob(blob, mesh);

            GameWindow window = new GameWindow(800, 600, GraphicsMode.Default, "Train-Fever Model Viewer 0.2 by Omich", GameWindowFlags.Default, DisplayDevice.Default, 2, 0, GraphicsContextFlags.Default);

            window.Load += delegate(object sender, EventArgs e)
            {
                GL.Enable(EnableCap.DepthTest);
                GL.Enable(EnableCap.Lighting);
                GL.Enable(EnableCap.Light0);
                GL.Enable(EnableCap.Texture2D);

                GL.Hint(HintTarget.PerspectiveCorrectionHint, HintMode.Nicest);

                if (Args.Length > 1)
                {
                    string textureFileName = Args[1];

                    if (!File.Exists(textureFileName))
                        Console.WriteLine("File {0} not found. Skipping texture", blobFileName);
                    else
                    {
                        TextureHandle = GL.GenTexture();
                        GL.BindTexture(TextureTarget.Texture2D, TextureHandle);

                        Bitmap bitmap;

                        if (textureFileName.EndsWith(".tga"))
                            bitmap = Paloma.TargaImage.LoadTargaImage(textureFileName);
                        else
                            bitmap = new Bitmap(textureFileName);

                        bitmap.RotateFlip(RotateFlipType.RotateNoneFlipY);

                        BitmapData data = bitmap.LockBits(new Rectangle(0, 0, bitmap.Width, bitmap.Height), ImageLockMode.ReadOnly, bitmap.PixelFormat);

                        switch (bitmap.PixelFormat)
                        {
                            case GDIPixelFormat.Format24bppRgb:
                                GL.TexImage2D(TextureTarget.Texture2D, 0, PixelInternalFormat.Rgb, bitmap.Width, bitmap.Height, 0, GLPixelFormat.Bgr, PixelType.UnsignedByte, data.Scan0);
                                break;

                            case GDIPixelFormat.Format32bppArgb:
                                GL.TexImage2D(TextureTarget.Texture2D, 0, PixelInternalFormat.Rgba, bitmap.Width, bitmap.Height, 0, GLPixelFormat.Bgra, PixelType.UnsignedByte, data.Scan0);
                                break;

                            default:
                                Console.WriteLine(bitmap.PixelFormat + " texture pixel format support not implemented. Skipping texture");
                                TextureHandle = -1;
                                break;
                        }

                        if (TextureHandle != -1)
                        {
                            GL.GenerateMipmap(GenerateMipmapTarget.Texture2D);

                            GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureWrapS, (int)TextureWrapMode.ClampToEdge);
                            GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureWrapT, (int)TextureWrapMode.ClampToEdge);

                            GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMinFilter, (int)TextureMinFilter.LinearMipmapLinear);
                            GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMagFilter, (int)TextureMagFilter.Linear);
                        }

                        bitmap.UnlockBits(data);
                        bitmap.Dispose();
                    }
                }
            };

            window.Resize += delegate(object sender, EventArgs e)
            {
                GL.Viewport(0, 0, window.Width, window.Height);

                GL.MatrixMode(MatrixMode.Projection);
                Matrix4 projection = Matrix4.CreatePerspectiveFieldOfView(MathHelper.PiOver2, (float)window.Width / window.Height, 0.1f, 1000.0f);
                GL.LoadMatrix(ref projection);

                GL.MatrixMode(MatrixMode.Modelview);
            };

            float hAngle = MathHelper.PiOver2;
            float vAngle = MathHelper.PiOver2;

            bool mouseDown = false;

            int zoom = 15;

            float dragStartH = 0;
            float dragStartV = 0;
            int dragStartX = 0;
            int dragStartY = 0;

            window.MouseDown += delegate(object sender, MouseButtonEventArgs e)
            {
                if (e.Button == MouseButton.Left)
                {
                    if (e.IsPressed)
                    {
                        mouseDown = true;
                        dragStartH = hAngle;
                        dragStartV = vAngle;
                        dragStartX = e.X;
                        dragStartY = e.Y;
                    }
                }
            };

            window.MouseUp += delegate(object sender, MouseButtonEventArgs e)
            {
                if (e.Button == MouseButton.Left)
                    mouseDown = false;
            };

            window.MouseMove += delegate(object sender, MouseMoveEventArgs e)
            {
                if (mouseDown)
                {
                    int offsetX = e.X - dragStartX;
                    int offsetY = e.Y - dragStartY;

                    hAngle = dragStartH - offsetX * 0.01f;
                    vAngle = Math.Min(MathHelper.Pi - 0.01f, Math.Max(0.01f, dragStartV - offsetY * 0.01f));
                }
            };

            window.MouseWheel += delegate(object sender, MouseWheelEventArgs e)
            {
                zoom -= e.Delta;
                zoom = Math.Min(50, Math.Max(1, zoom));
            };

            window.RenderFrame += delegate(object sender, FrameEventArgs e)
            {
                GL.Clear(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit);

                float x = (float)(zoom * Math.Sin(vAngle) * Math.Cos(hAngle));
                float y = (float)(zoom * Math.Sin(vAngle) * Math.Sin(hAngle));
                float z = (float)(zoom * Math.Cos(vAngle));

                Matrix4 view = Matrix4.LookAt(new Vector3(x, y, z), Vector3.Zero, Vector3.UnitZ);
                GL.LoadMatrix(ref view);

                if (TextureHandle != -1)
                    GL.BindTexture(TextureTarget.Texture2D, TextureHandle);

                GL.Begin(PrimitiveType.Triangles);

                for (int i = 0; i < meshData.positionIndices.Length; i++)
                {
                    GL.TexCoord2(meshData.uv[meshData.uvIndices[i]]);
                    GL.Normal3(meshData.normal[meshData.normalIndices[i]]);
                    GL.Vertex3(meshData.position[meshData.positionIndices[i]]);
                }

                GL.End();

                window.SwapBuffers();
            };

            window.Run();
        }
    }
}