using System;
using System.Collections.Generic;
using System.Linq;
using DG.Tweening;
using Lean.Pool;
using Sirenix.OdinInspector;
using UniRx;
using UnityEngine;

namespace Cielonos.MainGame.Characters
{
    [ExecuteInEditMode]
    public partial class RenderSubcontrollerBase : SubcontrollerBase<CharacterBase>
    {
        public List<SkinnedMeshRenderer> baseRenderers;
        public List<Material> baseRenderMaterials;

        [ValueDropdown("GetMeshTypeDropdown")] public string meshType;

        public IntReactiveProperty activeEffectCount = new IntReactiveProperty(0);
        public GameObject effectContainer;
        public List<string> effectPartNames;
        public List<MeshEffectRendererInfo> meshEffectRenderers;

        public Dictionary<string, MeshEffectUnit> meshEffectUnits;

        [HideInEditorMode] public Dictionary<string, List<Material>> effectRenderMaterials;
    }

    public partial class RenderSubcontrollerBase
    {
        private IEnumerable<string> GetMeshTypeDropdown()
        {
            return new[] { "Submesh", "SeparateMesh" };
        }
    }

    public partial class RenderSubcontrollerBase
    {
        public override void Initialize()
        {
            base.Initialize();

            baseRenderMaterials = new List<Material>();
            foreach (SkinnedMeshRenderer renderer in baseRenderers)
            {
                baseRenderMaterials.AddRange(renderer.materials);
            }

            if (effectContainer == null) return;

            activeEffectCount.Subscribe(count => { effectContainer.SetActive(count > 0); });

            effectRenderMaterials = new Dictionary<string, List<Material>>();

            SkinnedMeshRenderer[] effectRenderers = effectContainer.GetComponentsInChildren<SkinnedMeshRenderer>(true);

            if (meshType == "SeparateMesh")
            {
                for (int i = 0; i < effectPartNames.Count; i++)
                {
                    List<Material> mats = effectRenderers.Select(renderer => renderer.materials[i]).ToList();
                    effectRenderMaterials[effectPartNames[i]] = mats;
                }
            }
            else if (meshType == "Submesh")
            {
                for (int i = 0; i < effectPartNames.Count; i++)
                {
                    List<Material> mats = effectRenderers[i].materials.ToList();
                    effectRenderMaterials[effectPartNames[i]] = mats;
                }
            }

            meshEffectUnits = new Dictionary<string, MeshEffectUnit>
            {
                { "Weak", new MeshEffectUnit(this, "Weak") },
                { "Freeze", new MeshEffectUnit(this, "Freeze") },
                { "Burn", new MeshEffectUnit(this, "Burn") },
                { "ElectronicParalysis", new MeshEffectUnit(this, "ElectronicParalysis", false, true) }
            };
        }
    }

    #region GetHitBlink



    public partial class RenderSubcontrollerBase
    {
        private Sequence getHitBlinkTween;

        public void GetHitBlink()
        {
            getHitBlinkTween?.Kill(true);
            getHitBlinkTween = DOTween.Sequence();

            foreach (Material mat in baseRenderMaterials)
            {
                if (!mat.IsKeywordEnabled("_RIM_LIGHTING_ON"))
                {
                    continue;
                }

                Tweener rimTween = mat.DOFloat(0.06f, "_RimAttenuation", 0.125f)
                    .From(0f)
                    .SetEase(Ease.OutQuad)
                    .SetLoops(2, LoopType.Yoyo);

                getHitBlinkTween.Join(rimTween);
            }

            getHitBlinkTween.Play();
        }
    }

    #endregion

    #region Outline

    public partial class RenderSubcontrollerBase
    {
        private Sequence outlineOnTween;
        private Sequence outlineOffTween;

        public void OutlineOn(BreakthroughType type, float width, float fadeInDuration)
        {
            outlineOffTween?.Kill(true);
            outlineOnTween?.Kill(true);
            outlineOnTween = DOTween.Sequence();

            outlineOnTween.OnPlay(() => { activeEffectCount.Value++; });

            foreach (Material mat in effectRenderMaterials["Outline"])
            {
                mat.SetColor("_Outline_Color", MainGameManager.BaseCollection.outlineColorCollection[type]);

                Tweener matTween = mat.DOFloat(width, "_Outline_Thickness", fadeInDuration)
                    .From(0.0f)
                    .SetEase(Ease.OutQuad);
                outlineOnTween.Join(matTween);
            }

            outlineOnTween.Play();
        }

        public void OutlineOff(float fadeOutDuration)
        {
            outlineOnTween?.Kill(true);
            outlineOffTween?.Kill(true);
            outlineOffTween = DOTween.Sequence();

            foreach (Material mat in effectRenderMaterials["Outline"])
            {
                Tweener matTween = mat.DOFloat(0.0f, "_Outline_Thickness", fadeOutDuration)
                    .SetEase(Ease.OutQuad);
                outlineOffTween.Join(matTween);
            }

            outlineOffTween.OnComplete(() => { activeEffectCount.Value--; });

            outlineOffTween.Play();
        }
    }

    #endregion
}