AppleHillsProduction/Assets/Scripts/UI/CardSystem/DragDrop/AlbumCardSlot.cs

using AppleHills.Data.CardSystem;
using Data.CardSystem;
using UI.DragAndDrop.Core;
using UnityEngine;

namespace UI.CardSystem
{
    /// <summary>
    /// Specialized slot for album pages that only accepts a specific card.
    /// Validates cards based on their CardDefinition.
    /// Self-populates with owned cards when enabled.
    /// </summary>
    public class AlbumCardSlot : DraggableSlot
    {
        [Header("Album Slot Configuration")]
        [SerializeField] private CardDefinition targetCardDefinition; // Which card this slot accepts
        [SerializeField] private GameObject albumCardPrefab; // Prefab to spawn when card is owned
        
        private bool _isOccupiedPermanently = false;
        private AlbumCard _placedCard;
        
        /// <summary>
        /// Set the target card this slot should accept
        /// </summary>
        public void SetTargetCard(CardDefinition definition)
        {
            targetCardDefinition = definition;
        }
        
        /// <summary>
        /// Check if this slot can accept a specific card
        /// </summary>
        public bool CanAcceptCard(CardData cardData)
        {
            if (cardData == null || targetCardDefinition == null) return false;
            if (_isOccupiedPermanently) return false;
            
            // Card must match this slot's target definition
            return cardData.DefinitionId == targetCardDefinition.Id;
        }
        
        /// <summary>
        /// Called when a card is successfully placed in this slot
        /// </summary>
        public void OnCardPlaced(AlbumCard albumCard = null)
        {
            _isOccupiedPermanently = true;
            
            if (albumCard != null)
            {
                _placedCard = albumCard;
                albumCard.SetParentSlot(this);
                
                // Register with AlbumViewPage for enlarge/shrink handling
                AlbumViewPage albumPage = FindObjectOfType<AlbumViewPage>();
                if (albumPage != null)
                {
                    albumPage.RegisterAlbumCard(albumCard);
                }
            }
        }
        
        /// <summary>
        /// Check if this slot has a placed card
        /// </summary>
        public bool HasPlacedCard()
        {
            return _placedCard != null;
        }
        
        /// <summary>
        /// Get the placed card (if any)
        /// </summary>
        public AlbumCard GetPlacedCard()
        {
            return _placedCard;
        }
        
        private void OnEnable()
        {
            // Check if we should spawn a card for this slot
            CheckAndSpawnOwnedCard();
        }
        
        /// <summary>
        /// Check if player owns the card for this slot and spawn it if so
        /// </summary>
        private void CheckAndSpawnOwnedCard()
        {
            // Guard: need CardSystemManager and target definition
            if (CardSystemManager.Instance == null || targetCardDefinition == null)
                return;
            
            // Guard: don't spawn if already occupied
            if (_isOccupiedPermanently || _placedCard != null)
                return;
            
            // Guard: need prefab to spawn
            if (albumCardPrefab == null)
            {
                Debug.LogWarning($"[AlbumCardSlot] No albumCardPrefab assigned for slot targeting {targetCardDefinition.name}");
                return;
            }
            
            // Check if player owns this card at ANY rarity (prioritize highest rarity)
            CardData ownedCard = null;
            
            // Check in order: Legendary > Rare > Normal
            foreach (CardRarity rarity in new[] { CardRarity.Legendary, CardRarity.Rare, CardRarity.Normal })
            {
                CardData card = CardSystemManager.Instance.GetCardInventory().GetCard(targetCardDefinition.Id, rarity);
                if (card != null)
                {
                    ownedCard = card;
                    break; // Found highest rarity owned
                }
            }
            
            // Spawn card if owned
            if (ownedCard != null)
            {
                SpawnAlbumCard(ownedCard);
            }
        }
        
        /// <summary>
        /// Spawn an AlbumCard in this slot
        /// </summary>
        private void SpawnAlbumCard(CardData cardData)
        {
            GameObject cardObj = Instantiate(albumCardPrefab, transform);
            AlbumCard albumCard = cardObj.GetComponent<AlbumCard>();
            
            if (albumCard != null)
            {
                albumCard.SetupCard(cardData);
                albumCard.SetParentSlot(this);
                _placedCard = albumCard;
                _isOccupiedPermanently = true;
                
                // Register with AlbumViewPage for enlarge/shrink handling
                AlbumViewPage albumPage = FindObjectOfType<AlbumViewPage>();
                if (albumPage != null)
                {
                    albumPage.RegisterAlbumCard(albumCard);
                }
                
                Debug.Log($"[AlbumCardSlot] Spawned owned card '{cardData.Name}' ({cardData.Rarity}) in slot");
            }
            else
            {
                Debug.LogWarning($"[AlbumCardSlot] Spawned prefab has no AlbumCard component!");
                Destroy(cardObj);
            }
        }
        
        /// <summary>
        /// Get the target card definition for this slot
        /// </summary>
        public CardDefinition TargetCardDefinition => targetCardDefinition;
    }
}