using System.Collections.Generic;
using System.Linq;
using Cirno.Scripts.Components;
using Cirno.Scripts.Controllers;
using Cirno.Scripts.Resources;
using Godot;

namespace Cirno.Scripts.Weapons;

public partial class Bullet3D : Area3D, IBullet
{
    [Export] public float Speed { get; set; } = 1900f;

    public BulletOwner BulletOwner => _bulletInfo?.Owner ?? BulletOwner.None;

    public float Damage => _bulletInfo?.Damage ?? 1;

    public DamageType DamageType => _bulletInfo?.DamageType ?? DamageType.Neutral;

    protected Vector2 _direction = Vector2.Right;

    private double _elapsedTime = 0f;
    private BulletInfo _bulletInfo;

    public BulletInfo BulletInfo => _bulletInfo;

    private List<ModifierWrapper> _modifiers = new();

    public bool IsGrazed { get; set; } = false;

    public bool IsFrozen { get; private set; } = false;
    public bool Enabled { get; private set; } = false;

    [Signal]
    public delegate void OnDestroyEventHandler();

    [Signal]
    public delegate void InitializedEventHandler(); 

    private AudioStreamPlayer3D _grazeSound;
    private GpuParticles3D _grazeParticles;

    private CollisionShape3D _collisionShape;

    public override void _Ready()
    {
        _grazeSound = GetNodeOrNull<AudioStreamPlayer3D>("AudioStreamPlayer");
        _grazeParticles = GetNodeOrNull<GpuParticles3D>("GrazeParticles");

        _collisionShape = GetNode<CollisionShape3D>("CollisionShape");
    }

    public void Initialize(BulletInfo bulletInfo)
    {
        _bulletInfo = bulletInfo;
        

        _elapsedTime = 0f;

        this.Speed = bulletInfo.Speed;

        // Need to clone them here
        // _modifiers = _bulletInfo.TimeModifiers.Select(x => x.MakeClone()).ToList();


        // var clonedModifiers = _bulletInfo.TimeModifiers.Select(x => x.MakeClone());
        // _modifiers = clonedModifiers.ToList();

        // Ugly hack to make instances unique
        _modifiers = _bulletInfo.TimeModifiers.Select(x => x.Wrap()).ToList();
        
        EmitSignalInitialized();
    }

    /// <summary>
    /// Enables the bullet, shows the sprite and activates collisions
    /// </summary>
    public void Enable()
    {
        Enabled = true;
        Show();
        if (this._collisionShape is null)
        {
            _collisionShape = GetNode<CollisionShape3D>("CollisionShape");
        }

        _collisionShape.SetDeferred(CollisionShape3D.PropertyName.Disabled, false);
    }

    /// <summary>
    /// Disables the bullet, hides the sprite and disables collisions
    /// </summary>
    public void Disable(bool hideSprite = true)
    {
        Enabled = false;
        if (hideSprite && !BulletInfo.Attributes.HasFlag(BulletFlags.PersistSprite))
        {
            Hide();
        }

        if (this._collisionShape is null)
        {
            _collisionShape = GetNode<CollisionShape3D>("CollisionShape2D");
        }

        _collisionShape.SetDeferred(CollisionShape2D.PropertyName.Disabled, true);
    }

    public void Graze()
    {
        if (!Enabled) return;
        _grazeSound?.Play();
        if (_grazeParticles is not null)
        {
            _grazeParticles.Emitting = true;
        }

        IsGrazed = true;
    }

    private void ApplyTimeModifiers(double delta)
    {
        return;
        // foreach (var modifier in _modifiers)
        // {
        //     if (_elapsedTime >= modifier.TimeModifier.TimeInSeconds)
        //     {
        //         if (!modifier.Applied)
        //         {
        //             modifier.Applied = true;
        //             modifier.TimeModifier.Start(this);
        //             modifier.Elapsed = 0;
        //         }
        //         else
        //         {
        //             modifier.Elapsed += delta;
        //         }
        //
        //         modifier.TimeModifier.Update(this, delta, modifier.Elapsed);
        //         
        //     }
        // }
    }

    public virtual void RotateBullet(float degrees)
    {
        float radians = Mathf.DegToRad(degrees);
        _direction = _direction.Rotated(radians).Normalized(); // Rotate direction
        
        if (!BulletInfo.Attributes.HasFlag(BulletFlags.Rotateable)) return;
        //SetRotation(Rotation + radians);
    }

    public virtual void RotateSpriteDegrees(float degrees)
    {
        if (!BulletInfo.Attributes.HasFlag(BulletFlags.Rotateable)) return;
        //SetRotationDegrees(RotationDegrees + degrees);
    }

