extends Control
class_name MenuContainer
 
const VERSION_FILE_PATH = "res://Game.json"
# Signal to notify parent when a new game is requested
# signal new_game_requested
signal reward_closed(node)
signal new_game_requested(options)
signal shop_open_requested(options)
signal reward_open_requested(options)
signal deckmanager_open_requested(options)
signal map_open_requested(options)
signal node_completed(options)
signal shop_closed
signal card_purchased(card, price)
signal lobby_open_requested(options)
signal lobby_shop_open_requested(options)
signal vanilla_mode_selected
signal deeper_mode_selected
@onready var newGameButton = $HBoxContainer/VBoxContainer/MenuOptions/NewGameText
@onready var continueButton = $HBoxContainer/VBoxContainer/MenuOptions/Continue  
@onready var optionsButton = $HBoxContainer/VBoxContainer/MenuOptions/Options
@onready var versionText = $HBoxContainer/VBoxContainer/VersionText 
@onready var titleText = $HBoxContainer/VBoxContainer/TitleText 
@onready var developerText = $HBoxContainer/VBoxContainer/DeveloperText
@onready var gameMenuScreen = get_node("/root/Board/GameMenuScreen") 
@onready var deckManagerScreen = get_node("/root/Board/DeckManagerScreen")
@onready var mapScreen = get_node("/root/Board/MapScreen")
@onready var stateMachine = get_node("/root/Board/StateMachine") 
@onready var shopScreen = get_node("/root/Board/ShopScreen") 
@onready var progressionScreen = get_node("/root/Board/ProgressionScreen") 
@onready var rewardScreen = get_node("/root/Board/RewardScreen") 
@onready var game = get_node_or_null("/root/Board") as ChessGame
@onready var lobbyScreen = get_node_or_null("/root/Board/LobbyScreen")
@onready var lobbyShopScreen = get_node_or_null("/root/Board/LobbyShopScreen")



var player_gold = 10
var back_to_map = false
var winConditionManager: WinConditionManager
var currentWinCondition = Utils.WinConditionType.CAPTURE_UNIT
var currentLossCondition = Utils.LossConditionType.UNIT_LOST


func _ready():
    # Connect menu option signals
    _connect_button(newGameButton, "_on_new_game_pressed")
    _connect_button(continueButton, "_on_continue_pressed")
    _connect_button(optionsButton, "_on_options_pressed")
    if gameMenuScreen:
        gameMenuScreen.setup(self)
        gameMenuScreen.connect("shop_open_requested", Callable(self, "_on_shop_open_requested"))
        gameMenuScreen.connect("deckmanager_open_requested", Callable(self, "_on_deckmanager_open_requested"))
        gameMenuScreen.connect("map_open_requested", Callable(self, "_on_map_open_requested"))
        gameMenuScreen.connect("new_game_requested", Callable(self, "_on_start_game_pressed"))
        gameMenuScreen.connect("reward_open_requested", Callable(self, "_on_reward_open_requested")) 
        gameMenuScreen.connect("lobby_open_requested", Callable(self, "_on_lobby_open_requested"))
        gameMenuScreen.visible = false
    else:
        connect("map_open_requested", Callable(self, "_on_map_open_requested"))
    connect("reward_closed", Callable(self, "_on_reward_completed"))
    
    game.connect("node_completed", Callable(self, "_on_node_completed"))
    if deckManagerScreen:
        deckManagerScreen.connect("back_pressed", Callable(self, "_on_deck_manager_back_pressed"))
        deckManagerScreen.visible = false
    
    if progressionScreen:
        progressionScreen.connect("save_pressed", Callable(self, "_on_progression_save_pressed"))
        progressionScreen.visible = false
    if mapScreen:
        mapScreen.connect("back_pressed", Callable(self, "_on_map_back_pressed"))
        mapScreen.connect("deckmanager_open_requested", Callable(self, "_on_deckmanager_open_requested_from_map"))
        mapScreen.connect("node_selected", Callable(self, "_on_map_node_selected"))
        mapScreen.visible = false

    if shopScreen:
        shopScreen.connect("back_pressed", Callable(self, "_on_shop_back_pressed"))
        shopScreen.connect("card_purchased", Callable(self, "_on_shop_card_purchased"))
        shopScreen.visible = false
    if rewardScreen:
        rewardScreen.connect("back_pressed", Callable(self, "_on_reward_back_pressed"))
        rewardScreen.connect("card_purchased", Callable(self, "_on_reward_card"))
        rewardScreen.visible = false
    if lobbyScreen:
        lobbyScreen.connect("vanilla_selected", Callable(self, "_on_vanilla_selected"))
        lobbyScreen.connect("shop_selected", Callable(self, "_on_lobby_shop_open_requested"))
        lobbyScreen.connect("deeper_selected", Callable(self, "_on_deeper_selected"))
        lobbyScreen.connect("back_pressed", Callable(self, "_on_lobby_back_pressed"))
        # lobbyScreen.connect("map_open_requested", Callable(self, "_on_map_open_requested"))
        lobbyScreen.visible = false

    if lobbyShopScreen:
        lobbyShopScreen.connect("back_pressed", Callable(self, "_on_lobby_shop_back_pressed"))
        lobbyShopScreen.connect("card_purchased", Callable(self, "_on_lobby_shop_card_purchased"))
        lobbyShopScreen.connect("hand_size_increased", Callable(self, "_on_hand_size_increased"))
        lobbyShopScreen.visible = false
    load_version()


