extends Node

## GameController - Top-level controller managing menu and game states

enum State {
	MENU,
	DECK_BUILDER,
	GAME_SETUP,
	PLAYING,
	PAUSED
}

var current_state: State = State.MENU

# Menu window size (matches project.godot viewport)
const MENU_SIZE := Vector2i(460, 689)
# Deck builder window size
const DECK_BUILDER_SIZE := Vector2i(1600, 900)
# Game setup window size
const GAME_SETUP_SIZE := Vector2i(800, 600)
# Game window size
const GAME_SIZE := Vector2i(2160, 980)

# Scene references
var main_menu: MainMenu = null
var deck_builder: DeckBuilder = null
var game_setup_menu: GameSetupMenu = null
var game_scene: Node3D = null
var pause_menu: PauseMenu = null

# Selected decks for gameplay
var selected_deck: Deck = null
var player1_deck: Array = []  # Card IDs for player 1
var player2_deck: Array = []  # Card IDs for player 2

# Preload the main game scene script
const MainScript = preload("res://scripts/Main.gd")

func _ready() -> void:
	process_mode = Node.PROCESS_MODE_ALWAYS
	_show_main_menu()

func _input(event: InputEvent) -> void:
	if event is InputEventKey and event.pressed:
		if event.keycode == KEY_ESCAPE:
			match current_state:
				State.DECK_BUILDER:
					_on_deck_builder_back()
				State.GAME_SETUP:
					_on_game_setup_back()
				State.PLAYING:
					_show_pause_menu()
				State.PAUSED:
					_hide_pause_menu()

func _show_main_menu() -> void:
	# Clean up any existing game
	if game_scene:
		game_scene.queue_free()
		game_scene = null

	if pause_menu:
		pause_menu.queue_free()
		pause_menu = null

	# Switch back to small borderless menu window
	DisplayServer.window_set_mode(DisplayServer.WINDOW_MODE_WINDOWED)
	DisplayServer.window_set_flag(DisplayServer.WINDOW_FLAG_BORDERLESS, true)
	DisplayServer.window_set_size(MENU_SIZE)
	var screen := DisplayServer.screen_get_size()
	DisplayServer.window_set_position(Vector2i(
		(screen.x - MENU_SIZE.x) / 2,
		(screen.y - MENU_SIZE.y) / 2
	))

	# Reset viewport to main menu size
	get_tree().root.content_scale_size = MENU_SIZE

	# Clean up deck builder if exists
	if deck_builder:
		deck_builder.queue_free()
		deck_builder = null

	# Clean up game setup menu if exists
	if game_setup_menu:
		game_setup_menu.queue_free()
		game_setup_menu = null

	# Create main menu
	if not main_menu:
		main_menu = MainMenu.new()
		add_child(main_menu)
		main_menu.play_game.connect(_on_start_game)
		main_menu.deck_builder.connect(_on_deck_builder)

	main_menu.visible = true
	current_state = State.MENU

func _on_start_game() -> void:
	# Hide menu
	if main_menu:
		main_menu.visible = false

	# Show game setup menu
	_show_game_setup_menu()


func _on_deck_builder() -> void:
	# Hide menu
	if main_menu:
		main_menu.visible = false

	# Switch to deck builder window size
	DisplayServer.window_set_flag(DisplayServer.WINDOW_FLAG_BORDERLESS, false)
	DisplayServer.window_set_size(DECK_BUILDER_SIZE)
	var screen := DisplayServer.screen_get_size()
	DisplayServer.window_set_position(Vector2i(
		(screen.x - DECK_BUILDER_SIZE.x) / 2,
		(screen.y - DECK_BUILDER_SIZE.y) / 2
	))

	# Set viewport to deck builder size
	get_tree().root.content_scale_size = DECK_BUILDER_SIZE

	# Create deck builder
	if not deck_builder:
		deck_builder = DeckBuilder.new()
		add_child(deck_builder)
		deck_builder.back_pressed.connect(_on_deck_builder_back)
		deck_builder.deck_selected.connect(_on_deck_selected)

	deck_builder.visible = true
	current_state = State.DECK_BUILDER