    public virtual void RotateSprite(float radians)
    {
        if (!BulletInfo.Attributes.HasFlag(BulletFlags.Rotateable)) return;
        //SetRotation(Rotation + radians);
    }

    public void FacePlayer()
    {
        // if (_gameManager.Player != null)
        // {
        //     //_direction = (_gameManager.PlayerPosition.Value - this.GlobalPosition).Normalized();
        //     RotateBullet(0); // quick hack to rotate lasers
        //     //LookAt(player.GlobalPosition);
        // }
    }
    

    public void SetDirection(Vector2 direction)
    {
        var normalized = direction.Normalized();

        _direction = normalized;

        if (!BulletInfo.Attributes.HasFlag(BulletFlags.Rotateable)) return;
        //SetRotation(Mathf.Atan2(normalized.Y, normalized.X) + Mathf.Pi / 2);

       
    }

    // Called every frame. 'delta' is the elapsed time since the previous frame.
    public override void _Process(double delta)
    {
        if (!Enabled) return;
        _elapsedTime += delta;

        if (_elapsedTime >= _bulletInfo.LifeTime)
        {
            Destroy();
        }
    }

    public override void _PhysicsProcess(double delta)
    {
        if (!Enabled) return;
        if (_bulletInfo != null)
        {
            ApplyTimeModifiers(delta);
        }

        if (BulletInfo.Attributes.HasFlag(BulletFlags.Controllable))
        {
            ControlBullet(delta);
        }

        var newPos2D = ((float)(Speed * delta) * _direction);
        
        this.Position += new Vector3(newPos2D.X, 0, newPos2D.Y);
    }

    private void ControlBullet(double delta)
    {
        if (!Enabled) return;
        var axis = Input.GetAxis("left", "right");

        if (axis != 0)
        {
            float rotationSpeed = 180f; // Degrees per second
            RotateBullet(axis * rotationSpeed * (float)delta);
        }
    }

    private void _on_visible_on_screen_notifier_2d_screen_exited()
    {
        if (!Enabled) return;
        if (!BulletInfo.Attributes.HasFlag(BulletFlags.DieOutOfScreen)) return;
        //Debug.WriteLine("Destroy bullet out of screen");
        Destroy();
    }

    private void _on_body_entered(Node3D body)
    {
        if (body.IsInGroup("Destroyable") && body is IDestructible destructible &&
            CanHit(BulletOwner, destructible.BulletGroup))
        {
            // hit
            destructible.Hit(Damage, DamageType);

            RequestCollisionDestruction();
            return;
        }
        
        if (body.IsInGroup("Solid"))
        {
            //Debug.WriteLine("Collision");
            RequestCollisionDestruction();
        }
        //// Do not Collide with body for purpose of destroying bullets
        // else if (body.IsInGroup("Destroyable"))
        // {
        // 	Debug.WriteLine("Collision with destroyable object body");
        // 	QueueFree();
        // }
    }

    private void _on_area_entered(Area3D area)
    {
        if (area.IsInGroup("Solid"))
        {
            RequestCollisionDestruction();
            return;
        }

        if (area.IsInGroup("Destroyable") && area is IDestructible destructible &&
            CanHit(BulletOwner, destructible.BulletGroup))
        {
            // hit
            destructible.Hit(Damage, DamageType);

            RequestCollisionDestruction();
        }
    }

    public bool CanHit(BulletOwner bulletOwner, BulletOwner targetGroup)
    {
        // If either is None, it always hits
        if (bulletOwner == BulletOwner.None || targetGroup == BulletOwner.None)
        {
            return true;
        }

        // Otherwise, it hits only if they are different groups
        return bulletOwner != targetGroup;
    }

    public void RequestCollisionDestruction()
    {
        if (!Enabled) return;
        if (_bulletInfo.DestroyOnCollision)
        {
            Destroy();
        }
    }

    private void Destroy()
    {
        if (_bulletInfo?.DestructionParticlesScene != null)
        {
            //this.CreateSibling<Node2D>(_bulletInfo.DestructionParticlesScene);

            //particle.Init();
        }

        EmitSignal(Bullet.SignalName.OnDestroy);
        //QueueFree();
        PoolingManager.Instance.DisableBullet(this);
    }

    public void Freeze()
    {
        IsFrozen = true;
        EmitSignal(Bullet.SignalName.OnDestroy);
        //QueueFree();
        PoolingManager.Instance.DisableBullet(this);
    }
}