func load_version():

    var version = "v.0.0.0"
    var title = "ChessBuilder"
    var developer = ""
    var file = FileAccess.open(VERSION_FILE_PATH, FileAccess.READ)
    if file:
        var json_text = file.get_as_text()
        file.close()
        
        # Parse the JSON
        var json = JSON.new()
        var error = json.parse(json_text)
        
        if error == OK:
            var data = json.get_data()
            if data and typeof(data) == TYPE_DICTIONARY and data.has("version"):
                version = "v   " + str(data.version)
            if data and typeof(data) == TYPE_DICTIONARY and data.has("title"):
                title = str(data.title)
            if data and typeof(data) == TYPE_DICTIONARY and data.has("developer"):
                developer = str(data.developer)
        else:
            print("JSON Parse Error: ", json.get_error_message())

    if versionText:
        versionText.text = version
    if titleText:
        titleText.text = title
    if developerText:
        developerText.text = developer
# Connect a button signal to a method
func _connect_button(button, method_name):
    if button and button.has_signal("pressed"):
        if !button.is_connected("pressed", Callable(self, method_name)):
            button.connect("pressed", Callable(self, method_name))

# Handle New Game button press
func _on_new_game_pressed():
    print("New Game pressed, showing game menu")
    self.visible = false
    if gameMenuScreen:
        gameMenuScreen.visible = true
    
    # _on_map_open_requested({})
    # emit_signal("new_game_requested")



func _on_lobby_open_requested(options):
    print("Lobby requested with options:", options)
    if gameMenuScreen:
        gameMenuScreen.visible = false
    if lobbyScreen:
        lobbyScreen.visible = true
        lobbyScreen.initialize(options)
        lobbyScreen.show_screen()
        print("_on_lobby_open_requested" )

func _on_lobby_back_pressed():
    if lobbyScreen:
        lobbyScreen.visible = false
    self.visible = true

func _on_vanilla_selected():
    print("Vanilla mode selected")
    if gameMenuScreen:
        gameMenuScreen.visible = true
    _on_map_open_requested({"mode": "vanilla", "hand_size": 2, })
    # emit_signal("vanilla_mode_selected")

func _on_deeper_selected():
    print("Deeper mode selected")
    if gameMenuScreen:
        gameMenuScreen.visible = true
    _on_map_open_requested({"mode": "deeper", "hand_size": game.player.hand_size,})

func _on_lobby_shop_open_requested(options):
    print("Lobby Shop requested with options:", options)
    if lobbyScreen:
        lobbyScreen.visible = false
    if lobbyShopScreen:
        lobbyShopScreen.visible = true
        lobbyShopScreen.initialize(options)
    emit_signal("lobby_shop_open_requested", options)

