using UnityEngine;
using Unity.Netcode;

/// <summary>
/// First-person mode. The player keeps walking (WASD, camera-relative) but the camera moves to the
/// player's eye (the CameraTarget) with free mouse-look, and the player's mesh is hidden so the body
/// isn't seen from the inside. The orbit camera input is disabled while here so it doesn't fight for
/// the cursor; the <see cref="FirstPersonController"/> drives its own dedicated CinemachineCamera.
/// </summary>
public class FirstPersonMode : GameMode
{
    public override string DisplayName => "First Person";

    public override void Enter()
    {
        // Player stays fully controllable; only the view changes.
        SetPlayerControl(true);
        SetPainting(false);
        SetOrbitInputEnabled(false);

        if (Manager.FirstPerson)
            Manager.FirstPerson.SetActive(true);
    }

    public override void Exit()
    {
        // Modes are Enter-only, so first-person must undo its own camera takeover (and unhide the mesh)
        // here; the next mode's Enter restores the player/painter/look-mode state.
        if (Manager.FirstPerson)
            Manager.FirstPerson.SetActive(false);

        SetOrbitInputEnabled(true);
        if (Manager.CameraInput)
        {
            // Carry the first-person facing into the orbit camera so the next orbit mode (Paint / Player
            // Control) keeps the current view angle instead of snapping back to the orbit's last-used angle.
            // Camera.main still shows the first-person view this frame (the brain hasn't blended yet).
            Manager.CameraInput.SyncToView();
        }
    }

    // --- Hunter shooting -------------------------------------------------------------------------------
    // A hunter in first person shoots a single ray from the camera centre on left-click (with a cooldown),
    // but only during the SEEK sub-phase. A hit on an un-found hider is reported to the server, which
    // validates and marks the hider found. Gated on the local avatar actually being a hunter role variant,
    // so the legacy lobby first-person view never shoots.

    private float _nextShootTime;
    private static readonly RaycastHit[] _hits = new RaycastHit[32];
    private static bool _hitsSaturated; // log-once: a saturated buffer can silently drop the true blocker

    // Cached per bound avatar: CanShoot runs every Tick during a match.
    private PlayerCharacterController _setupSource;
    private NetworkPlayerSetup _setup;

    public override void Tick()
    {
        if (!CanShoot()) return;
        if (Time.time < _nextShootTime) return;
        if (!InputUtil.LeftClickedThisFrame()) return;

        _nextShootTime = Time.time + Mathf.Max(0f, MatchManager.Instance.ShootCooldown);
        TryShoot();
    }

    private bool CanShoot()
    {
        var match = MatchManager.Instance;
        if (!match || !match.MatchActive || match.LocalSubPhase != MatchManager.MatchSubPhase.Seek) return false;
        var player = Manager.Player;
        if (!player || !Manager.FirstPerson) return false;

        if (player != _setupSource)
        {
            _setupSource = player;
            _setup = player.GetComponent<NetworkPlayerSetup>();
        }
        return _setup && _setup.ScopedModes && _setup.Role == PlayerRole.Hunter;
    }

    private void TryShoot()
    {
        var match = MatchManager.Instance;
        Transform cam = Manager.FirstPerson.transform; // FP vcam sits at the eye, facing the look direction
        float range = Mathf.Max(0f, match.ShootRange);

        int count = Physics.RaycastNonAlloc(cam.position, cam.forward, _hits, range, ~0, QueryTriggerInteraction.Ignore);
        if (count == _hits.Length && !_hitsSaturated)
        {
            _hitsSaturated = true;
            Debug.LogWarning($"FirstPersonMode: shot raycast buffer saturated ({count}); the nearest blocker may be missed.");
        }
        if (count == 0) return;

        // Nearest-first so the shot stops at the first solid thing it meets (a wall blocks; a nearer avatar
        // shields a farther one). The hunter's own body is skipped so looking down doesn't self-block.
        System.Array.Sort(_hits, 0, count, RaycastDistanceComparer.Instance);

        NetworkObject self = Manager.Player ? Manager.Player.GetComponent<NetworkObject>() : null;
        for (int i = 0; i < count; i++)
        {
            var netObj = _hits[i].collider.GetComponentInParent<NetworkObject>();
            if (netObj && self && netObj == self) continue;
            if (!netObj || !netObj.IsPlayerObject) return;   // first solid hit is world geometry -> blocked

            var setup = netObj.GetComponent<NetworkPlayerSetup>();
            if (setup && setup.Role == PlayerRole.Hider && !setup.IsFound)
                match.ReportHit(netObj.OwnerClientId);
            return; // the first non-self hit decides the shot
        }
    }

    private sealed class RaycastDistanceComparer : System.Collections.Generic.IComparer<RaycastHit>
    {
        public static readonly RaycastDistanceComparer Instance = new RaycastDistanceComparer();
        public int Compare(RaycastHit a, RaycastHit b) => a.distance.CompareTo(b.distance);
    }
}