using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using FlaxEngine;
using FlaxEngine.Assertions;
using FlaxEngine.Json;
using FlaxEngine.Networking;

namespace Game;

public enum GameModeMessageType2 : byte
{
    AcceptConnection, // AcceptConnectionMessage
    SpawnPlayer,
    PlayerInput,
    PlayerPosition, // world update
    PlayerSnapshot, // send world state delta to client since last client's acknowledged frame

    LastMessageType = 128,
}

public class PlayerFrame
{
    public ulong frame => inputState.Frame;
    public Float3 position;
    public PlayerInputState2 inputState;
    public PlayerMovementState movementState;
}

public interface IClientInfo
{
    public NetworkConnection Connection { get; set; }
    public PlayerActor PlayerActor { get; set; }
    public PlayerFrame[] FrameHistory { get; set; }
}

public class World
{
    public bool IsServer => this is ServerWorld;
    public bool IsClient => this is ClientWorld;
    public ulong Frame { get; protected set; }
    public ulong ServerFrame { get; protected set; } // Last received frame from server
    public float GameTime { get; protected set; } // The join time
    public float GetFrameTime(ulong frame) => GameTime + (frame * (1.0f / Time.PhysicsFPS));

    protected Scene _scene;
    protected Actor _worldSpawn;

    public static void InitClient()
    {
        WorldStore.ClientWorld = new ClientWorld();
        WorldStore.ClientWorld.Init();
    }
    public static void InitServer()
    {
        WorldStore.ServerWorld = new ServerWorld();
        WorldStore.ServerWorld.Init();
        Scripting.Update += WorldStore.ServerWorld.OnUpdate;
        Scripting.LateUpdate += WorldStore.ServerWorld.OnUpdateLate;
        Scripting.FixedUpdate += WorldStore.ServerWorld.OnFixedUpdate;
    }
    public static void CleanupClient()
    {
        WorldStore.ClientWorld?.Cleanup();
        WorldStore.ClientWorld = null;
    }
    public static void CleanupServer()
    {
        WorldStore.ServerWorld?.Cleanup();
        WorldStore.ServerWorld = null;
    }

    virtual protected void Init()
    {
        
        Scripting.LateFixedUpdate += OnLateUpdate;
    }

    virtual protected void Cleanup()
    {
        //Level.SceneLoaded -= OnLevelLoaded;
        //Scripting.LateUpdate -= OnLateUpdatePre;
        Scripting.Update -= OnUpdate;
        Scripting.LateUpdate -= OnUpdateLate;
        Scripting.FixedUpdate -= OnFixedUpdate;
        Scripting.LateFixedUpdate -= OnLateUpdate;

        if (_scene)
        {
            foreach (var player in _scene.GetChildren<PlayerActor>())
            {
                FlaxEngine.Object.Destroy(player);
            }
            if (Level.UnloadScene(_scene))
                throw new Exception("Failed to unload scene");
            _scene = null;
        }
    }

    void OnUpdate()
    {
        //Console.Print("server Update");
    }

    void OnUpdateLate()
    {
        //Console.Print("server LateUpdate");
    }

    void OnFixedUpdate()
    {
        //Console.Print("server FixedUpdate");
    }