func _on_lobby_shop_back_pressed():
    if lobbyShopScreen:
        lobbyShopScreen.visible = false
    if lobbyScreen:
        lobbyScreen.visible = true

func _on_lobby_shop_card_purchased(card, token_cost):
    # Add the card to the player's bank
    if game and "deckManager" in game:
        var deck_manager = game.deckManager
        deck_manager.bank.append(card)
        print("Added purchased card to bank:", card.cardName)

func _on_hand_size_increased():
    print("Hand size increased")


# Handle Continue button press  
func _on_continue_pressed():
    print("Continue pressed")
    # Implement continue game logic here
    # self.visible = false
    # You can add logic to load a saved game if needed

# Handle Options button press
func _on_options_pressed():
    print("Options pressed")
    # Implement options menu logic here
    # You could show an options panel or switch to an options menu

# Game Menu Screen Signals
func _on_shop_open_requested(options):
    print("Shop requested with options:", options)
    if gameMenuScreen:
        gameMenuScreen.visible = false
     
    if options == null:
        options = {} 
    
    if "gold" in options:
        options["gold"] = game.player.get_gold()
    if mapScreen:
        mapScreen.visible = false
    if shopScreen:
        shopScreen.visible = true
        shopScreen.initialize(options)
    emit_signal("shop_open_requested", options)

func _on_shop_back_pressed():
    if shopScreen:
        shopScreen.visible = false
        game.player.set_gold(shopScreen.player_gold)
    
    # Show game menu again
    if not back_to_map and gameMenuScreen:
        gameMenuScreen.visible = true
    if back_to_map:
        mapScreen.visible = true
    # Emit signal that shop was closed
    emit_signal("shop_closed")

func _on_shop_card_purchased(card, price):
    game.player.remove_gold(price)
    # Forward the signal
    emit_signal("card_purchased", card, price)
    
    # Add the card to the player's bank
    if game and "deckManager" in game:
        var deck_manager = game.deckManager
        deck_manager.bank.append(card)
        print("Added purchased card to bank:", card.cardName)



func _on_reward_open_requested(options):
    print("Reward requested with options:", options)
    if shopScreen:
        shopScreen.visible = false
     
    if options == null:
        options = {} 

    
    if "gold" in options.metadata:
        options.metadata["gold"] = game.player.get_gold()
    if rewardScreen:
        rewardScreen.visible = true
        rewardScreen.initialize(options)
    emit_signal("reward_open_requested", options)


func _on_reward_back_pressed(completed_node):
    if rewardScreen:
        rewardScreen.visible = false 

    if not back_to_map and gameMenuScreen:
        gameMenuScreen.visible = true
    if back_to_map:
        mapScreen.visible = true
    print("DONE: ", completed_node)
    var is_escape = completed_node.metadata.is_escape
    emit_signal("reward_closed", completed_node)

func _on_reward_card(card, price):
    # Forward the signal
    emit_signal("card_purchased", card, price)
    
    # Add the card to the player's bank
    if game and "deckManager" in game:
        var deck_manager = game.deckManager
        deck_manager.bank.append(card)
        print("Added reward card to bank:", card.cardName)


func _on_reward_completed(completed_node):
    var is_escape = completed_node.metadata.is_escape
    if progressionScreen and is_escape:
        progressionScreen.initialize({"max_deck_size": 10, "node": completed_node})
        if completed_node.type == Utils.RoomType.FINAL:
            game.player.add_tokens(1)
        progressionScreen.visible = true



func _on_progression_save_pressed():
    print("_on_progression_save_pressed")
    progressionScreen.visible = false
    gameMenuScreen.visible = false
    _on_lobby_open_requested(null)

    

func _on_deckmanager_open_requested_from_map(options):
    print("Deck Manager requested with options:", options)
    
    # Hide game menu
    gameMenuScreen.visible = false
    
    # Show and initialize deck manager 
    
    if deckManagerScreen:
        deckManagerScreen.visible = true
        deckManagerScreen.initialize(options)
        back_to_map = true
    # Also emit signal for other systems that might need to know
    emit_signal("deckmanager_open_requested", options)



