using UnityEngine;

using System.Collections;

public class SlotMachineScriptableObject : MonoBehaviour

{

    public ReelScriptableObject[] reels; // Array of reels used in the slot machine

    public float faceSpriteSize = 1.0f; // Size of the face sprites

    public float spacing = 0.5f; // Spacing between the face sprites

    public float reelSpacing = 2.0f; // Spacing between the reels

    public float baseSpinSpeed = 5.0f; // Base speed at which the faces move

    public float minSpinTime = 2.0f; // Minimum spin time

    public float maxSpinTime = 5.0f; // Maximum spin time

    private void Start()

    {

        BuildSlotMachine();

    }

    private void BuildSlotMachine()

    {

        // Build the slot machine by setting up the reels and faces

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

        {

            // Create a GameObject for each reel

            GameObject reelObj = new GameObject("Reel" + (i + 1));

            reelObj.transform.SetParent(transform);

            // Set the initial position of the reel

            Vector3 initialPosition = new Vector3(i * reelSpacing, 0, 0); // Adjust this as needed

            reelObj.transform.localPosition = initialPosition;

            // Set the reel sprite

            SpriteRenderer reelRenderer = reelObj.AddComponent<SpriteRenderer>();

            reelRenderer.sprite = reels[i].sprite;

            reelRenderer.sortingLayerName = "Default"; // Adjust as needed

            reelRenderer.sortingOrder = i * 100; // Ensure a high order to avoid overlap with faces

            // Add a SpriteMask to hide faces outside the reel bounds

            SpriteMask mask = reelObj.AddComponent<SpriteMask>();

            mask.sprite = reels[i].sprite;

            mask.isCustomRangeActive = true;

            mask.frontSortingOrder = reelRenderer.sortingOrder;

            mask.backSortingOrder = reelRenderer.sortingOrder - 1;

            // Debug logs

            if (reels[i].sprite != null)

            {

                Debug.Log("Reel Sprite Assigned: " + reels[i].sprite.name);

            }

            else

            {

                Debug.LogError("Reel Sprite is null for Reel" + (i + 1));

            }

            // Calculate the reel height dynamically based on the number of face slots

            float reelHeight = (reels[i].faceSlots - 1) * (faceSpriteSize + spacing);

            // Create and position face objects

            for (int j = 0; j < reels[i].faceSlots; j++)

            {

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

                faceObj.transform.SetParent(reelObj.transform);

                faceObj.transform.localPosition = new Vector3(0, reelHeight / 2 - j * (faceSpriteSize + spacing), 0); // Start at the top of the reel

                // Set the face sprite

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

                faceRenderer.sprite = reels[i].faces[j].sprite;

                faceRenderer.transform.localScale = new Vector3(faceSpriteSize, faceSpriteSize, 1);

                faceRenderer.sortingLayerName = "Default"; // Adjust as needed

                faceRenderer.sortingOrder = i * 100 + j + 1; // Ensure unique order to avoid overlap

                faceRenderer.maskInteraction = SpriteMaskInteraction.VisibleInsideMask; // Ensure faces are visible only inside the mask

                faceRenderer.enabled = true; // Enable rendering initially

            }

        }

    }

    public void StartSpin()

    {

        StartCoroutine(SpinReels());

    }

    private IEnumerator SpinReels()

    {

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

        {

            float spinTime = Random.Range(minSpinTime, maxSpinTime); // Random spin time within the range

            float spinSpeed = baseSpinSpeed * Random.Range(0.8f, 1.2f); // Add some variation to the spin speed

            StartCoroutine(SpinReel(reels[i], i, spinSpeed, spinTime));

            yield return new WaitForSeconds(0.5f);

        }

        yield return new WaitForSeconds(1.0f);

        IdentifyWinningFace();

    }

    private IEnumerator SpinReel(ReelScriptableObject reel, int reelIndex, float spinSpeed, float spinTime)

    {

        float elapsed = 0.0f;

        // Get the reel GameObject

        GameObject reelObj = transform.GetChild(reelIndex).gameObject;

        // Calculate the reel height dynamically

        float reelHeight = (reel.faceSlots - 1) * (faceSpriteSize + spacing);

        while (elapsed < spinTime)

        {

            elapsed += Time.deltaTime;

            // Move face objects down the reel

            for (int j = 0; j < reel.faceSlots; j++)

            {

                Transform faceTransform = reelObj.transform.GetChild(j);

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

                // Move the face sprite down smoothly

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

                faceTransform.localPosition = new Vector3(faceTransform.localPosition.x, newY, faceTransform.localPosition.z);

                // Show the face sprite only when within the reel bounds

                if (faceTransform.localPosition.y <= reelHeight / 2 && faceTransform.localPosition.y >= -reelHeight / 2)

                {

                    faceRenderer.enabled = true;

                }

                else

                {

                    faceRenderer.enabled = false;

                }

                // Wrap around to the top if the face moves out of view

                if (faceTransform.localPosition.y < -reelHeight / 2)

                {

                    faceTransform.localPosition = new Vector3(faceTransform.localPosition.x, reelHeight / 2, faceTransform.localPosition.z);

                }

            }

            yield return null;

        }

        // Stop the spin and identify the winning face

        int winningIndex = Random.Range(0, reel.faceSlots);

        GameObject winningFaceObj = reelObj.transform.GetChild(winningIndex).gameObject;

        // Snap the winning face to the center of the reel

        float centerY = 0;

        winningFaceObj.transform.localPosition = new Vector3(winningFaceObj.transform.localPosition.x, centerY, winningFaceObj.transform.localPosition.z);

        // Ensure the winning face is on top

        SpriteRenderer winningFaceRenderer = winningFaceObj.GetComponent<SpriteRenderer>();

        winningFaceRenderer.sortingOrder = reelIndex * 100 + reel.faceSlots + 1; // Set a high order to be on top

        // Reposition other faces to avoid overlapping

        for (int j = 0; j < reel.faceSlots; j++)

        {

            if (j != winningIndex)

            {

                Transform faceTransform = reelObj.transform.GetChild(j);

                float offset = (j - winningIndex) * (faceSpriteSize + spacing);

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

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

                faceRenderer.sortingOrder = reelIndex * 100 + j + 1; // Ensure unique order to avoid overlap

            }

        }

        Debug.Log("Winning Face: " + reel.faces[winningIndex].itemName);

    }

    private void IdentifyWinningFace()

    {

        Debug.Log("Identifying the winning face...");

    }

}