using UnityEngine;

/// <summary>
/// Handles interaction between players and chunk-based blocks.
/// Converts raycast hits to block indices and manages damage/reveal requests.
/// </summary>
public static class ChunkInteractionHandler
{
    /// <summary>
    /// Result of a chunk interaction query
    /// </summary>
    public struct ChunkHitResult
    {
        public bool hasHit;
        public MineableChunk chunk;
        public int blockIndex;
        public Vector3 hitPoint;
        public Vector3 blockWorldPosition;
        public BlockData blockData;

        public static ChunkHitResult None => new ChunkHitResult { hasHit = false };
    }

    /// <summary>
    /// Try to get chunk and block info from a raycast hit
    /// </summary>
    public static ChunkHitResult GetChunkHit(RaycastHit hit)
    {
        // Try to get MineableChunk from hit collider
        MineableChunk chunk = hit.collider.GetComponentInParent<MineableChunk>();
        if (chunk == null)
        {
            return ChunkHitResult.None;
        }

        // Convert hit point to block index
        // Push slightly into the surface using the normal to get the correct block
        Vector3 insidePoint = hit.point - hit.normal * 0.01f;
        int blockIndex = chunk.WorldPointToBlockIndex(insidePoint);
        BlockData blockData = chunk.GetBlock(blockIndex);

        // Skip if block is empty
        if (blockData.IsEmpty)
        {
            return ChunkHitResult.None;
        }

        return new ChunkHitResult
        {
            hasHit = true,
            chunk = chunk,
            blockIndex = blockIndex,
            hitPoint = hit.point,
            blockWorldPosition = chunk.GetBlockWorldPosition(blockIndex),
            blockData = blockData
        };
    }

    /// <summary>
    /// Try to damage a block at a raycast hit point
    /// </summary>
    public static bool TryDamageAtPoint(RaycastHit hit, float damage)
    {
        ChunkHitResult result = GetChunkHit(hit);
        if (!result.hasHit) return false;

        // Request damage on server
        result.chunk.DamageBlockServerRpc(result.blockIndex, (byte)Mathf.Min(255, damage));
        return true;
    }

    /// <summary>
    /// Try to damage a block directly on a known chunk
    /// </summary>
    public static bool TryDamageBlock(MineableChunk chunk, int blockIndex, float damage)
    {
        if (chunk == null) return false;

        BlockData block = chunk.GetBlock(blockIndex);
        if (block.IsEmpty) return false;

        chunk.DamageBlockServerRpc(blockIndex, (byte)Mathf.Min(255, damage));
        return true;
    }

    /// <summary>
    /// Try to reveal a block at a raycast hit point
    /// </summary>
    public static bool TryRevealAtPoint(RaycastHit hit)
    {
        MineableChunk chunk = hit.collider.GetComponentInParent<MineableChunk>();
        if (chunk == null) return false;

        int blockIndex = chunk.WorldPointToBlockIndex(hit.point - hit.normal * 0.1f);
        BlockData blockData = chunk.GetBlock(blockIndex);

        if (blockData.IsEmpty || blockData.IsDiscovered) return false;

        chunk.RevealBlockServerRpc(blockIndex);
        return true;
    }

    /// <summary>
    /// Perform a sphere cast to find a targetable block in a chunk
    /// </summary>
    public static ChunkHitResult SphereCastForBlock(Vector3 origin, Vector3 direction, float radius, float maxDistance, LayerMask chunkLayer)
    {
        if (Physics.SphereCast(origin, radius, direction, out RaycastHit hit, maxDistance, chunkLayer))
        {
            return GetChunkHit(hit);
        }
        return ChunkHitResult.None;
    }

    /// <summary>
    /// Perform a raycast to find a targetable block in a chunk
    /// </summary>
    public static ChunkHitResult RaycastForBlock(Vector3 origin, Vector3 direction, float maxDistance, LayerMask chunkLayer)
    {
        if (Physics.Raycast(origin, direction, out RaycastHit hit, maxDistance, chunkLayer))
        {
            return GetChunkHit(hit);
        }
        return ChunkHitResult.None;
    }
}