using System.Text.Json;
using DaggerFramework.Audio;
using DaggerFramework.Rendering;
using DaggerFramework.Resources;


namespace DaggerFramework.SceneGraph
{
    public class Scene : IMainLoop
    {
        public Renderer Renderer { get => _renderer; set => _renderer = value; }
        public InputHandler? Input { get => _input; set => _input = value; }
        public AudioBackend? Audio => _audioBackend;
        public ResourceManager ResourceManager => _resourceManager;

        public double DeltaTime => _renderer.FrameTime;
        public bool ShouldRun => Renderer.ShouldRun;

        public Scene(SceneSettings settings)
        {
            _renderer = settings.Renderer;
            _input = settings.InputHandler;
            _audioBackend = settings.AudioBackend;
            _resourceManager = settings.ResourceManager;
        }

        public static Scene FromSerialized(SerializedScene serializedScene, SceneSettings settings)
        {
            var scene = new Scene(settings);
            scene.WithLayers(serializedScene.Layers);

            return scene;
        }

        public bool TrySerialize(out SerializedScene serializedScene)
        {
            serializedScene = new SerializedScene(string.Empty, new byte[] { })
            {
                Layers = _layers
            };

            var sourceGenOptions = new JsonSerializerOptions
            {
                TypeInfoResolver = SerializedSceneContext.Default
            };

            serializedScene.Buffer = JsonSerializer.SerializeToUtf8Bytes(serializedScene, typeof(SerializedScene), sourceGenOptions);
            serializedScene.BufferSize = serializedScene.Buffer.LongLength;

            return true;
        }

        public void WithLayers(Dictionary<string, Layer> layers)
        {
            _layers = layers;
        }

        public void Init() => SetupRenderer();
        public void Start()
        {
            foreach (var layer in _layers.Values)
            {
                if (_input is not null)
                {
                    layer.Input = _input;
                }

                layer.Start();
            }
        }

        public void Update()
        {
            foreach (var layer in _layers)
            {
                layer.Value.Update(DeltaTime);
            }

            Audio?.Update();
        }

        public void AddLayer(string name, Layer layer)
        {
            layer.Scene = this;
            _layers.Add(name, layer);
        }

        public void BeginDraw()
        {
            Renderer.BeginFrame();
            Renderer.ClearBackground(Color.Black);

            foreach (var layer in _layers.Values)
            {
                layer.BeginDraw(_renderer);
                layer.Draw(_renderer);
            }

            Renderer.ResetTransform();
        }

        public void EndDraw()
        {
            foreach (var layer in _layers.Values)
            {
                layer.EndDraw(_renderer);
            }

            Renderer.EndFrame();
        }

        private void SetupRenderer()
        {
            Renderer.Initialize(new RendererSettings { Msaa = Msaa.Msaa4x, UseVSync = true });
        }

        private Dictionary<string, Layer> _layers = new();
        private Renderer _renderer;
        private AudioBackend? _audioBackend;
        private InputHandler? _input;
        private ResourceManager _resourceManager;
    }

    public struct SceneSettings
    {
        public Renderer Renderer { get; set; }
        public AudioBackend AudioBackend { get; set; }
        public InputHandler InputHandler { get; set; }
        public ResourceManager ResourceManager { get; set; }
    }
}