using UnityEngine;

using System.Collections;

public class Reel : MonoBehaviour

{

    private FaceScriptableObject[] faces;

    public float faceSpriteSize = 1.0f;

    public float spacing = 0.5f;

    public float baseSpinSpeed = 5.0f;

    public float minSpinTime = 2.0f;

    public float maxSpinTime = 5.0f;

    public float faceHeightSpacing = 1.0f;

    public bool isSpinning { get; private set; }

    public AudioClip spinAudioClip;

    private AudioSource audioSource;

    private bool shouldStop = false;

    private int winningIndex;

    private float spinDuration;

    private void Start()

    {

        audioSource = GetComponent<AudioSource>();

    }

    public void InitializeReel(ReelScriptableObject reelData)

    {

        faces = reelData.faces;

        BuildReel();

    }

    private void BuildReel()

    {

        // Clear existing faces

        foreach (Transform child in transform)

        {

            Destroy(child.gameObject);

        }

        if (faces == null || faces.Length == 0)

        {

            Debug.LogError("Faces array is not assigned or empty.");

            return;

        }

        Debug.Log("Building reel with " + faces.Length + " faces.");

        float reelHeight = faces.Length * (faceSpriteSize + faceHeightSpacing);

        for (int i = 0; i < faces.Length; i++)

        {

            GameObject faceObj = new GameObject("Face" + (i + 1));

            faceObj.transform.SetParent(transform);

            faceObj.transform.localPosition = new Vector3(0, reelHeight / 2 - i * (faceSpriteSize + faceHeightSpacing), 0);

            SpriteRenderer faceRenderer = faceObj.AddComponent<SpriteRenderer>();

            faceRenderer.sprite = faces[i].sprite;

            if (faces[i].sprite == null)

            {

                Debug.LogError("Sprite not assigned for face: " + faces[i].itemName);

                continue;

            }

            faceRenderer.sortingLayerName = "Reels";

            faceRenderer.sortingOrder = i + 1;

            faceRenderer.maskInteraction = SpriteMaskInteraction.None; // Set to None for now

            faceRenderer.enabled = true;

            Debug.Log($"Reel {gameObject.name}: Face {i + 1} assigned with sprite: {faces[i].sprite.name} at position: {faceObj.transform.localPosition}");

        }

        Debug.Log("Reel building complete. Child count: " + transform.childCount);

    }

    public void StartSpin()

    {

        if (transform.childCount == 0)

        {

            Debug.LogError("No faces available for spinning.");

            return;

        }

        isSpinning = true;

        shouldStop = false;

        spinDuration = Random.Range(minSpinTime, maxSpinTime);

        if (audioSource != null && spinAudioClip != null)

        {

            audioSource.clip = spinAudioClip;

            audioSource.Play();

        }

        StartCoroutine(SpinReel());

    }

    private IEnumerator SpinReel()

    {

        float reelHeight = faces.Length * (faceSpriteSize + faceHeightSpacing);

        float spinTime = 0f;

        while (!shouldStop && spinTime < spinDuration)

        {

            spinTime += Time.deltaTime;

            for (int i = 0; i < transform.childCount; i++)

            {

                Transform faceTransform = transform.GetChild(i);

                SpriteRenderer faceRenderer = faceTransform.GetComponent<SpriteRenderer>();

                float newY = faceTransform.localPosition.y - (baseSpinSpeed * Time.deltaTime);

                if (newY < -reelHeight / 2)

                {

                    newY += reelHeight;

                }

                faceTransform.localPosition = new Vector3(0, newY, faceTransform.localPosition.z); // Ensure faces are centered

                faceRenderer.enabled = faceTransform.localPosition.y <= reelHeight / 2 && faceTransform.localPosition.y >= -reelHeight / 2;

                Debug.Log($"Face {i + 1} position: {faceTransform.localPosition} - visibility: {faceRenderer.enabled}");

            }

            yield return null;

        }

        Debug.Log("Stopping reel...");

        FindWinningFace();

        StopReel();

        Debug.Log("Reel finished spinning with winning face: " + faces[winningIndex].itemName);

        StartCoroutine(WinningFaceEffect(transform.GetChild(winningIndex), 2.0f));

    }

