ChessBuilder/Systems/Game/Shop/ShopScreen.gd

extends Control
class_name ShopScreen

signal back_pressed
signal card_purchased(card, price)

# Node references
@onready var card_carousel = $MainContainer/CardCarouselContainer/CardCarousel
@onready var gold_label = $TopBar/GoldContainer/GoldLabel
@onready var buy_button = $BuyButton
@onready var back_button = $BackButton
@onready var card_preview = $CardPreviewPanel
@onready var left_button = $MainContainer/CardCarouselContainer/LeftButton
@onready var right_button = $MainContainer/CardCarouselContainer/RightButton

# Shop data
var available_cards = []  # Cards available in the shop
var player_gold = 1000    
var selected_card = null  
var selected_index = 0    
var is_escape = false     # Is this shop an escape option 
var carousel_page = 0    
var cards_per_page = 3   
var card_instance_map = {}
var hovering_card_index = -1
var mouse_over_any_card = false
# Card prices by rank
var card_prices = Utils.CardPrices

func _ready():
    if back_button:
        if back_button.is_connected("pressed", Callable(self, "_on_back_button_pressed")):
            back_button.disconnect("pressed", Callable(self, "_on_back_button_pressed"))
        back_button.connect("pressed", Callable(self, "_on_back_button_pressed"))
    
    if buy_button:
        if buy_button.is_connected("pressed", Callable(self, "_on_buy_button_pressed")):
            buy_button.disconnect("pressed", Callable(self, "_on_buy_button_pressed"))
        buy_button.connect("pressed", Callable(self, "_on_buy_button_pressed"))
    
    # Use direct connection for navigation buttons
    # This doesnt work for some reason use input below
    if left_button:
        if left_button.is_connected("pressed", Callable(self, "_on_left_button_pressed")):
            left_button.disconnect("pressed", Callable(self, "_on_left_button_pressed"))
        left_button.pressed.connect(_on_left_button_pressed)
    
    if right_button:
        if right_button.is_connected("pressed", Callable(self, "_on_right_button_pressed")):
            right_button.disconnect("pressed", Callable(self, "_on_right_button_pressed"))
        right_button.pressed.connect(_on_right_button_pressed)
    
    # Initialize with empty shop
    if card_preview:
        card_preview.visible = false
    
    update_gold_display()
    update_buy_button()
    update_navigation_buttons()

func initialize(options = null):
    carousel_page = 0
    selected_index = 0
    
    # Process options if provided
    if options:
        if options.has("gold") and options.gold is int:
            player_gold = options.gold
        else:
            var board = get_node_or_null("/root/Board") as ChessGame
            player_gold = board.player.get_gold()
        if options.has("cards") and options.cards is Array:
            available_cards = options.cards.duplicate()
        if options.has("is_escape") and options.is_escape is bool:
            is_escape = options.is_escape
            # Apply escape markup (higher prices)
            if is_escape:
                for rank in card_prices:
                    card_prices[rank] = int(card_prices[rank] * 1.5)
     
    # if available_cards.is_empty():
    #     var board = get_node_or_null("/root/Board") as ChessGame
    #     if board and "deckManager" in board:
    #         var deck_manager = board.deckManager
    #         available_cards = generate_shop_cards(deck_manager)
    
    # Update display
    update_gold_display()
    populate_carousel()
    update_navigation_buttons()
    
    if not available_cards.is_empty():
        select_card(0)  # Select the first card by default

func generate_shop_cards(deck_manager):
    var shop_cards = []
    
    var all_cards = []
    var card_classes = [
        HopscotchCard,
        FieryCapeCard,
        FieryTrailCard,
        ExplosiveBootsCard,
        DoubleTimeCard,
        DrunkDrivingCard,
        SupernovaCard
    ]
    
    for card_class in card_classes:
        var card = card_class.new()
        all_cards.append(card)
    
    all_cards.shuffle()
    
    var num_shop_cards = min(randi_range(5, 7), all_cards.size())
    
    for i in range(num_shop_cards):
        shop_cards.append(all_cards[i % card_classes.size()])
    
    return shop_cards

func populate_carousel():
    if card_carousel:
        for child in card_carousel.get_children():
            child.queue_free()
    
    card_instance_map.clear()
    
    var start_index = carousel_page * cards_per_page
    var end_index = min(start_index + cards_per_page, available_cards.size())
    
    card_carousel.add_theme_constant_override("separation", 20)
    
    for i in range(start_index, end_index):
        var card = available_cards[i]
        var card_visual = preload("res://card_visual.tscn").instantiate()
        
        card_carousel.add_child(card_visual)
        card_visual.set_card(card)
        
        var price = get_card_price(card)
        card_visual.set_price(price)
        
        var instance_id = card_visual.get_instance_id()
        
        card_instance_map[instance_id] = {
            "card_index": i,
            "card": card
        }

    update_navigation_buttons()


func update_navigation_buttons():
    if left_button:
        left_button.disabled = (carousel_page <= 0)
    
    if right_button:
        var max_page = ceil(float(available_cards.size()) / cards_per_page) - 1
        right_button.disabled = (carousel_page >= max_page or available_cards.size() <= cards_per_page)
    