func _on_deck_builder_back() -> void:
	if deck_builder:
		deck_builder.visible = false
	_show_main_menu()


func _show_game_setup_menu() -> void:
	# Switch to game setup window size (borderless like main menu)
	DisplayServer.window_set_flag(DisplayServer.WINDOW_FLAG_BORDERLESS, true)
	DisplayServer.window_set_size(GAME_SETUP_SIZE)
	var screen := DisplayServer.screen_get_size()
	DisplayServer.window_set_position(Vector2i(
		(screen.x - GAME_SETUP_SIZE.x) / 2,
		(screen.y - GAME_SETUP_SIZE.y) / 2
	))

	# Resize the root viewport to match the window size to avoid letterboxing
	get_tree().root.content_scale_size = GAME_SETUP_SIZE

	# Create game setup menu
	if not game_setup_menu:
		game_setup_menu = GameSetupMenu.new()
		add_child(game_setup_menu)
		game_setup_menu.back_pressed.connect(_on_game_setup_back)
		game_setup_menu.start_game_requested.connect(_on_game_setup_start)

	game_setup_menu.visible = true
	current_state = State.GAME_SETUP


func _on_game_setup_back() -> void:
	if game_setup_menu:
		game_setup_menu.visible = false
	_show_main_menu()


func _on_game_setup_start(p1_deck: Array, p2_deck: Array) -> void:
	player1_deck = p1_deck
	player2_deck = p2_deck

	if game_setup_menu:
		game_setup_menu.visible = false

	# Switch to game window size
	DisplayServer.window_set_flag(DisplayServer.WINDOW_FLAG_BORDERLESS, false)
	DisplayServer.window_set_size(GAME_SIZE)
	var screen := DisplayServer.screen_get_size()
	DisplayServer.window_set_position(Vector2i(
		(screen.x - GAME_SIZE.x) / 2,
		(screen.y - GAME_SIZE.y) / 2
	))

	# Set viewport to game size
	get_tree().root.content_scale_size = GAME_SIZE

	_start_new_game()


func _on_deck_selected(deck: Deck) -> void:
	selected_deck = deck
	if deck_builder:
		deck_builder.visible = false

	# Switch to game window size and start game
	DisplayServer.window_set_flag(DisplayServer.WINDOW_FLAG_BORDERLESS, false)
	DisplayServer.window_set_size(GAME_SIZE)
	var screen := DisplayServer.screen_get_size()
	DisplayServer.window_set_position(Vector2i(
		(screen.x - GAME_SIZE.x) / 2,
		(screen.y - GAME_SIZE.y) / 2
	))

	# Set viewport to game size
	get_tree().root.content_scale_size = GAME_SIZE

	_start_new_game()

func _start_new_game() -> void:
	# Make sure game isn't paused
	get_tree().paused = false

	# Clean up existing game
	if game_scene:
		game_scene.queue_free()
		game_scene = null

	# Reset GameManager state
	if GameManager:
		GameManager.is_game_active = false
		GameManager.game_state = null

	# Create new game scene
	game_scene = Node3D.new()
	game_scene.set_script(MainScript)

	# Pass deck configurations if available
	if player1_deck.size() > 0:
		game_scene.player1_deck = player1_deck
	if player2_deck.size() > 0:
		game_scene.player2_deck = player2_deck

	add_child(game_scene)

	# Create pause menu
	if not pause_menu:
		pause_menu = PauseMenu.new()
		add_child(pause_menu)
		pause_menu.resume_game.connect(_on_resume_game)
		pause_menu.restart_game.connect(_on_restart_game)
		pause_menu.return_to_menu.connect(_on_return_to_menu)

	current_state = State.PLAYING

func _show_pause_menu() -> void:
	if pause_menu:
		pause_menu.show_menu()
	current_state = State.PAUSED

func _hide_pause_menu() -> void:
	if pause_menu:
		pause_menu.hide_menu()
	current_state = State.PLAYING

func _on_resume_game() -> void:
	current_state = State.PLAYING

func _on_restart_game() -> void:
	_start_new_game()

func _on_return_to_menu() -> void:
	_show_main_menu()