ChessBuilder/Systems/Game/DeckManagerScreen.gd

extends Control
class_name DeckManagerScreen

signal back_pressed
signal deck_manager_visibility_changed(isvisible)

# Node references
@onready var deckGrid = $MainContainer/GridScrollContainer/GridContainer
@onready var bankContainer = $MainContainer/BankContainer/ScrollContainer/VBoxContainer
@onready var backButton = $BackButton
@onready var card_preview = $CardPreviewPanel

# Default deck size (can be overridden via options)
var maxDeckSize = 40
var deckManager = null
var bankCards = []  # Cards available but not in deck

# The current deck
var currentDeck = []
var current_preview_card = null

func _ready():
    # Connect back button
    if backButton:
        backButton.connect("pressed", Callable(self, "_on_backButton_pressed"))
    
    if card_preview:
        card_preview.visible = false


func initialize(options = null):
    # Process options if provided
    if options:
        if options.has("max_deck_size") and options.max_deck_size is int:
            maxDeckSize = options.max_deck_size
    

    # Find the DeckManager instance
    var board = get_node_or_null("/root/Board") as ChessGame
    if board and "deckManager" in board:
        deckManager = board.deckManager
        print("Found deck manager:", deckManager)
        # if(!deckManager.deck):
        #     deckManager.initializeStartingDeck()
    else:
        print("DeckManager not found on Board node")
    print("DECK MANAGER")
    
    # Load cards from deck and bank
    loadCards()
    
    # Set up the grid with empty card containers
    setupDeckGrid()
    
    # Populate the bank with available cards
    populateBank()

func loadCards():
    var board = get_node_or_null("/root/Board") as ChessGame
    if board and "deckManager" in board:
        deckManager = board.deckManager
        print("Found deck manager:", deckManager)
    if deckManager:
        # Clone the deck to work with
        currentDeck = deckManager.deck.duplicate()
        bankCards = deckManager.bank.duplicate()
    else:
        # Fallback with empty collections if deck manager not found
        currentDeck = []
        bankCards = []
        print("Warning: DeckManager not found")
  

func setupDeckGrid():
    # Clear existing children
    for child in deckGrid.get_children():
        child.queue_free()
    
    # Calculate grid dimensions
    var cols = 4 #check screen to deteremine
    var rows = maxDeckSize / cols 
    deckGrid.columns = cols
    
    # Create card slots
    for i in range(maxDeckSize):
        var card_slot = preload("res://card_slot.tscn").instantiate()
        deckGrid.add_child(card_slot)
        
        # Connect signals
        card_slot.connect("card_selected", Callable(self, "_on_deck_card_selected"))
        _connect_hover_signals(card_slot)
        
        # Set card if available
        if i < currentDeck.size():
            card_slot.set_card(currentDeck[i])
        else:
            card_slot.clear()

func _connect_hover_signals(node):
    # Add hover signals for preview functionality
    if node.is_class("Control"):
        node.mouse_entered.connect(Callable(self, "_on_card_mouse_entered").bind(node))
        # node.mouse_exited.connect(Callable(self, "_on_card_mouse_exited").bind(node))


func populateBank():
    # Clear existing children
    for child in bankContainer.get_children():
        child.queue_free()
    
    # Add each bank card to the list
    for card in bankCards:
        var card_item = preload("res://card_bank_item.tscn").instantiate()
        bankContainer.add_child(card_item)
        card_item.set_card(card)
        card_item.connect("card_selected", Callable(self, "_on_bank_card_selected"))
        _connect_hover_signals(card_item)

func _on_deck_card_selected(card_slot, card):
    if card:
        # Remove card from deck
        var index = currentDeck.find(card)
        if index >= 0:
            currentDeck.remove_at(index)
        
        # Add to bank
        bankCards.append(card)
        
        # Update UI
        card_slot.clear()
        populateBank()
        if current_preview_card == card:
            hide_card_preview()

func _on_bank_card_selected(card_item, card):
    print("_on_bank_card_selected")
    # Find first empty slot in deck
    var empty_slot_index = -1
    for i in range(deckGrid.get_child_count()):
        var slot = deckGrid.get_child(i)
        if !slot.has_card():
            empty_slot_index = i
            break
    
    if empty_slot_index >= 0 and currentDeck.size() < maxDeckSize:
        # Remove from bank
        var bank_index = bankCards.find(card)
        if bank_index >= 0:
            bankCards.remove_at(bank_index)
        
        # Add to deck
        currentDeck.append(card)
        
        # Update UI
        deckGrid.get_child(empty_slot_index).set_card(card)
        populateBank()

func _on_card_mouse_entered(node):
    var card = null
    
    # Get the card from the node
    if node.has_method("has_card") and node.has_card():
        # This is a CardSlot
        card = node.current_card
    elif node.has_method("set_card") and node.current_card:
        # This is a CardBankItem
        card = node.current_card
    
    if card:
        show_card_preview(card)

# func _on_card_mouse_exited(node):
#     # Add a short delay before hiding the preview
#     # This prevents flickering when moving between cards
#     await get_tree().create_timer(0.1).timeout
    
#     # Only hide if we're not hovering over another card that shows the same preview
#     if current_preview_card:
#         hide_card_preview()

func show_card_preview(card):
    if card_preview and card:
        current_preview_card = card
        card_preview.preview_card(card)

func hide_card_preview():
    if card_preview:
        current_preview_card = null
        card_preview.hide_preview()

func saveDeck():
    if deckManager:
        # Save the current deck to the deck manager
        deckManager.deck = currentDeck.duplicate()
        deckManager.bank = bankCards.duplicate()
        
        print("Deck saved with ", currentDeck.size(), " cards")

func _on_backButton_pressed():
    # Save changes before returning
    saveDeck()
    
    # Emit signal to go back
    emit_signal("back_pressed")
    
    # Hide this screen
    visible = false




# Notification
func _notification(what):
    if what == NOTIFICATION_VISIBILITY_CHANGED:
        _on_visibility_changed(visible)

func _on_visibility_changed(is_visible):
    
    print("DeckManager visibility changed to: ", is_visible)
    if is_visible:
        loadCards()
        setupDeckGrid()
    else:
        print("DeckManager is now invisible")
        
    emit_signal("deck_manager_visibility_changed", is_visible)