using System;
using System.Collections.Generic;
using System.Linq;
using BITFALL.Entities.Equipment;
using BITKit.PlayerCamera;
using UnityEngine;
using UnityEngine.Rendering;
namespace BITKit.Entities.Player.Character
{
    public class EntityCharacter : EntityPlayerBehavior
    {
        [Header(Constant.Header.Components)]
        [SerializeField] private Renderer[] fpvRenderer = Array.Empty<Renderer>();
        [SerializeField] private Renderer[] tpvRenderer = Array.Empty<Renderer>();
        [SerializeField] private Renderer[] fpvOverrideRenderers = Array.Empty<Renderer>();
        [SerializeField] private Transform[] tpvRendererGroup = Array.Empty<Transform>();
        [Header(Constant.Header.Reference)]
        [SerializeReference, SubclassSelector] public IReference getDamage;

        [Inject(true)] private IHealth _health;
        
        [Inject(true)] private IPlayerCameraService _cameraService;

        [Inject(true)] private IEntityOverride _entityOverride;

        [Inject(true)] private IEntityEquipment _equipment;
        
        private Renderer[] _tpvRendererGroup;
        
        private readonly ValidHandle allowFPVOverride = new();

        public override void OnStart()
        {
            if (_health is not null)
            {
                _health.OnSetAlive += _ => UpdateMeshState();
                _health.OnDamageRelease += OnDamageRelease;
            }

            if (_cameraService is not null)
                _cameraService.OnCameraActivated += _ => UpdateMeshState();

            if (_entityOverride is not null)
                _entityOverride.OnOverride += _ =>
                {
                    UpdateMeshState();
                    allowFPVOverride.SetElements(_entityOverride,_);
                };
            _tpvRendererGroup = tpvRendererGroup.SelectMany(x => x.GetComponentsInChildren<Renderer>(true)).ToArray();

            if (_equipment is not null)
            {
                _equipment.OnEquipAddressable += _ =>
                {
                    allowFPVOverride.RemoveElement(_equipment);
                };
                _equipment.OnUnEquipAddressable += _ =>
                {
                    allowFPVOverride.AddElement(_equipment);
                };
            }
            
            allowFPVOverride.AddListener(value =>
            {
                foreach (var x in fpvOverrideRenderers)
                {
                    x.enabled = value;
                }
            });
            
            allowFPVOverride.Invoke();
        }
        public override void OnPlayerInitialized()
        {
            UpdateMeshState();
        }
        public override void OnPlayerDispose()
        {
            SetFPV(false);
        }
        // private void OnSetHP(int hp)
        // {
        //     UnityEntity.Invoke<string>(Constant.Animation.Play, getDamage.Value);
        // }
        private void OnDamageRelease(DamageMessage damageMessage)
        {
            UnityEntity.Invoke<string>(Constant.Animation.Play, getDamage.Value);
        }

        private void UpdateMeshState()
        {
            switch (_health, _cameraService)
            {
                case (null, null):
                    SetFPV(true);
                    break;
                case (null, not null):
                    SetFPV(_cameraService.IsCameraActivated);
                    break;
                case (not null, null):
                    SetFPV(_health.IsAlive);
                    break;
                case (not null, not null):
                    SetFPV(_health.IsAlive && _cameraService.IsCameraActivated);
                    break;
            }
        }

        private void SetFPV(bool isFpv)
        {
            var shadowMode = isFpv ?
            ShadowCastingMode.ShadowsOnly :
            ShadowCastingMode.On;
            foreach (var x in fpvRenderer)
            {
                x.enabled = isFpv;
            }
            foreach (var x in tpvRenderer)
            {
                x.shadowCastingMode = shadowMode;
            }
            foreach (var x in _tpvRendererGroup)
            {
                x.shadowCastingMode =
                    _entityOverride is not null
                        ? _entityOverride.IsOvering ? ShadowCastingMode.On : shadowMode
                        : shadowMode;
            }
        }
    }
}