func select_card(index):
    if index < 0 or index >= available_cards.size():
        return
    
    var page_for_index = int(index / cards_per_page)
    if page_for_index != carousel_page:
        carousel_page = page_for_index
        populate_carousel()
    
    selected_index = index
    selected_card = available_cards[index]
    
    var visual_index = index % cards_per_page
    
    for i in range(card_carousel.get_child_count()):
        var card_visual = card_carousel.get_child(i)
        card_visual.set_selected(i == visual_index)
    
    if card_preview and selected_card:
        card_preview.preview_card(selected_card)
        card_preview.visible = true
    
    update_buy_button()

func update_buy_button():
    if not buy_button or not selected_card:
        return
    
    var price = get_card_price(selected_card)
    buy_button.text = "BUY (" + str(price) + " gold)"

    buy_button.disabled = price > player_gold

func get_card_price(card):
    if not card:
        return 0
    if card.rank in card_prices:
        return card_prices[card.rank]
    return 50

func update_gold_display():
    if gold_label:
        gold_label.text = str(player_gold) + " GOLD"

func purchase_selected_card():
    if not selected_card:
        return false
    
    var price = get_card_price(selected_card)
    
    if player_gold < price:
        # Show not enough gold message
        print("Not enough gold")
        return false
    
    player_gold -= price
    var purchased_card = selected_card.duplicate()
    var old_page = carousel_page
    available_cards.remove_at(selected_index)
    emit_signal("card_purchased", purchased_card, price)
    
    update_gold_display()
    
    var max_page = max(0, ceil(float(available_cards.size()) / cards_per_page) - 1)
    
    if carousel_page > max_page:
        carousel_page = max_page

    populate_carousel()
    
    if not available_cards.is_empty():
        var new_index = min(selected_index, available_cards.size() - 1)
        select_card(new_index)
    else:
        selected_card = null
        selected_index = -1
        if card_preview:
            card_preview.hide_preview()
        
        buy_button.disabled = true
    
    update_buy_button()
    return true

# Signal handlers
func _on_back_button_pressed():
    emit_signal("back_pressed")
    visible = false

func _on_buy_button_pressed():
    purchase_selected_card()

func _input(event):
    if event is InputEventMouseButton and event.pressed and event.button_index == MOUSE_BUTTON_LEFT:
        # Check if click is within buttons
        if left_button and left_button.get_global_rect().has_point(event.position) and not left_button.disabled:
            # print("Left button clicked via _input")
            _on_left_button_pressed()
            get_viewport().set_input_as_handled()
        elif right_button and right_button.get_global_rect().has_point(event.position) and not right_button.disabled:
            # print("Right button clicked via _input")
            _on_right_button_pressed()
            get_viewport().set_input_as_handled()


func _on_left_button_pressed():
    if carousel_page > 0:
        carousel_page -= 1
        var new_index = carousel_page * cards_per_page
        populate_carousel()
        select_card(new_index)
        

func _on_right_button_pressed():
    var max_page = ceil(float(available_cards.size()) / cards_per_page) - 1
    if carousel_page < max_page:
        carousel_page += 1
        var new_index = carousel_page * cards_per_page
        populate_carousel()
        select_card(new_index)


func _on_card_visual_pressed(index):
    select_card(index)

func _on_card_visual_hover(card, index):
    if card_preview and card:
        card_preview.preview_card(card)
        card_preview.visible = true
    select_card(index)

func _on_card_visual_exit():
    
    if card_preview and selected_card:
        card_preview.preview_card(selected_card)
    elif card_preview:
        card_preview.hide_preview()

func _process(delta):
    if not visible:
        return
        
    var mouse_pos = get_viewport().get_mouse_position()
    
    # Reset tracking
    var old_hovering_index = hovering_card_index
    hovering_card_index = -1
    mouse_over_any_card = false
    var mouse_clicked = Input.is_mouse_button_pressed(MOUSE_BUTTON_LEFT)
    
    for i in range(card_carousel.get_child_count()):
        var card_visual = card_carousel.get_child(i)
        var card_rect = card_visual.get_global_rect()
        
        if card_rect.has_point(mouse_pos) and mouse_clicked:
            # Get data from instance map
            var instance_id = card_visual.get_instance_id()
            if card_instance_map.has(instance_id):
                var data = card_instance_map[instance_id]
                hovering_card_index = data.card_index
                mouse_over_any_card = true
                
                # If we just started hovering this card
                if old_hovering_index != hovering_card_index:
                    _on_card_visual_hover(data.card, data.card_index)
                    
                    # Also trigger the card's own hover effect
                    card_visual._on_mouse_entered()
                
                break
    
    # If we were hovering a card before but not now, trigger exit
    if old_hovering_index != -1 and hovering_card_index == -1:
        _on_card_visual_exit()
        
        # Find the previously hovered card by index
        for i in range(card_carousel.get_child_count()):
            var card_visual = card_carousel.get_child(i)
            var instance_id = card_visual.get_instance_id()
            if card_instance_map.has(instance_id) and card_instance_map[instance_id].card_index == old_hovering_index:
                card_visual._on_mouse_exited()
                break