using Godot;
using System;
using Cirno._3D.TrenchBroom.EntityScripts.Triggers;
using Cirno.Scripts;
using Cirno.Scripts.Components.FSM._3DPlayer;
using Cirno.Scripts.Utils;
using Godot.Collections;

[Tool]
public partial class TriggerArea : Area3D, ITargetable, ITargeting, IActivationType
{
	[Export] public string Target { get;  set; }
	[Export] public string TargetFunc { get; private set; }
	[Export] public string TargetName { get; set; }

	[Export] public int MinActivations { get; private set; } = 0;
	[Export] public int MaxActivations { get; private set; } = 1;
	
	[Export] public ActivationType ActivationType { get; set; } = ActivationType.Toggle;

	public enum TriggerStates
	{
		READY,
		USED,
		WAITING
	}
	
	private TriggerStates _triggerState = TriggerStates.READY;

	private float _timeout = 0f;
	private Node _lastActivator;

	private int _activations = 0;
	
	public void _func_godot_apply_properties(Dictionary<string, Variant> props)
	{
		
		((ITargetable)this).ApplyTargetProperties(props);
		((ITargeting)this).ApplyTargetingProperties(props);
		//Target = props["target"];
		TargetFunc = props["targetfunc"].AsString();
		//TargetName = props["targetname"];
		// if (props.TryGetValue("activationtype", out var type))
		// {
		// 	var t = Enum.TryParse(type.AsString(), true, out ActivationType activationType);
		// 	if (t)
		// 	{
		// 		ActivationType = activationType;
		// 	}
		// }
		((IActivationType)this).ApplyActivationTypeProperties(props);
		

		if (props.TryGetValue("minactivations", out var minActivations))
		{
			MinActivations = minActivations.AsInt32();
		}
		
		if (props.TryGetValue("maxactivations", out var maxActivations))
		{
			MaxActivations = maxActivations.AsInt32();
		}
	}

	public void _on_ent_entered(Node ent)
	{
		//GD.Print($"Trigger entered by {ent.Name}");
		switch (_triggerState)
		{
			case TriggerStates.READY:
				if (ent is IsoPlayerFSMProxy)
				{
					if (_activations >= MinActivations && _activations < MaxActivations )
					{
						Use();
					}
					else
					{
						_activations++;
					}
				}
				break;
			case TriggerStates.USED:
				break;
			
		
		}
		// if (_triggerState is TriggerStates.READY)
		// {
		// 	if (ent is IsoPlayerFSMProxy)
		// 	{
		// 		//GD.Print($"Entity {ent} is player, trying to use");
		// 		Use();
		// 	}
		// 	else
		// 	{
		// 		//GD.Print($"{ent.Name} was not interaction controller");
		// 	}
		// }
		// else
		// {
		// 	//GD.Print("Trigger was not ready");
		// }
	}

	public void Use()
	{
		if (_triggerState is not TriggerStates.READY) return;
		
		ActivationHelper.UseTargets(this, Target, ActivationType);
			
		_activations++;
		
		if (_activations >= MaxActivations)
		{
			_triggerState = TriggerStates.USED;
			ToggleCollision(false);
		}
	}

	private void ToggleCollision(bool toggle)
	{
		SetDeferred(nameof(Monitoring), toggle);
		//Monitoring = toggle;
	}
	
	// Called when the node enters the scene tree for the first time.
	public override void _Ready()
	{
		if (Engine.IsEditorHint()) return;
		
		//TBGAME.set_targetname(self, targetname)
		if (!string.IsNullOrEmpty(TargetName))
		{
			this.AddToGroup(TargetName);
		}
	}

	public TriggerArea()
	{
		Monitoring = true;
		Monitorable = false;
		BodyEntered += _on_ent_entered;
		//AreaEntered += _on_ent_entered;
	}
	
}