namespace Minecraft.Server.FourKit.Entity;

using System.Runtime.InteropServices;
using Minecraft.Server.FourKit.Command;
using Minecraft.Server.FourKit.Inventory;
using Minecraft.Server.FourKit.Net;

/// <summary>
/// Represents a player connected to the server.
/// </summary>
public class Player : HumanEntity, OfflinePlayer, CommandSender
{
    private float _saturation = 5.0f;
    private float _walkSpeed = 0.2f;
    private Guid _playerUniqueId;
    private string? _displayName;
    private bool _sneaking;
    private bool _sprinting;
    private bool _allowFlight;
    private bool _sleepingIgnored;

    internal bool IsOnline { get; set; }

    internal Player(int entityId, string name)
    {
        SetEntityIdInternal(entityId);
        SetEntityTypeInternal(EntityType.PLAYER);
        SetNameInternal(name);
        IsOnline = true;
        _playerInventory._holder = this;
    }

    /// <inheritdoc/>
    public override EntityType getType() => EntityType.PLAYER;

    /// <inheritdoc/>
    public override EntityType GetType() => EntityType.PLAYER;

    /// <inheritdoc/>
    public override bool teleport(Location location)
    {
        NativeBridge.TeleportPlayer?.Invoke(getEntityId(), location.X, location.Y, location.Z);
        SetLocation(location);
        return true;
    }

    /// <inheritdoc/>
    public Player? getPlayer() => IsOnline ? this : null;

    /// <summary>
    /// Gets the "friendly" name to display of this player.
    /// This may include color. If no custom display name has been set,
    /// this returns the player's <see cref="HumanEntity.getName"/>.
    /// </summary>
    /// <returns>The display name.</returns>
    public string getDisplayName() => _displayName ?? getName();

    /// <summary>
    /// Sets the "friendly" name to display of this player.
    /// </summary>
    /// <param name="name">The display name, or <c>null</c> to reset to <see cref="HumanEntity.getName"/>.</param>
    public void setDisplayName(string? name)
    {
        _displayName = name;
    }

    /// <inheritdoc/>
    public bool isOnline() => IsOnline;

    /// <summary>
    /// Returns the UUID that uniquely identifies this player across sessions.
    /// This is the player-specific UUID, not the entity UUID.
    /// </summary>
    /// <returns>The player's unique identifier.</returns>
    public new Guid getUniqueId() => _playerUniqueId;

    /// <summary>
    /// Gets the player's current saturation level.
    /// Saturation acts as a buffer before hunger begins to deplete.
    /// </summary>
    /// <returns>The current saturation level.</returns>
    public float getSaturation() => _saturation;

    /// <summary>
    /// Gets the current allowed speed that a client can walk.
    /// The default value is 0.2.
    /// </summary>
    /// <returns>The current walk speed.</returns>
    public float getWalkSpeed() => _walkSpeed;

    /// <summary>
    /// Sets the speed at which a client will walk.
    /// This calls into the native server to apply the change.
    /// </summary>
    /// <param name="value">The new walk speed.</param>
    public void setWalkSpeed(float value)
    {
        _walkSpeed = value;
        NativeBridge.SetWalkSpeed?.Invoke(getEntityId(), value);
    }

    /// <summary>
    /// Returns if the player is in sneak mode.
    /// </summary>
    /// <returns>True if player is in sneak mode.</returns>
    public bool isSneaking() => _sneaking;

    /// <summary>
    /// Gets whether the player is sprinting or not.
    /// </summary>
    /// <returns>True if player is sprinting.</returns>
    public bool isSprinting() => _sprinting;

    /// <summary>
    /// Sets whether the player is ignored as not sleeping. If everyone is
    /// either sleeping or has this flag set, then time will advance to the
    /// next day. If everyone has this flag set but no one is actually in
    /// bed, then nothing will happen.
    /// </summary>
    /// <param name="isSleeping">Whether to ignore.</param>
    public void setSleepingIgnored(bool isSleeping)
    {
        _sleepingIgnored = isSleeping;
        NativeBridge.SetSleepingIgnored?.Invoke(getEntityId(), isSleeping ? 1 : 0);
    }

    /// <summary>
    /// Returns whether the player is sleeping ignored.
    /// </summary>
    /// <returns>Whether player is ignoring sleep.</returns>
    public bool isSleepingIgnored() => _sleepingIgnored;

    /// <summary>
    /// Play a sound for a player at the location.
    /// This function will fail silently if Location or Sound are null.
    /// </summary>
    /// <param name="location">The location to play the sound.</param>
    /// <param name="sound">The sound to play.</param>
    /// <param name="volume">The volume of the sound.</param>
    /// <param name="pitch">The pitch of the sound.</param>
    public void playSound(Location location, Sound sound, float volume, float pitch)
    {
        if (location == null)
            return;
        NativeBridge.PlaySound?.Invoke(getEntityId(), (int)sound, location.X, location.Y, location.Z, volume, pitch);
    }

