extends Control
class_name RewardScreen

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 select_button = $SelectButton
@onready var back_button = $BackButton
@onready var card_preview = $CardPreviewPanel
@onready var left_button = $MainContainer/CardCarouselContainer/LeftButton
@onready var right_button = $MainContainer/CardCarouselContainer/RightButton
@onready var screen_title = $TopBar/TitleLabel

# reward 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 reward event an escape option 
var carousel_page = 0    
var cards_per_page = 3   
var card_selection_counter = 0
var card_selection_limit = 1   
var card_instance_map = {}
var hovering_card_index = -1
var mouse_over_any_card = false
var deckManager: DeckManager


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 select_button:
        if select_button.is_connected("pressed", Callable(self, "_on_select_button_pressed")):
            select_button.disconnect("pressed", Callable(self, "_on_select_button_pressed"))
        select_button.connect("pressed", Callable(self, "_on_select_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_select_button()
    update_navigation_buttons()

func initialize(options = null):
    print("RewardScreen ", options)
    carousel_page = 0
    selected_index = 0
    var board = get_node_or_null("/root/Board") as ChessGame
    if board and "deckManager" in board:
        deckManager = board.deckManager
    
    # Process options if provided
    if options:
        if options.has("gold") and options.gold is int:
            player_gold = options.gold
        if options.has("reward") and options.reward.has("selection") and options.reward.selection is Array:
            available_cards = options.reward.selection.duplicate()
        else:
            available_cards = []
        if options.has("is_escape") and options.is_escape is bool:
            is_escape = options.is_escape
        if options.has("reward") and options.reward.has("gold") and options.reward.gold is int:
            board.player.add_gold(options.reward.gold)
            player_gold = board.player.get_gold()
    
        if options.has("reward") and options.reward.has("selection_limit") and options.reward.selection_limit is int:
            card_selection_limit = options.reward.selection_limit
            screen_title.text = "Select Reward (" + str(options.reward.selection_limit) + ")"
            select_button.visible = true
            select_button.disabled = false
        else:
            screen_title.text = "Reward :" + str(options.reward.gold) + " gold"
            select_button.visible = false
    card_selection_counter = 0

    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()
        
    player_gold = board.player.get_gold()
    # Update display
    update_gold_display()
    populate_carousel()
    update_navigation_buttons()
    
    if not available_cards.is_empty():
        select_card(0)
 

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)
        card_visual.hide_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_select_button()

func update_select_button():
    if not select_button or not selected_card:
        return
    
    if card_selection_counter >= card_selection_limit:
        select_button.disabled = true
    

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

func get_selected_card():
    if not selected_card:
        return false
    
    var purchased_card = selected_card.duplicate()
    var old_page = carousel_page
    available_cards.remove_at(selected_index)
    emit_signal("card_purchased", purchased_card, 0)
    card_selection_counter += 1
    
    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()
        
        select_button.disabled = true
    
    update_select_button()
    return true

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

func _on_select_button_pressed():
    get_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 old_hovering_index != hovering_card_index:
                    _on_card_visual_hover(data.card, data.card_index)
                    
                    card_visual._on_mouse_entered()
                
                break
                
    if old_hovering_index != -1 and hovering_card_index == -1:
        _on_card_visual_exit() 
        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