using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using SynthySound;
using EvilSatellites.Screens;
using EvilSatellites.Objects;
using Microsoft.Xna.Framework;

namespace EvilSatellites
{
    public class Radar
    {
        public bool Active { get; set; }
        public IGameObject Owner;
        public IGameObject Target;
        public IScreen Screen;
        public ISoundEffect3D RadarNoise;
        public ObjectType Filter;
        public Vector3 RadarDirection;
        public Vector3 RadarPosition;
        public bool IsPlaying;
        public Vector3 RadarTarget;
        public Matrix RadarOrientation;
        public float RadarPitch;
        public Radar(IGameObject owner, IScreen screen)
        {
            Owner = owner;
            Screen = screen;
            RadarNoise = Screen.Manager.Sound.Load3D(@"sfx/ui/radar/pingEnemy.wav");
            RadarNoise.Loop = true;
            Filter = ObjectType.Satellite;
            
            Active = false;
        }

        public void SetObjectType(ObjectType type)
        {
            Filter = type;
        }

        public void Start()
        {
            RadarNoise.Reset();
            RadarNoise.Play();
            Active = true;
        }

        public void Stop()
        {
            RadarNoise.Pause();
            Active = false;
        }

        public void UpdateX(List<IGameObject> objects)
        {
            if (objects.Count < 1) return;
            float minDistance = 50000000;
            Target = null;
            foreach (var obj in objects)
            {
                if (obj.Type != Filter) continue;
                float distance = Vector3.Distance(obj.Position, Owner.Position);
                if (distance < minDistance)
                {
                    minDistance = distance;
                    Target = obj;
                }
            }
            if (Target == null)
            {
                RadarNoise.Pitch = 0.1;
                RadarPitch = 0.1f;
                return;
            }
            Vector3 radarTarget = (Target.Position - Owner.Position);
            radarTarget.Normalize();
            RadarNoise.Pitch = MathHelper.Clamp(0.1f / Vector3.Distance(Owner.Rotation.Forward, radarTarget) * 3f, 0, 1);
            RadarPitch = MathHelper.Clamp(0.1f / Vector3.Distance(Owner.Rotation.Forward, radarTarget) * 3f, 0, 1);
        }


        public void Update(List<IGameObject> objects)
        {
            if (IsPlaying)
            {
                RadarPosition += RadarDirection;
                RadarNoise.Position = new System.Numerics.Vector3(RadarPosition.X, RadarPosition.Y, RadarPosition.Z);
                RadarNoise.Pitch = MathHelper.Clamp(0.1f / Vector3.Distance(Owner.Rotation.Forward, RadarTarget) * 3f, 0, 2);
                RadarPitch = MathHelper.Clamp(0.1f / Vector3.Distance(Owner.Rotation.Forward, RadarTarget) * 3f, 0, 2);
                if (Vector3.Distance(RadarPosition, Owner.Position) > 20)
                {
                    IsPlaying = false;
                }
            } else
            {
                if (objects.Count < 1)
                {
                    RadarNoise.Volume = 0f;
                }
                float minDistance = 50000000;
                Target = null;
                foreach (var obj in objects)
                {
                    if (obj.Type != Filter) continue;
                    float distance = Vector3.Distance(obj.Position, Owner.Position);
                    if (distance < minDistance)
                    {
                        minDistance = distance;
                        Target = obj;
                    }
                }
                if (Target == null)
                {
                    RadarNoise.Volume = 0f;
                    return;
                }
                Vector3 radarTarget = (Target.Position - Owner.Position);
                radarTarget.Normalize();
                RadarTarget = radarTarget;
                RadarPosition = new Vector3(Owner.Position.X+Owner.Dimensions.X/2, Owner.Position.Y+Owner.Dimensions.Y/2, Owner.Position.Z+Owner.Dimensions.Z/2);
                RadarDirection = new Vector3(radarTarget.X*0.5f, radarTarget.Y*0.5f, radarTarget.Z*0.5f);
                RadarOrientation = Matrix.Invert(Matrix.CreateTranslation(Target.Position) * Matrix.CreateLookAt(Target.Position, Owner.Position, Owner.Rotation.Up));
                RadarNoise.Reset();
                RadarNoise.Volume = 1f;
                // RadarNoise.Play();
                IsPlaying = true;
                // RadarNoise.Pitch = MathHelper.Clamp(0.1f / Vector3.Distance(Owner.Rotation.Forward, radarTarget) * 3f, 0, 1);
            }
        }

        public void Destroy()
        {
            RadarNoise.Destroy();
        }
    }
}