using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using Cysharp.Threading.Tasks;
#if UNITY_EDITOR
using UnityEditor;
using UnityEditor.UIElements;
#endif
using UnityEngine;
using UnityEngine.Accessibility;
using UnityEngine.Profiling;
using UnityEngine.UIElements;
// ReSharper disable PossibleMultipleEnumeration

namespace BITKit.Sensors
{
	/// <summary>
	/// 智能目标传感器,根据条件,智能选择目标
	/// </summary>
	public class SmartTargetSensor :MonoBehaviour,ISensor,IAction
	{
		/// <summary>
		/// 自动更新
		/// </summary>
		[Header(Constant.Header.Settings)]
		[SerializeField] private bool autoUpdate;
		[SerializeField] private Optional<string[]> ignoreTags;
		[SerializeField] private Optional<IntervalUpdate> optionalRetargetInterval;
		
		
		/// <summary>
		/// 主传感器
		/// </summary>
		[Header(nameof(Sensor))]
		[SerializeField,SerializeReference,SubclassSelector] private ISensor sensor;

		[Header(Constant.Header.Debug)]
		[SerializeReference, ReadOnly] private int updateCount;

		public IEnumerable<Transform> Get() =>CurrentTarget is not null ? new[] { CurrentTarget }:Enumerable.Empty<Transform>();

		bool ISensor.AutoUpdate => autoUpdate;
		
		public bool IsValid(Collider _collider)
		{
			if (!_collider) return false;
			if (ignoreTags.Allow)
			{
				if (_collider.TryGetComponent<ITag>(out var iTags))
				{
					var tags = iTags.GetTags();
					foreach (var x in ignoreTags.Value)
					{
						if (tags.Contains(x))
						{
							return false;
						}
					}
				}
			}
			return true;
		}
		public float GetDistance() => sensor.GetDistance();
		public Transform CurrentTarget { get; private set; }
		private IEnumerable<Transform> detected = ArraySegment<Transform>.Empty;
		private Vector3 _currentPosition;
		private int Id;
		
		private CancellationTokenSource timeoutCancellationTokenSource=new();

		private void OnEnable()
		{
			SensorQueue.Register(Id=GetInstanceID(),this);
		}
		private void OnDisable()
		{
			SensorQueue.UnRegister(Id);
		}
		public async UniTask Execute()
		{
			updateCount++;
			timeoutCancellationTokenSource?.Cancel();
			timeoutCancellationTokenSource = new CancellationTokenSource();
			await sensor.Execute();
			Profiler.BeginSample("Release Detected Buffer");
			var newDetected = sensor.Get();
			Profiler.EndSample();
			// ReSharper disable once PossibleMultipleEnumeration
			if (newDetected.Contains(CurrentTarget))
			{
				if (optionalRetargetInterval.Allow && optionalRetargetInterval.Value.AllowUpdate)
				{
					
				}
				else
				{
					return;
				}
			}
			Profiler.BeginSample("Filter Detected");
			// // ReSharper disable once PossibleMultipleEnumeration
			// CurrentTarget = newDetected
			// 	.Where(_transform => IsValid(_transform.GetComponent<Collider>()))
			// 	.OrderBy(_transform => Vector3.Distance(currentPosition, _transform.position))
			// 	.FirstOrDefault();
			

			foreach (var x in newDetected.OrderBy(KeySelector))
			{
				if(IsValid(x.GetComponent<Collider>()) is false)continue;
				CurrentTarget = x;
				break;
			}
			Profiler.EndSample();
		}
		private float KeySelector(Transform x)
		{
			return Vector3.Distance(_currentPosition, x.position);
		}
		void IAction.Execute()
		{
			Execute().Forget();
		}
		#if UNITY_EDITOR
		private void OnDrawGizmosSelected()
		{
			try
			{
				if (!CurrentTarget) return;
				Gizmos.DrawLine(transform.position,CurrentTarget.position);
			}
			catch (UnassignedReferenceException)
			{
			}
		
		}
#endif
	}
	#if UNITY_EDITOR
	[CustomEditor(typeof(SmartTargetSensor))]
	public class SmartTargetSensorInspector:BITInspector<SmartTargetSensor>
	{
		private ObjectField _objectField;
		public override VisualElement CreateInspectorGUI()
		{
			FillDefaultInspector();
			 
			CreateSubTitle("Editor Debug Field");

			_objectField = root.Create<ObjectField>();
			
			_objectField.objectType = typeof(Transform);

			_objectField.SetEnabled(false);
			
			return root;
		}

		protected override void OnUpdate()
		{
			if (_objectField is not null)
			{
				_objectField.value = agent.CurrentTarget;
			}
		}
	}
	#endif
}