    protected void CreateScene(string sceneNamePrefix, string sceneGuid)
    {
        string physicsSceneName = $"{sceneNamePrefix}PhysicsScene";
        PhysicsScene localPhysicsScene = Physics.FindOrCreateScene(physicsSceneName);

        Guid guid = JsonSerializer.ParseID(sceneGuid);
        string guidStr = JsonSerializer.GetStringID(guid);
        string sceneData = $@"
{{
	""ID"": ""{guidStr}"",
	""TypeName"": ""FlaxEngine.SceneAsset"",
	""EngineBuild"": 65046,
	""Data"": [
		{{
			""ID"": ""{guidStr}"",
			""TypeName"": ""FlaxEngine.Scene"",
			""LightmapSettings"": {{
				""IndirectLightingIntensity"": 1.0,
				""GlobalObjectsScale"": 1.0,
				""ChartsPadding"": 3,
				""AtlasSize"": 1024,
				""BounceCount"": 1,
				""CompressLightmaps"": true,
				""UseGeometryWithNoMaterials"": true,
				""Quality"": 10
			}}
		}}
	]
}}";

        {
            var onSceneLoaded = (Scene loadedScene, Guid id) =>
            {
                if (guid == id)
                {
                    loadedScene.PhysicsScene = localPhysicsScene;
                    //scene = loadedScene;
                }
            };

            try
            {
                Level.SceneLoaded += onSceneLoaded;
                //Level.LoadScene(new SceneReference(guid));
                _scene = Level.LoadSceneFromBytes(Encoding.ASCII.GetBytes(sceneData));
            }
            finally
            {
                Level.SceneLoaded -= onSceneLoaded;
            }
        }
        Assert.IsTrue(_scene);

        _scene.Name = $"{sceneNamePrefix}Scene";

        //Level.SceneLoaded += OnLevelLoaded;
        

        var importer = FlaxEngine.Object.New<Q3MapImporter>();
        importer.mapPath = @"C:\dev\GoakeFlax\Assets\Maps\aerowalk.map";
        importer.LoadCollidersOnly = sceneNamePrefix != "Client"; // FIXME
        importer.Parent = _scene;

        //importer.Enabled = true;
        _worldSpawn = _scene.FindActor("WorldSpawn");// ?? Level.FindActor("WorldSpawn");
        Assert.IsTrue(_worldSpawn);
    }

    virtual protected void OnLateUpdate()
    {
        Frame++;
    }

    virtual protected IClientInfo GetClient(uint playerId) => null;

    virtual protected PlayerActor SpawnPlayer(uint playerId, Float3 position, Vector3 eulerAngles)
    {
        string prefabPath = Path.Combine(AssetManager.ContentPath, "Common");
        var playerPrefab = Content.Load<Prefab>(Path.Combine(prefabPath, "PlayerPrefab.prefab"));
        if (playerPrefab == null)
            Console.PrintError("GameModeManager: Failed to find PlayerPrefab");

        PlayerActor playerActor = SpawnActor<PlayerActor>(playerPrefab);
        playerActor.Initialize(playerId, position, eulerAngles);
        //playerActor.Teleport(position, eulerAngles);

        IClientInfo player = GetClient(playerId);
        player.PlayerActor = playerActor;
        IPlayerInput playerInput = playerActor.GetScript<PlayerMovement>().Input;
        playerInput.SetFrame(Frame);
        /*if (IsServer)
        {
            serverWorldState.actors.Add(playerActor);
            if (!playerLastReceivedFrames.ContainsKey(playerId))
                playerLastReceivedFrames.Add(playerId, 0);
        }*/

        return playerActor;
    }

    protected T SpawnActor<T>(Prefab prefab) where T : Actor
    {
        T actor = PrefabManager.SpawnPrefab(prefab, _scene).As<T>();
        actor.PhysicsScene = _scene.PhysicsScene;
        return actor;
    }

    virtual public bool IsLocalPlayer(uint playerId) => false;

    virtual public ulong GetLastProcessedFrame(uint playerId) => 0;

    virtual public ulong GetLastReceivedFrame(uint playerId) => 0;

    public PlayerFrame GetPlayerFrame(uint playerId, ulong frame)
    {
        IClientInfo player = GetClient(playerId);
        PlayerFrame playerFrame = player.FrameHistory[frame % 120];
        if (playerFrame.inputState.Frame == frame || playerFrame.movementState.frame == frame)
            return playerFrame;
        return null;
    }

    public bool HasPlayerFrame(uint playerId, ulong frame) => GetPlayerFrame(playerId, frame) != null;

    public bool GetPlayerInputState(uint playerId, ulong frame, out PlayerInputState2 inputState)
    {
        PlayerFrame playerFrame = GetPlayerFrame(playerId, frame);
        inputState = playerFrame?.inputState ?? default;
        return playerFrame != null;
    }

