ChessBuilder/Systems/DeckManager.gd

extends Node
class_name DeckManager

var deck: Array = []
var hand: Array = []
var discard: Array = []
var attached_cards: Dictionary = {}  # piece_id: card
var attached_effects: Dictionary = {} # piece_id: [card]
var hand_size: int = 5

# Card costs for shop
const CARD_BASE_COSTS = {
    Card.Rank.RANK_0: 100,
    Card.Rank.RANK_1: 75,
    Card.Rank.RANK_2: 50,
    Card.Rank.RANK_3: 25
}

func _init():
    initializeStartingDeck()

func initializeStartingDeck():
    deck.clear();
    # for i in range(2):
    # 	deck.append(DoubleTimeCard.new()) 
    deck.append(HopscotchCard.new()) 
    deck.append(FieryCapeCard.new()) 
    deck.append(FieryTrailCard.new()) 
    deck.append(ExplosiveBootsCard.new()) 
    deck.append(DoubleTimeCard.new()) 
    deck.append(DrunkDrivingCard.new()) 
    deck.append(SupernovaCard.new()) 
    shuffleDeck()
    drawStartingHand()

func shuffleDeck():
    deck.shuffle()

func drawStartingHand():
    for i in range(min(hand_size, deck.size())):
        drawCard()

func drawCard():
    if deck.is_empty() && !discard.is_empty():
        deck = discard.duplicate()
        discard.clear()
        shuffleDeck()
    
    if !deck.is_empty() && hand.size() < hand_size:
        hand.append(deck.pop_back())
    
    emit_signal("hand_updated", hand)
        

signal hand_updated



func playCard(card: Card, target_piece: Pawn, board_flow = null, game_state = null, avoidHand = false):
    if !avoidHand and !hand.has(card):
        # print("Failed Play Card 1")
        return false
    if card.duration > 0:
        attached_cards[target_piece.get_instance_id()] = card
        
    if card.apply_effect(target_piece, board_flow, game_state):
        if card.duration > 0:
            attached_cards[target_piece.get_instance_id()] = card
        hand.erase(card)
        emit_signal("hand_updated", hand)
                
            
        return true
    # print("Failed Play Card 2")
    return false


func playEffect(card: Card, target_piece: Pawn, board_flow = null, game_state = null):

    var key = target_piece.get_instance_id();
    if !attached_effects.has(key):
        attached_effects[key] = []
    else:
        for existing_card in attached_effects[key]:
            if existing_card.cardName == card.cardName:
                # Card already exists, don't add it again
                return false
        
    if card.apply_effect(target_piece, board_flow, game_state):
        if card.duration > 0:
            attached_effects[key].append(card)
                
            
        return true
    # print("Failed Play Card 2")
    return false

func updateEffectDurations():
    var expired_entries = []  # Store [piece_id, card_id] pairs to remove

    for piece_id in attached_effects:
        var cards_to_remove = []  # Track which cards to remove from this piece's array
        
        for card in attached_effects[piece_id]:
            card.update_duration()
            if card.remaining_turns <= 0:
                cards_to_remove.append(card)
            else:
                var piece_node = instance_from_id(piece_id)
                if is_instance_valid(piece_node):
                    piece_node.update_appearance()
        
        # Remove expired cards from this piece's array
        for card in cards_to_remove:
            attached_effects[piece_id].erase(card)
        
        # If no cards left for this piece, mark the piece_id for removal
        if attached_effects[piece_id].is_empty():
            expired_entries.append(piece_id)
            var piece_node = instance_from_id(piece_id)
            if is_instance_valid(piece_node):
                piece_node.update_appearance()

    # Remove empty entries
    for piece_id in expired_entries:
        attached_effects.erase(piece_id)

func updateCardDurations():
    var expired_cards = []
    for piece_id in attached_cards:
        var card = attached_cards[piece_id]
        card.update_duration()
        # print("Card: ", card.id, " | ", card.cardName, " | ", card.remaining_turns)
        if card.remaining_turns <= 0:
            expired_cards.append(piece_id)

        
            match card.rank:
                Card.Rank.RANK_0:
                    print("Rank 3 Burned permanently")
                    pass
                Card.Rank.RANK_1:
                    print("Rank 3 Burned until next match")
                    pass
                Card.Rank.RANK_2:
                    print("Rank 2 add to Discard")
                    discard.append(card)
                    pass
                Card.Rank.RANK_3:
                    deck.append(card)
                    print("Rank 3 add to Deck")
                    pass
        else:
            var piece_node = instance_from_id(piece_id)
            if is_instance_valid(piece_node):
                piece_node.update_appearance()
    for piece_id in expired_cards:
        attached_cards.erase(piece_id)
        var piece_node = instance_from_id(piece_id)
        if is_instance_valid(piece_node):
            piece_node.update_appearance()
        
    # print("updateCardDurations", attached_cards)

# Shop functionality
func getShopCards(num_cards: int = 3) -> Array:
    var shop_cards = []
    # Generate random shop selection
    #for i in range(num_cards):
        #var card = generate_random_card()
        #shop_cards.append({
            #"card": card,
            #"cost": calculateCardCost(card)
        #})
    return shop_cards

func calculateCardCost(card: Card) -> int:
    var base_cost = CARD_BASE_COSTS[card.rank]
    # Add modifiers based on card effects
    return base_cost

func upgradeCard(card: Card) -> bool:
    # Implement card upgrading logic
    return false