using UnityEngine;
using Pooling;

namespace Minigames.DivingForPictures
{
    /// <summary>
    /// Represents a single bubble, handling its movement, wobble effect, scaling, and sprite assignment.
    /// </summary>
    public class Bubble : MonoBehaviour, IPoolableWithReference<BubblePool>
    {
        public float speed = 1f;
        public float wobbleSpeed = 1f;
        private SpriteRenderer spriteRenderer;
        private SpriteRenderer bubbleSpriteRenderer; // Renamed from bottleSpriteRenderer
        private float timeOffset;
        private float minScale = 0.2f;
        private float maxScale = 1.2f;
        private float baseScale = 1f; // Added to store the initial scale

        private Camera mainCamera; // Cache camera reference
        private BubblePool parentPool; // Reference to the pool this bubble came from

        void Awake()
        {
            // Cache references and randomize time offset for wobble
            spriteRenderer = GetComponent<SpriteRenderer>();
            timeOffset = Random.value * 100f;
            // Find the child named "BubbleSprite" and get its SpriteRenderer
            Transform bubbleSpriteTransform = transform.Find("BubbleSprite");
            if (bubbleSpriteTransform != null)
            {
                bubbleSpriteRenderer = bubbleSpriteTransform.GetComponent<SpriteRenderer>();
            }
            
            // Cache camera reference
            mainCamera = Camera.main;
        }

        void Update()
        {
            // Move bubble upward
            transform.position += Vector3.up * (speed * Time.deltaTime);
            
            // Wobble effect (smooth oscillation between min and max scale)
            float t = (Mathf.Sin((Time.time + timeOffset) * wobbleSpeed) + 1f) * 0.5f; // t in [0,1]
            float wobbleFactor = Mathf.Lerp(minScale, maxScale, t);
            transform.localScale = Vector3.one * (baseScale * wobbleFactor);
            
            // Destroy when off screen - using cached camera reference
            if (mainCamera != null && transform.position.y > mainCamera.orthographicSize + 2f)
            {
                OnBubbleDestroy();
            }
        }

        /// <summary>
        /// Called when bubble is about to be destroyed
        /// </summary>
        private void OnBubbleDestroy()
        {
            // Use the cached pool reference instead of finding it each time
            if (parentPool != null)
            {
                parentPool.ReturnBubble(this);
            }
            else
            {
                // Fallback to find the pool if the reference is somehow lost
                BubblePool pool = FindFirstObjectByType<BubblePool>();
                if (pool != null)
                {
                    Debug.LogWarning("Bubble is missing its parent pool reference, finding pool as fallback");
                    pool.ReturnBubble(this);
                }
                else
                {
                    Destroy(gameObject);
                }
            }
        }

        /// <summary>
        /// Sets the parent pool for this bubble
        /// </summary>
        /// <param name="pool">The bubble pool that created this bubble</param>
        public void SetPool(BubblePool pool)
        {
            parentPool = pool;
        }

        /// <summary>
        /// Called when the object is retrieved from the pool.
        /// </summary>
        public void OnSpawn()
        {
            ResetState();
        }

        /// <summary>
        /// Called when the object is returned to the pool.
        /// </summary>
        public void OnDespawn()
        {
            // Nothing to do here for now, but we could clean up resources
        }

        /// <summary>
        /// Sets the main sprite for the bubble.
        /// </summary>
        /// <param name="sprite">Sprite to assign.</param>
        public void SetSprite(Sprite sprite)
        {
            if (spriteRenderer != null)
                spriteRenderer.sprite = sprite;
        }

        /// <summary>
        /// Sets the sprite for the child "BubbleSprite" renderer.
        /// </summary>
        /// <param name="sprite">Sprite to assign.</param>
        public void SetBubbleSprite(Sprite sprite)
        {
            if (bubbleSpriteRenderer != null)
                bubbleSpriteRenderer.sprite = sprite;
        }

        /// <summary>
        /// Sets the base scale for the bubble
        /// </summary>
        /// <param name="scale">Base scale value</param>
        public void SetBaseScale(float scale)
        {
            baseScale = scale;
        }

        /// <summary>
        /// Sets the minimum and maximum scale for the wobble effect.
        /// </summary>
        /// <param name="min">Minimum scale.</param>
        /// <param name="max">Maximum scale.</param>
        public void SetWobbleScaleLimits(float min, float max)
        {
            minScale = min;
            maxScale = max;
        }
        
        /// <summary>
        /// Resets the bubble state for reuse from object pool
        /// </summary>
        public void ResetState()
        {
            timeOffset = Random.value * 100f;
        }
    }
}