using System.Numerics;
using System.Runtime.InteropServices;
using System.Text;
using Raylib_cs;

namespace DaggerFramework.Rendering
{
    public class RaylibRenderer : Renderer
    {
        public override Vector2 WindowSize => new Vector2(Raylib.GetScreenWidth(), Raylib.GetScreenHeight());
        public override bool ShouldRun => !WindowShouldClose();

        // public override void CreateWindow(string title, Vector2 size)
        // {
        //     Raylib.SetTraceLogLevel(TraceLogLevel.LOG_NONE);
        //     _windowSize = size;
        //     Raylib.InitWindow((int)_windowSize.X, (int)_windowSize.Y, title);
        // }

        public override void CreateWindow(WindowSettings windowSettings)
        {
            Raylib.SetTraceLogLevel(TraceLogLevel.LOG_NONE);
            _windowSize = windowSettings.Size;

            ConfigFlags windowFlags = 0;
            windowFlags |= windowSettings.Resizable ? ConfigFlags.FLAG_WINDOW_RESIZABLE : 0;

            Raylib.InitWindow((int)_windowSize.X, (int)_windowSize.Y, windowSettings.Title);
            Raylib.SetWindowState(windowFlags);
        }

        public override void SetWindowTitle(string title)
        {
            Raylib.SetWindowTitle(title);
        }

        public override void SetWindowVSync(bool value)
        {

        }

        public override void SetTargetFps(int fps)
        {
            Raylib.SetTargetFPS(fps);
        }

        public override bool WindowShouldClose()
        {
            return Raylib.WindowShouldClose();
        }

        public override void Shutdown()
        {
            Raylib.CloseWindow();
        }

        public override void BeginFrame()
        {
            Raylib.BeginDrawing();
        }

        public override void EndFrame()
        {
            Raylib.EndDrawing();
        }

        public override void BeginCamera2d(Vector2 offset, Vector2 target, float rotation, float zoom)
        {
            var camera = new Camera2D(offset, target, rotation, zoom);
            Raylib.BeginMode2D(camera);
        }

        public override void EndCamera2d()
        {
            Raylib.EndMode2D();
        }

        public override void ClearBackground(Color color)
        {
            Raylib.ClearBackground(DaggerColorToRaylibColor(color));
        }

        public override double GetFrameTime()
        {
            return (double)Raylib.GetFrameTime();
        }

        public override void DrawCircle(float radius, Color color)
        {
            Raylib.DrawCircle((int)_position.X, (int)_position.Y, radius, DaggerColorToRaylibColor(color));
        }

        public override void SetTransform(Vector2 position, Vector2 offset, float rotation = 0)
        {
            _position = position;
            _offset = offset;
            _rotation = rotation;
        }

        public override int LoadTexture(Texture2d texture)
        {
            Image image = new Image();

            unsafe
            {
                fixed (void* dataPtr = texture.Buffer)
                {
                    image.data = dataPtr;
                }
            }

            image.width = texture.Width;
            image.height = texture.Height;
            image.mipmaps = 1;
            image.format = PixelFormat.PIXELFORMAT_UNCOMPRESSED_R8G8B8A8;

            Texture2D rayTexture;

            rayTexture = Raylib.LoadTextureFromImage(image);

            _texturePool.Add(rayTexture);

            return _texturePool.Count - 1;
        }

        public unsafe override int LoadFont(Font font)
        {
            // TODO: screw it, let's just load the font directly from the path. I give up.
            // Raylib_cs.Font fontRay;

            // string ext = "ttf";
            // byte[] extBytes = new byte[Encoding.Default.GetByteCount(ext) + 1];
            // Encoding.Default.GetBytes(ext, extBytes);
            // int fontChars = 0;

            // unsafe
            // {
            //     fixed (byte* extP = extBytes)
            //     {
            //         fixed (byte* bufferP = font.Buffer)
            //         {
            //             fontRay = Raylib.LoadFontFromMemory((sbyte*)extP, bufferP, (int)font.BufferSize, font.Size, null, 95);

            //         }
            //     }
            // }

            var fontRay = Raylib.LoadFont(font.Path);
            Raylib.SetTextureFilter(fontRay.texture, TextureFilter.TEXTURE_FILTER_BILINEAR);

            _fontPool.Add(fontRay);
            return _fontPool.Count - 1;
        }

        public override void DrawTexture(int id, Color tint)
        {
            Raylib.DrawTextureV(_texturePool[id], _position, DaggerColorToRaylibColor(tint));
        }

        public override void DrawRectangle(Vector2 size, Color color)
        {
            // Raylib.DrawRectangleV(_position, size, SystemColorToRaylibColor(color));
            Raylib.DrawRectanglePro(new Rectangle()
            {
                x = _position.X,
                y = _position.Y,
                width = size.X,
                height = size.Y
            }, _offset, _rotation, DaggerColorToRaylibColor(color));
        }

        public override void DrawDebugText(string text, int fontSize, Color color)
        {
            Raylib.DrawText(text, (int)_position.X, (int)_position.Y, fontSize, DaggerColorToRaylibColor(color));
        }

        public override void DrawSdfText(string text, int fontSize, Color color)
        {
            throw new NotImplementedException();
        }

        public override void Initialize(RendererSettings settings)
        {
            ConfigFlags flags = 0;

            // MSAA
            flags |= settings.Msaa == Msaa.Msaa4x ? ConfigFlags.FLAG_MSAA_4X_HINT : 0;

            // VSync
            flags |= settings.UseVSync ? ConfigFlags.FLAG_VSYNC_HINT : 0;

            // Fullscreen
            flags |= settings.Fullscreen ? ConfigFlags.FLAG_FULLSCREEN_MODE : 0;

            Raylib.SetConfigFlags(flags);
        }

        // TODO
        public override void SetTransform(Matrix4x4 transform) { }

        public override void CreateAndInitialize(WindowSettings windowSettings, RendererSettings renderSettings)
        {
            CreateWindow(windowSettings);
            Initialize(renderSettings);
        }

        private Raylib_cs.Color DaggerColorToRaylibColor(Color color)
        {
            return new Raylib_cs.Color { r = (byte)Math.Round(color.R * 255f), g = (byte)Math.Round(color.G * 255f), b = (byte)Math.Round(color.B * 255f), a = (byte)Math.Round(color.A * 255f) };
        }

        public override void DrawText(int fontId, string text, int fontSize, Color color)
        {
            var font = _fontPool[fontId];
            Raylib.DrawTextPro(font, text, _position, Vector2.Zero, _rotation, fontSize, 0.0f, DaggerColorToRaylibColor(color));
        }

        private List<Texture2D> _texturePool = new();
        private List<Raylib_cs.Font> _fontPool = new();
        private Vector2 _position, _offset;
        private float _rotation;
        private Vector2 _windowSize;
    }
}