using System;
using Cirno.Scripts.AttackPatterns;
using Cirno.Scripts.Resources;
using Cirno.Scripts.Resources.BulletScripts;
using Godot;
using Godot.Collections;

namespace Cirno.Scripts.Actors;

[Tool]
public partial class ScriptableBulletsEmitter3D : Destructible3D, IActivable, IScriptHost3D
{
    public Node3D ParentObject => this;
    
    [Export]
    public BulletScript3D Script { get; set; }
    
    [Export] public string ActivationGroup { get; set; }

    [Export]
    public bool InvertSignal { get; private set; } = false;
    
    [Export]
    public bool EmitOnStart { get; set; } = false;

    // [Export] public bool Indestructible { get; private set; } = false;
    // [Export] public float Health = 1f;
    //
    // [Export] public BulletResource ExplosionData { get; set; }
    // [Export] public BulletOwner BulletGroup { get; set; } = BulletOwner.None;
    // [Export] public Array<DamageResistance> DamageResistances { get; set; } = [];
    
    [Signal]
    public delegate void StateChangedEventHandler(bool isEmitting);

    private bool _isActive = false;

    //private BulletScript _scriptInstance;

    protected BulletScript3D.BulletScriptMachine ScriptMachine; 
    
    public override void _Ready()
    {
        if (Engine.IsEditorHint()) return;
        //_scriptInstance = Script.Duplicate(true) as BulletScript;

        if (!string.IsNullOrWhiteSpace(ActivationGroup))
        {
            this.AddToGroup(ActivationGroup);
        }
        
        ScriptMachine = Script.Make(this);
        
        _homePosition = this.GlobalPosition;
        
        if (EmitOnStart)
        {
            _isActive = true;
            ScriptMachine.Start();
        }
        EmitSignal(SignalName.StateChanged, _isActive);
    }
    
    public override void _func_godot_apply_properties(Dictionary<string, Variant> props)
    {
        ActivationGroup = props["targetname"].AsString();
        
        var scriptPath = props["script_path"].AsString();
        if (!string.IsNullOrWhiteSpace(scriptPath))
        {
            Script = GD.Load<BulletScript3D>(scriptPath);            
        }
        else
        {
            GD.PushWarning("Emitter has no script assigned");
        }
        

        EmitOnStart = props["emit_on_start"].AsBool();
        InvertSignal = props["invert_signal"].AsBool();
        //TargetFunc = props["targetfunc"];
        //TargetName = props["targetname"];
        SetProperties(props);
    }

    public bool Activate(ActivationType activationType = ActivationType.Toggle)
    {
        if (Engine.IsEditorHint()) return false;
        switch (activationType)
        {
            case ActivationType.Use:
            case ActivationType.Toggle:
                _isActive = !_isActive;
                break;
            case ActivationType.Open:
            case ActivationType.Enable:
                _isActive = !InvertSignal;
                break;
            case ActivationType.Close:
            case ActivationType.Disable:
                _isActive = InvertSignal;
                break;
            case ActivationType.Destroy:
                _isActive = InvertSignal;
                // TODO: Explode
                break;
        }

        if (_isActive)
        {
            ScriptMachine.Start();
        }
        
        EmitSignal(SignalName.StateChanged, _isActive);

        return true;
    }
    
    public void Toggle()
    {
        this.Activate();
    }
    
    public override void _Process(double delta)
    {
        if (Engine.IsEditorHint()) return;
        if (!_isActive) return;
        
        ScriptMachine.UpdatePhase(delta);
    }

    private Vector3 _homePosition;
    public Vector3 HomePosition => _homePosition;
    
    public void ChangeSpriteDirection(Vector2 direction)
    {
        
    }
}