    virtual public void UpdatePlayerInputState(uint playerId, ulong frame, PlayerInputState2 inputState, PlayerMovementState movementState)
    {
        IClientInfo player = GetClient(playerId);

        PlayerFrame playerFrame = player.FrameHistory[frame % 120];
        /*if (playerFrame.frame == frame)
        {
            var old = playerFrame.inputState with { Frame = inputState.Frame };
            playerFrame.inputState = inputState with
            {
                ViewDelta = playerFrame.inputState.ViewDelta + inputState.ViewDelta,
                MoveForward = MathF.MaxMagnitude(playerFrame.inputState.MoveForward, inputState.MoveForward),
                MoveRight = MathF.MaxMagnitude(playerFrame.inputState.MoveRight, inputState.MoveRight),
                Attack = playerFrame.inputState.Attack || inputState.Attack,
                Jump = playerFrame.inputState.Jump || inputState.Jump,
            };

            if (old != playerFrame.inputState)
                old = old;
        }
        else*/
            playerFrame.inputState = inputState;
        playerFrame.inputState.Frame = frame;
        //playerFrame.movementState = movementState;
        //playerFrame.frame = frame;
    }

    virtual public void UpdatePlayerState(uint playerId, ulong frame, PlayerMovementState movementState)
    {
        IClientInfo player = GetClient(playerId);
        PlayerFrame playerFrame = player.FrameHistory[frame % 120];
        playerFrame.movementState = movementState;
        playerFrame.movementState.frame = frame;
    }
}