    /// <summary>
    /// Determines if the Player is allowed to fly via jump key double-tap
    /// like in creative mode.
    /// </summary>
    /// <returns>True if the player is allowed to fly.</returns>
    public bool getAllowFlight() => _allowFlight;

    /// <summary>
    /// Sets if the Player is allowed to fly via jump key double-tap like
    /// in creative mode.
    /// </summary>
    /// <param name="flight">If flight should be allowed.</param>
    public void setAllowFlight(bool flight)
    {
        _allowFlight = flight;
        NativeBridge.SetAllowFlight?.Invoke(getEntityId(), flight ? 1 : 0);
    }

    /// <inheritdoc/>
    public void sendMessage(string message)
    {
        if (string.IsNullOrEmpty(message) || NativeBridge.SendMessage == null)
            return;
        if (message.Length > FourKit.MAX_CHAT_LENGTH)
            message = message[..FourKit.MAX_CHAT_LENGTH];

        IntPtr ptr = Marshal.StringToCoTaskMemUTF8(message);
        try
        {
            NativeBridge.SendMessage(getEntityId(), ptr, System.Text.Encoding.UTF8.GetByteCount(message));
        }
        finally
        {
            Marshal.FreeCoTaskMem(ptr);
        }
    }

    /// <inheritdoc/>
    public void sendMessage(string[] messages)
    {
        foreach (var msg in messages)
            sendMessage(msg);
    }

    /// <summary>
    /// Kicks player with the default <see cref="DisconnectReason.KICKED"/> reason.
    /// </summary>
    public void kickPlayer()
    {
        NativeBridge.KickPlayer?.Invoke(getEntityId(), (int)DisconnectReason.KICKED);
    }

    /// <summary>
    /// Bans the player by UID with the specified reason and disconnects them.
    /// </summary>
    /// <param name="reason">The ban reason.</param>
    /// <returns><c>true</c> if the ban was applied successfully.</returns>
    public bool banPlayer(string reason)
    {
        if (NativeBridge.BanPlayer == null) return false;
        IntPtr ptr = Marshal.StringToCoTaskMemUTF8(reason ?? string.Empty);
        try
        {
            int byteLen = System.Text.Encoding.UTF8.GetByteCount(reason ?? string.Empty);
            return NativeBridge.BanPlayer(getEntityId(), ptr, byteLen) != 0;
        }
        finally
        {
            Marshal.FreeCoTaskMem(ptr);
        }
    }

    /// <summary>
    /// Bans the player's IP address with the specified reason.
    /// </summary>
    /// <param name="reason">The ban reason.</param>
    /// <returns><c>true</c> if the IP ban was applied successfully.</returns>
    public bool banPlayerIp(string reason)
    {
        if (NativeBridge.BanPlayerIp == null) return false;
        IntPtr ptr = Marshal.StringToCoTaskMemUTF8(reason ?? string.Empty);
        try
        {
            int byteLen = System.Text.Encoding.UTF8.GetByteCount(reason ?? string.Empty);
            return NativeBridge.BanPlayerIp(getEntityId(), ptr, byteLen) != 0;
        }
        finally
        {
            Marshal.FreeCoTaskMem(ptr);
        }
    }

    /// <summary>
    /// Gets the socket address of this player.
    /// </summary>
    /// <returns>The player's socket address, or <c>null</c> if the address could not be determined.</returns>
    public InetSocketAddress? getAddress()
    {
        if (NativeBridge.GetPlayerAddress == null)
            return null;

        const int ipBufSize = 64;
        IntPtr ipBuf = Marshal.AllocCoTaskMem(ipBufSize);
        IntPtr portBuf = Marshal.AllocCoTaskMem(sizeof(int));
        try
        {
            int result = NativeBridge.GetPlayerAddress(getEntityId(), ipBuf, ipBufSize, portBuf);
            if (result == 0)
                return null;

            string? ip = Marshal.PtrToStringAnsi(ipBuf);
            int port = Marshal.ReadInt32(portBuf);

            if (string.IsNullOrEmpty(ip))
                return null;

            return new InetSocketAddress(new InetAddress(ip), port);
        }
        finally
        {
            Marshal.FreeCoTaskMem(ipBuf);
            Marshal.FreeCoTaskMem(portBuf);
        }
    }

    // INTERNAL
    internal void SetSaturationInternal(float saturation) => _saturation = saturation;
    internal void SetWalkSpeedInternal(float walkSpeed) => _walkSpeed = walkSpeed;
    internal void SetPlayerUniqueIdInternal(Guid id) => _playerUniqueId = id;
    internal void SetSneakingInternal(bool sneaking) => _sneaking = sneaking;
    internal void SetSprintingInternal(bool sprinting) => _sprinting = sprinting;
    internal void SetAllowFlightInternal(bool allowFlight) => _allowFlight = allowFlight;
    internal void SetSleepingIgnoredInternal(bool ignored) => _sleepingIgnored = ignored;
}