extends Node

const DEFAULT_ACTION_COLOR = Color.WHITE
const ENERGY_ACTION_COLOR = Color("ffff2b")
const NO_ENERGY_ACTION_COLOR = Color.RED
const ZONE_OPACITY = 0.4
const ZONE_ACTIVATED_COLOR = Color("#96B3DB")
const ZONE_DEACTIVATED_COLOR = Color("#FF006E")

const CARD_VISUALISATION_TIME = 0.3
const CARD_UP_PADDING = 50
    
@export var default_cursor : Texture2D
@export var hover_cursor : Texture2D

var all_inspected : Array[Node]
var inspected : Node = null
var inspected_card_info : CardInfo = null
var player : Player # renseigné par Player
var can_interact : bool = false
var current_selected_item : Item = null
var have_energy_to_use_item : bool = false
var could_use_item : bool = false
var can_use_item : bool = false
var press_time := 0.
var press_action_done := false

var action_disabled := false

func get_current_inspected() -> Node:
    if all_inspected.size() > 0:
        var mouse_pos := player.get_global_mouse_position()
        var closest_dist := INF
        var closest_ind := -1
        for i in all_inspected.size():
            var node := all_inspected[i]
            if not is_instance_valid(node):
                all_inspected.remove_at(i)
            elif node is Node2D:
                var dist = node.global_position.distance_squared_to(mouse_pos)
                if dist < closest_dist:
                    closest_dist = dist
                    closest_ind = i
            elif closest_ind < 0:
                closest_ind = i
        if all_inspected.size() > 0:
            return all_inspected[closest_ind]

    return null

func _ready():
    Input.set_custom_mouse_cursor(default_cursor)
    Input.set_custom_mouse_cursor(hover_cursor, Input.CURSOR_POINTING_HAND)
    %Action.visible =  false

func _process(delta):
    if player and not action_disabled:
        process_player_actions(delta)
    else :
        %ActionProgressBar.value = 0.

    %Inspector.position = get_viewport().get_mouse_position()

    if not action_disabled and current_selected_item and SceneManager.actual_scene.scene_id == "REGION":
        %ActionZone.radius = current_selected_item.usage_zone_radius * GameInfo.settings_data.zoom
        %ActionZone.color = ZONE_ACTIVATED_COLOR if can_use_item else ZONE_DEACTIVATED_COLOR
    else:
        %ActionZone.radius = 0
    
    %ActionZone.queue_redraw()

    update_card()

    update_inspector(get_current_inspected())

func process_player_actions(delta : float):
    can_interact = (
        inspected
        and inspected is Interactable
        and player.can_interact(inspected)
    )

    current_selected_item = player.data.inventory.get_item() 

    could_use_item = (
        current_selected_item
        and player.preview_could_use_item(current_selected_item)
    )

    have_energy_to_use_item = (
        current_selected_item
        and player.has_energy_to_use_item(current_selected_item)
    )

    can_use_item = could_use_item and have_energy_to_use_item

    if Input.is_action_pressed("move_pointer"):
        player.try_move(
            player.get_global_mouse_position()
        )
    if Input.is_action_just_pressed("drop"):
        player.drop_item()


    if (
        Input.is_action_pressed("action")
    ):
        if (
            can_use_item
            and current_selected_item.is_action_need_press_time()
            and not press_action_done
            and not can_interact
            and not inspected is InventoryGuiItemMouseDetector
        ):
            press_time += delta
            %ActionProgressBar.value = press_time/current_selected_item.get_action_press_time() * 100
            if not %ActionProgressPlayer.playing:
                %ActionProgressPlayer.play()
                %ActionProgressPlayer.pitch_scale = 1. / (current_selected_item.get_action_press_time() / %ActionProgressPlayer.stream.get_length())

            if press_time > current_selected_item.get_action_press_time():
                %ActionPlayer.play()
                player.try_use_item(
                    current_selected_item,
                    player.get_global_mouse_position()
                )
                press_action_done = true
    else:
        press_action_done = false
        press_time = 0
        %ActionProgressPlayer.playing = false
        %ActionProgressBar.value = 0.
    
    if Input.is_action_just_pressed("action"):
        if inspected is InventoryGuiItemMouseDetector:
            GameInfo.game_data.player_data.inventory.set_current_item(inspected.index)
        elif can_interact:
            var interactable = inspected as Interactable
            player.try_interact(interactable)
        elif can_use_item and not current_selected_item.is_action_need_press_time():
            player.try_use_item(
                current_selected_item,
                player.get_global_mouse_position()
            )

func inspect(node: Node):
    if not node in all_inspected:
        all_inspected.append(node)

func update_card():
    if (
        not inspected or inspected_card_info == null
        or get_tree().paused
        or action_disabled
        ):
        %CardVisualiser.hide()
    elif inspected != null :

        if inspected_card_info != %CardVisualiser.card_info:
            %CardVisualiser.card_info = inspected_card_info
        %CardVisualiser.show()

        var camera = get_viewport().get_camera_2d()
        var screen_size = get_viewport().get_visible_rect().size # * get_viewport().get_camera_2d().zoom

        if inspected is InspectableEntity:
            %CardPosition.position = (
                (inspected.global_position - camera.global_position) * get_viewport().get_camera_2d().zoom
                + ((screen_size) / 2)
                + inspected.get_card_up_padding() * Vector2.UP
            ) 
        elif inspected is Control:
            %CardPosition.position = inspected.global_position + inspected.size / 2 + CARD_UP_PADDING * Vector2.UP
        elif inspected is Node3D: 

            %CardPosition.position = (
                get_viewport().get_camera_3d().unproject_position(inspected.global_position)
                + CARD_UP_PADDING * Vector2.UP
            )
        # if %CardVisualiser.is_mouse_over():
        #     time_last_inspected = 0.
        

func update_inspector(current_inspected:Node):
    
    if current_inspected:
        if inspected != current_inspected:
            if inspected and inspected.has_method("inspect"):
                inspected.inspect(false)
            inspected = current_inspected
            if inspected.has_method("card_info"):
                inspected_card_info = inspected.card_info()
            else:
                inspected_card_info = null
            if inspected.has_method("inspect"):
                inspected.inspect(true)
    else:
        inspected = null

    if player and not action_disabled and (get_tree() and not get_tree().paused):
        if can_interact and inspected and inspected is Interactable:
            %Action.visible = true
            %ActionText.text = inspected.interact_text()
            %Action.modulate = DEFAULT_ACTION_COLOR if inspected.interaction_cost(player) == 0 else ENERGY_ACTION_COLOR
            %ActionEnergyImage.visible = inspected.interaction_cost(player) != 0
        elif current_selected_item and current_selected_item.use_text() != "":
            %Action.visible = true
            %ActionText.text = current_selected_item.use_text() + (tr("NO_ENERGY_LEFT") if not have_energy_to_use_item else "")
            if can_use_item:
                %Action.modulate = DEFAULT_ACTION_COLOR if current_selected_item.energy_usage == 0 else ENERGY_ACTION_COLOR
            else:
                %Action.modulate = NO_ENERGY_ACTION_COLOR
            %ActionEnergyImage.visible = current_selected_item.energy_usage != 0
        else:
            %Action.visible = false
    else:
        %Action.visible = false

func stop_inspect(node : Node = get_current_inspected()):
    all_inspected.erase(node)