func _on_deckmanager_open_requested(options):
    print("Deck Manager requested with options:", options)
    
    # Hide game menu
    gameMenuScreen.visible = false
    
    # Show and initialize deck manager
    if deckManagerScreen:
        deckManagerScreen.visible = true
        deckManagerScreen.initialize(options)
    
    # Also emit signal for other systems that might need to know
    emit_signal("deckmanager_open_requested", options)

func _on_deck_manager_back_pressed():
    # Return to game menu screen
    deckManagerScreen.visible = false
    if not back_to_map:
        gameMenuScreen.visible = true
    else:
        mapScreen.visible = true

# _on_map_open_requested({"mode": "deep", "hand_size": game.player.hand_size,})
func _on_map_open_requested(options):
    print("Map requested with options:", options)
    gameMenuScreen.visible = false
    if "hand_size" in options:
        game.player.update_deck_hand_size(options.hand_size)
    if mapScreen:
        mapScreen.generate_map({"mode": options.mode})
        mapScreen.display_map()
        mapScreen.visible = true
    emit_signal("map_open_requested", options)

func _on_start_game_pressed(options):
    print("Starting game with options:", options)
     
    emit_signal("new_game_requested", options)
 
func _on_map_back_pressed():
    mapScreen.visible = false
    gameMenuScreen.visible = true

# Map node selection
func _on_map_node_selected(node_data):
    print("Selected map node: ", node_data)
    if node_data.type == Utils.RoomType.SHOP:
        print("Utils.RoomType.SHOP")
        back_to_map = true
        _on_shop_open_requested(node_data.metadata)
    elif node_data.type == Utils.RoomType.FINAL:
        print("Utils.RoomType.FINAL")
        if gameMenuScreen:
            gameMenuScreen.visible = false
        if deckManagerScreen:
            deckManagerScreen.visible = false
        if mapScreen:
            mapScreen.visible = false
        back_to_map = true
        _on_start_game_pressed(node_data)
    elif node_data.type == Utils.RoomType.NORMAL:
        print("Utils.RoomType.NORMAL")
        if gameMenuScreen:
            gameMenuScreen.visible = false
        if deckManagerScreen:
            deckManagerScreen.visible = false
        if mapScreen:
            mapScreen.visible = false
        back_to_map = true
        _on_start_game_pressed(node_data)
    elif node_data.type == Utils.RoomType.BOSS:
        print("Utils.RoomType.BOSS")
        if gameMenuScreen:
            gameMenuScreen.visible = false
        if deckManagerScreen:
            deckManagerScreen.visible = false
        if mapScreen:
            mapScreen.visible = false
        back_to_map = true
        _on_start_game_pressed(node_data)
    elif node_data.type == Utils.RoomType.EVENT:
        print("Utils.RoomType.EVENT")
        if gameMenuScreen:
            gameMenuScreen.visible = false
        if deckManagerScreen:
            deckManagerScreen.visible = false
        if mapScreen:
            mapScreen.visible = false
        back_to_map = true
        _on_start_game_pressed(node_data)

func _on_node_completed(options):
    var node_data = options.node
    var completed = options.completed
    var success = options.success
    if success:
        _on_reward_open_requested(node_data)
        print("**********************************")
        print("**********************************")
        print("**********************************")
        print("**********************************")
        print("**************MATCH***************")
        print("**************OVER****************")
        print("**********************************")
        print("**********************************")
        print("**********************************")
        print("**********************************")
    else:
        print("**********************************")
        print("**********************************")
        print("**********************************")
        print("**********************************")
        print("**************GAME****************")
        print("**************OVER****************")
        print("*************GITGUD***************")
        print("**********************************")
        print("**********************************")
        print("**********************************")


# Public method to show the menu
func show_menu():
    self.visible = true
    if gameMenuScreen:
        gameMenuScreen.visible = false
    if deckManagerScreen:
        deckManagerScreen.visible = false
    if mapScreen:
        mapScreen.visible = false