    private void FindWinningFace()

    {

        Transform closestFace = null;

        float closestDistance = float.MaxValue;

        Debug.Log("Finding winning face...");

        Debug.Log("Child count: " + transform.childCount);

        for (int i = 0; i < transform.childCount; i++)

        {

            Transform faceTransform = transform.GetChild(i);

            if (faceTransform == null)

            {

                Debug.LogError("Face transform is null at index: " + i);

                continue;

            }

            float distance = Mathf.Abs(faceTransform.localPosition.y);

            if (distance < closestDistance)

            {

                closestDistance = distance;

                closestFace = faceTransform;

            }

        }

        if (closestFace == null)

        {

            Debug.LogError("No closest face found!");

            return;

        }

        float centerY = 0;

        closestFace.localPosition = new Vector3(0, centerY, closestFace.localPosition.z);

        winningIndex = closestFace.GetSiblingIndex();

        Debug.Log("Winning face index: " + winningIndex);

        for (int i = 0; i < transform.childCount; i++)

        {

            if (i != winningIndex)

            {

                Transform faceTransform = transform.GetChild(i);

                float offset = (i - winningIndex) * (faceSpriteSize + faceHeightSpacing);

                faceTransform.localPosition = new Vector3(0, centerY + offset, faceTransform.localPosition.z);

            }

        }

    }

    private void StopReel()

    {

        if (audioSource != null && audioSource.isPlaying)

        {

            audioSource.Stop();

        }

        isSpinning = false;

    }

    public void StopSpin()

    {

        shouldStop = true;

        Debug.Log("StopSpin called, shouldStop set to true.");

    }

    public FaceScriptableObject GetWinningFace()

    {

        if (winningIndex >= 0 && winningIndex < faces.Length)

        {

            return faces[winningIndex];

        }

        else

        {

            Debug.LogError("Winning index is out of bounds: " + winningIndex);

            return null;

        }

    }

    private IEnumerator WinningFaceEffect(Transform winningFace, float duration)

    {

        SpriteRenderer faceRenderer = winningFace.GetComponent<SpriteRenderer>();

        float elapsed = 0.0f;

        float blinkInterval = 0.1f;

        bool isVisible = true;

        // Instantiate the winning prefab

        FaceScriptableObject winningFaceSO = faces[winningIndex];

        GameObject winningPrefabInstance = null;

        if (winningFaceSO.prefab != null)

        {

            winningPrefabInstance = Instantiate(winningFaceSO.prefab, transform);

            winningPrefabInstance.transform.position = winningFace.position;

            Debug.Log("Prefab instantiated: " + winningFaceSO.prefab.name);

        }

        else

        {

            Debug.Log("No prefab attached to the winning face.");

        }

        while (elapsed < duration)

        {

            elapsed += Time.deltaTime;

            float rotation = 360 * (elapsed / duration);

            winningFace.eulerAngles = new Vector3(0, rotation, 0);

            if (elapsed % blinkInterval < blinkInterval / 2)

            {

                isVisible = !isVisible;

                faceRenderer.enabled = isVisible;

            }

            yield return null;

        }

        faceRenderer.enabled = true;

        winningFace.eulerAngles = Vector3.zero;

        // Ensure the prefab is properly positioned and visible

        if (winningPrefabInstance != null)

        {

            Debug.Log("Prefab final position set to: " + winningPrefabInstance.transform.position);

            // Trigger animation on the winning prefab

            Animator animator = winningPrefabInstance.GetComponent<Animator>();

            if (animator != null)

            {

                animator.SetTrigger("Play");

                Debug.Log("Animation triggered on prefab.");

            }

            else

            {

                Debug.LogError("Animator component missing on the prefab.");

            }

        }

    }

}