using UnityEngine;

namespace MegaKoop.Game.Networking
{
    [DisallowMultipleComponent]
    public class SteamHealthNetworkBridge : MonoBehaviour
    {
        [SerializeField] private Combat.Health health;
        [SerializeField] private NetworkIdentity identity;

        private SteamCoopNetworkManager networkManager;
        private bool isRegistered;

        private void Awake()
        {
            if (health == null)
            {
                health = GetComponent<Combat.Health>();
            }

            if (identity == null)
            {
                identity = GetComponent<NetworkIdentity>();
            }
        }

        private void OnEnable()
        {
            networkManager = SteamCoopNetworkManager.Instance;
            if (networkManager != null)
            {
                networkManager.RegisterHandler(NetworkMessageType.HealthSync, HandleHealthSync);
                isRegistered = true;
            }

            if (health != null)
            {
                health.NormalizedHealthChanged += OnHealthChanged;
            }
        }

        private void OnDisable()
        {
            if (isRegistered && networkManager != null)
            {
                networkManager.UnregisterHandler(NetworkMessageType.HealthSync, HandleHealthSync);
                isRegistered = false;
            }

            if (health != null)
            {
                health.NormalizedHealthChanged -= OnHealthChanged;
            }
        }

        private bool IsAuthority()
        {
            return networkManager == null || networkManager.IsHost;
        }

        private void OnHealthChanged(float normalized)
        {
            if (!IsAuthority() || identity == null)
            {
                return;
            }

            var message = new HealthSyncMessage(identity.NetworkId, normalized);
            byte[] payload = HealthSyncMessage.Serialize(message);
            networkManager.SendToAll(NetworkMessageType.HealthSync, payload, Steamworks.EP2PSend.k_EP2PSendReliable);
        }

        private void HandleHealthSync(NetworkMessage message)
        {
            if (IsAuthority() || identity == null || health == null)
            {
                return;
            }

            HealthSyncMessage syncMessage = HealthSyncMessage.Deserialize(message.Payload);
            if (syncMessage.NetworkId != identity.NetworkId)
            {
                return;
            }

            health.ForceSetNormalizedHealth(syncMessage.NormalizedHealth);
        }
    }
}