file class ServerWorld : World
{
    protected class ClientInfo : IClientInfo
    {
        public NetworkConnection Connection { get; set; }
        public PlayerActor PlayerActor { get; set; }
        public PlayerFrame[] FrameHistory { get; set; } = new PlayerFrame[120];
        public ulong LastReceivedFrame = 0;
        public ulong LastSentDeltaFrame = 0; // TODO: Accumulate deltas since this frame
        public ulong LastProcessedFrame = 0; // In case player is lagged behind, these frames should be caught up during next simulation
        public int SendRate = 0; // How many updates the client wants to receive per second

        public ClientInfo()
        {
            for (int i = 0; i < FrameHistory.Length; i++)
            {
                FrameHistory[i] = new PlayerFrame();
                FrameHistory[i].inputState.Frame = ulong.MaxValue;
                FrameHistory[i].movementState.frame = ulong.MaxValue;
            }
        }
    }

    protected Dictionary<uint, ClientInfo> _clients = new();

    protected override IClientInfo GetClient(uint playerId) => _clients[playerId];

    protected override void Init()
    {
        NetworkManager.RegisterServerCallbacks(OnMessage, OnClientConnecting, OnClientConnected);
        GameTime = Time.GameTime;

        CreateScene("Server", "59dd37cc444d5d7015759389c6153c4c");

        base.Init();
    }

    protected override void Cleanup()
    {
        NetworkManager.UnregisterServerCallbacks(OnMessage, OnClientConnecting, OnClientConnected);
        base.Cleanup();
    }

    protected override void OnLateUpdate()
    {
        //Console.Print("server LateFixedUpdate");
        base.OnLateUpdate();

        foreach (var client in _clients.Values)
        {
            // We assume all the scripts have processed the frames during this cycle
            client.LastProcessedFrame = client.LastReceivedFrame;
        }
    }

    public bool OnMessage(ref NetworkEvent networkEvent)
    {
        byte messageTypeByte = networkEvent.Message.ReadByte();
        if (!Enum.IsDefined(typeof(GameModeMessageType2), messageTypeByte))
        {
            //Console.PrintError($"GameModeManager: Unsupported message type received from client: {messageTypeByte}");
            return false;
        }

        GameModeMessageType2 messageType = (GameModeMessageType2)messageTypeByte;
        NetworkManager.DebugLastHandledMessage = messageType.ToString();

        //Console.Print($"GameModeManager: {messageType}");
        switch (messageType)
        {
            case GameModeMessageType2.AcceptConnection: // Client
            {
                break;
            }
            case GameModeMessageType2.PlayerPosition: // FIXME: Should be the delta frame
            {
                //uint playerId = networkEvent.Sender.ConnectionId;
                PlayerInputState2 inputState; //?
                PlayerActorState actorState;

                ulong receivedFrame = networkEvent.Message.ReadUInt64();
                uint reportedPlayerId = networkEvent.Message.ReadUInt32();
                actorState.position.X = networkEvent.Message.ReadSingle();
                actorState.position.Y = networkEvent.Message.ReadSingle();
                actorState.position.Z = networkEvent.Message.ReadSingle();
                actorState.velocity.X = networkEvent.Message.ReadSingle();
                actorState.velocity.Y = networkEvent.Message.ReadSingle();
                actorState.velocity.Z = networkEvent.Message.ReadSingle();
                /*actorState.orientation.X = networkEvent.Message.ReadSingle();
                actorState.orientation.Y = networkEvent.Message.ReadSingle();
                actorState.orientation.Z = networkEvent.Message.ReadSingle();
                actorState.orientation.W = networkEvent.Message.ReadSingle();*/
                actorState.viewAngles.X = networkEvent.Message.ReadSingle();
                actorState.viewAngles.Y = networkEvent.Message.ReadSingle();
                actorState.viewAngles.Z = networkEvent.Message.ReadSingle();
                actorState.lastJumpTime = networkEvent.Message.ReadSingle();
                actorState.numJumps = networkEvent.Message.ReadInt32();
                actorState.jumped = networkEvent.Message.ReadBoolean();

                //inputState.frame = receivedFrame;
                inputState.ViewDelta.X = networkEvent.Message.ReadSingle();
                inputState.ViewDelta.Y = networkEvent.Message.ReadSingle();
                inputState.MoveForward = networkEvent.Message.ReadSingle();
                inputState.MoveRight = networkEvent.Message.ReadSingle();
                inputState.Attack = networkEvent.Message.ReadBoolean();
                inputState.Jump = networkEvent.Message.ReadBoolean();

                ServerFrame = receivedFrame;
                break;
            }
            case GameModeMessageType2.PlayerInput:
            {
                PlayerInputState2 inputState; //?

                ulong receivedFrame = inputState.Frame = networkEvent.Message.ReadUInt64();
                uint playerId = networkEvent.Message.ReadUInt32();
                float time = networkEvent.Message.ReadSingle();
                float delay = Time.TimeSinceStartup - time;
                inputState.ViewDelta.X = networkEvent.Message.ReadSingle();
                inputState.ViewDelta.Y = networkEvent.Message.ReadSingle();
                inputState.MoveForward = networkEvent.Message.ReadSingle();
                inputState.MoveRight = networkEvent.Message.ReadSingle();
                inputState.Attack = networkEvent.Message.ReadBoolean();
                inputState.Jump = networkEvent.Message.ReadBoolean();

                //Console.Print("recv: " + receivedFrame.ToString());

                ClientInfo player = GetClient(playerId) as ClientInfo;
                if (receivedFrame <= player.LastReceivedFrame)
                {
                    if (receivedFrame < player.LastProcessedFrame)
                    {
                        Console.PrintWarning($"Dropping late frame from client: {receivedFrame}, last processed: {player.LastProcessedFrame}");
                        break;
                    }
                    else
                    {
                        //Console.PrintWarning($"Out-of-order frame received from client: {receivedFrame}, latest: {player.LastReceivedFrame}");
                    }
                }
                player.LastReceivedFrame = Math.Max(receivedFrame, player.LastReceivedFrame);
                //if (player.LastProcessedFrame == 0)
                //    player.LastProcessedFrame = receivedFrame - 1;

                //Console.Print($"server receive client frame {receivedFrame}, current server frame {Frame}");
                var asdf = receivedFrame;
                //receivedFrame = Frame; // TODO: receive all frames from players, simulate all unprocessed frames in next simulation cycle?

                if (inputState.MoveForward != 0)
                    receivedFrame = receivedFrame;

                //Console.Print($"delay: {delay * 1000}ms");

                // Sanity check
                if (GetPlayerInputState(playerId, receivedFrame, out var prevInputState))
                {
                    Console.PrintWarning($"Duplicate frame received from client: {asdf}, delay: {delay*1000}ms");
                    //break;
                }

                UpdatePlayerInputState(playerId, receivedFrame, inputState, default);
                break;
            }
            default:
                break;
        }

        return true;
    }

    public bool OnClientConnecting(NetworkConnection connection)
    {
        AcceptConnectionMessage message = new AcceptConnectionMessage();
        message.Frame = Frame;
        message.GameTime = GameTime;
        message.Players = new AcceptConnectionMessage.PlayerInfo[_clients.Count];

        int playerIndex = 0;
        foreach (var player in _clients.Values)
        {
            ref AcceptConnectionMessage.PlayerInfo playerInfo = ref message.Players[playerIndex];
            playerInfo.PlayerId = player.PlayerActor.GetScript<PlayerMovement>().PlayerId;
            playerInfo.PlayerPosition = player.PlayerActor.Position;
            playerIndex++;
        }
        NetworkMessage networkMessage = NetworkManager.ServerBeginSendMessage();
        message.Write(ref networkMessage);
        NetworkManager.ServerEndSendMessage(ref networkMessage, connection);
        return true;
    }

    public void OnClientConnected(NetworkConnection connection)
    {
        uint playerId = connection.ConnectionId;
        _clients.Add(playerId, new ClientInfo() { Connection = connection });

        var spawns = _worldSpawn.GetChildren<Actor>().Where(x => x.Name.StartsWith("PlayerSpawn_")).ToArray();
        Console.Print($"found {spawns.Length} spawns");

        var randomSpawn = spawns.First();

        Float3 position = randomSpawn.Position + new Float3(0f, 4.1f, 0f);
        Float3 eulerAngles = randomSpawn.Orientation.EulerAngles;

        SpawnPlayer(playerId, position, eulerAngles);
        {
            NetworkMessage message = NetworkManager.ServerBeginSendMessage();
            message.WriteByte((byte)GameModeMessageType.SpawnPlayer);
            message.WriteUInt32(playerId);
            message.WriteUInt64(Frame);
            message.WriteSingle(position.X);
            message.WriteSingle(position.Y);
            message.WriteSingle(position.Z);
            message.WriteSingle(eulerAngles.X);
            message.WriteSingle(eulerAngles.Y);
            message.WriteSingle(eulerAngles.Z);
            NetworkManager.ServerEndSendMessage(ref message, connection);
        }
    }

    public override ulong GetLastProcessedFrame(uint playerId)
    {
        ClientInfo player = GetClient(playerId) as ClientInfo;
        return player.LastProcessedFrame;
    }

    public override ulong GetLastReceivedFrame(uint playerId)
    {
        ClientInfo player = GetClient(playerId) as ClientInfo;
        return player.LastReceivedFrame;
    }

    public override void UpdatePlayerInputState(uint playerId, ulong frame, PlayerInputState2 inputState, PlayerMovementState movementState)
    {
        base.UpdatePlayerInputState(playerId, frame, inputState, movementState);

        //ClientInfo player = GetClient(playerId) as ClientInfo;
        //player.LastReceivedFrame = frame; // Dropped frames should be ignored?
    }

    protected override PlayerActor SpawnPlayer(uint playerId, Float3 position, Vector3 eulerAngles)
    {
        var playerActor = base.SpawnPlayer(playerId, position, eulerAngles);
        playerActor.Input = new PlayerInputNetwork2(playerId, this);
        return playerActor;
    }
}

file class ClientWorld : World
{
    protected class ClientInfo : IClientInfo
    {
        public NetworkConnection Connection { get; set; }
        public PlayerActor PlayerActor { get; set; }
        public PlayerFrame[] FrameHistory { get; set; } = new PlayerFrame[120];

        public ClientInfo()
        {
            for (int i = 0; i < FrameHistory.Length; i++)
                FrameHistory[i] = new PlayerFrame();
        }
    }

    private uint _localPlayerId;

    protected Dictionary<uint, ClientInfo> _clients = new();

    protected override IClientInfo GetClient(uint playerId) => _clients[playerId];

    protected override void Init()
    {
        NetworkManager.RegisterClientCallbacks(OnMessage, null, OnClientConnected);

        CreateScene("Client", "c095f9ac4989a46afd7fe3821f086e2e");

        base.Init();
    }

    protected override void Cleanup()
    {
        NetworkManager.UnregisterClientCallbacks(OnMessage, null, OnClientConnected);
        base.Cleanup();
    }

    override protected void OnLateUpdate()
    {
        foreach (var player in _scene.GetChildren<PlayerActor>())
        {
            if (player.PlayerId != _localPlayerId)
                continue;

            ClientInfo playerClient = GetClient(player.PlayerId) as ClientInfo;
            PlayerInputState2 inputState = player.Input.GetState();
            PlayerMovementState movementState = player.GetScript<PlayerMovement>().movementState;

            if (inputState.Frame == 0)
                inputState = inputState;
            /*public Float2 ViewDelta;
            public float MoveForward;
            public float MoveRight;
            public bool Attack;
            public bool Jump;*/


            //Console.Print($"client send {Frame}");
            UpdatePlayerInputState(player.PlayerId, Frame, inputState, movementState);
            //Console.Print($"cframe: {Frame}");

            NetworkMessage message = NetworkManager.ClientBeginSendMessage();
            message.WriteByte((byte)GameModeMessageType2.PlayerInput);
            message.WriteUInt64(Frame);
            message.WriteUInt32(player.PlayerId);
            message.WriteSingle(Time.TimeSinceStartup);
            message.WriteVector2(inputState.ViewDelta);
            message.WriteSingle(inputState.MoveForward);
            message.WriteSingle(inputState.MoveRight);
            message.WriteBoolean(inputState.Attack);
            message.WriteBoolean(inputState.Jump);
            NetworkManager.ClientEndSendMessage(ref message);

            //Console.Print("send: " + Frame.ToString());
        }
        base.OnLateUpdate();
    }

    public bool OnMessage(ref NetworkEvent networkEvent)
    {
        byte messageTypeByte = networkEvent.Message.ReadByte();
        if (!Enum.IsDefined(typeof(GameModeMessageType2), messageTypeByte))
        {
            //Console.PrintError($"GameModeManager: Unsupported message type received from client: {messageTypeByte}");
            return false;
        }

        GameModeMessageType2 messageType = (GameModeMessageType2)messageTypeByte;
        NetworkManager.DebugLastHandledMessage = messageType.ToString();

        //Console.Print($"GameModeManager: {messageType}");
        switch (messageType)
        {
            case GameModeMessageType2.AcceptConnection:
            {
                // Setup some initial state for newly connected client
                AcceptConnectionMessage welcomePlayer = AcceptConnectionMessage.Read(ref networkEvent.Message);
                ServerFrame = welcomePlayer.Frame;
                Frame += welcomePlayer.Frame;

                GameTime = welcomePlayer.GameTime;
                foreach (var playerInfo in welcomePlayer.Players)
                {
                    _clients.Add(playerInfo.PlayerId, new ClientInfo());
                    SpawnPlayer(playerInfo.PlayerId, playerInfo.PlayerPosition, new Float3(0));
                }

                Console.Print("received welcome: frame " + ServerFrame);
                break;
            }
            case GameModeMessageType2.SpawnPlayer:
            {
                uint playerId = networkEvent.Message.ReadUInt32();
                ulong playerFrameIndex = networkEvent.Message.ReadUInt64();
                Float3 position = new Float3(networkEvent.Message.ReadSingle(), networkEvent.Message.ReadSingle(), networkEvent.Message.ReadSingle());
                Vector3 eulerAngles = new Float3(networkEvent.Message.ReadSingle(), networkEvent.Message.ReadSingle(), networkEvent.Message.ReadSingle());

                /*if (!clientWorldState.playerFrameHistory.ContainsKey(playerId))
                {
                    var playerFrames = new PlayerFrame[120];
                    for (int j = 0; j < playerFrames.Length; j++)
                        playerFrames[j] = new PlayerFrame();
                    clientWorldState.playerFrameHistory.Add(playerId, playerFrames);
                }*/

                SpawnPlayer(playerId, position, eulerAngles);

                //if (NetworkManager.IsClient)
                //players[playerId].GetScript<PlayerMovement>().Input.SetFrame(ClientFrame);
                break;
            }
#if false
            case GameModeMessageType2.PlayerPosition:
            {
                //uint playerId = networkEvent.Sender.ConnectionId;
                PlayerInputState2 inputState; //?
                PlayerActorState actorState;

                ulong receivedFrame = networkEvent.Message.ReadUInt64();
                uint reportedPlayerId = networkEvent.Message.ReadUInt32();
                actorState.position.X = networkEvent.Message.ReadSingle();
                actorState.position.Y = networkEvent.Message.ReadSingle();
                actorState.position.Z = networkEvent.Message.ReadSingle();
                actorState.velocity.X = networkEvent.Message.ReadSingle();
                actorState.velocity.Y = networkEvent.Message.ReadSingle();
                actorState.velocity.Z = networkEvent.Message.ReadSingle();
                /*actorState.orientation.X = networkEvent.Message.ReadSingle();
                actorState.orientation.Y = networkEvent.Message.ReadSingle();
                actorState.orientation.Z = networkEvent.Message.ReadSingle();
                actorState.orientation.W = networkEvent.Message.ReadSingle();*/
                actorState.viewAngles.X = networkEvent.Message.ReadSingle();
                actorState.viewAngles.Y = networkEvent.Message.ReadSingle();
                actorState.viewAngles.Z = networkEvent.Message.ReadSingle();
                actorState.lastJumpTime = networkEvent.Message.ReadSingle();
                actorState.numJumps = networkEvent.Message.ReadInt32();
                actorState.jumped = networkEvent.Message.ReadBoolean();

                //inputState.frame = receivedFrame;
                inputState.ViewDelta.X = networkEvent.Message.ReadSingle();
                inputState.ViewDelta.Y = networkEvent.Message.ReadSingle();
                inputState.MoveForward = networkEvent.Message.ReadSingle();
                inputState.MoveRight = networkEvent.Message.ReadSingle();
                inputState.Attack = networkEvent.Message.ReadBoolean();
                inputState.Jump = networkEvent.Message.ReadBoolean();

                ServerFrame = receivedFrame;
                break;
            }
#endif
            default:
                break;
        }

        return true;
    }

    public override bool IsLocalPlayer(uint playerId) => playerId == _localPlayerId;

    public override ulong GetLastProcessedFrame(uint playerId)
    {
        //ClientInfo player = GetClient(playerId) as ClientInfo;
        return 0;
    }

    public override ulong GetLastReceivedFrame(uint playerId)
    {
        //ClientInfo player = GetClient(playerId) as ClientInfo;
        return 0;
    }

    public void OnClientConnected(NetworkConnection connection)
    {
        uint playerId = connection.ConnectionId;
        _clients.Add(playerId, new ClientInfo() { Connection = connection });

        _localPlayerId = playerId;
        Console.Print($"ClientWorld: Connected, playerId: {_localPlayerId}");
    }

    protected override PlayerActor SpawnPlayer(uint playerId, Float3 position, Vector3 eulerAngles)
    {
        var playerActor = base.SpawnPlayer(playerId, position, eulerAngles);
        if (playerId == _localPlayerId)
            playerActor.Input = new PlayerInput2();
        else
            playerActor.Input = new PlayerInputNetwork2(playerId, this);
        return playerActor;
    }
}

public static class WorldExtensions
{
    public static World GetWorld(this Script script) => IsServerScene(script.Scene) ? WorldStore.ServerWorld : WorldStore.ClientWorld;

    public static World GetWorld(this Actor actor) => IsServerScene(actor.Scene) ? WorldStore.ServerWorld : WorldStore.ClientWorld;

    private static bool IsServerScene(Scene scene) => scene.Name == "ServerScene";
}

file static class WorldStore
{
    public static ServerWorld ServerWorld;
    public static ClientWorld ClientWorld;
}

/*file class WorldPlugin : GamePlugin
{
    public WorldPlugin()
    {
    }

    public override void Initialize()
    {
        
        WorldStore.ClientWorld = new World(isServer: false);
    }

    public override void Deinitialize()
    {
        WorldStore.ServerWorld = null;
        WorldStore.ClientWorld = null;
    }
}*/