using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using DG.Tweening;

public class CustomRoleController : MonoBehaviour
{
    private Animator ani;
    private SkinnedMeshRenderer body;

    public Transform[] Chest;
    public Transform[] UpperArmUp;
    public Transform[] UpperArmDown;
    public Transform[] UpperLegUp;
    public Transform[] UpperLegDown;
    public Transform[] LowerLegUp;
    public Transform[] LowerLegDown;

    private void Start()
    {
        ani = GetComponent<Animator>();
        body = GetComponentInChildren<SkinnedMeshRenderer>();
        var t1 = ani.GetBoneTransform(HumanBodyBones.LeftHand);
        var t2 = ani.GetBoneTransform(HumanBodyBones.LeftFoot);
    }

    private void Update()
    {
        UpdatePos();
    }

    private void UpdatePos()
    {
        var t = body.bounds.min;
        var offset = t.y - (-1.36f);
        var y = transform.position.y - offset;
        transform.SetPositionY(y * 0.2f + transform.position.y * 0.8f);
    }

    public void UpdateBoneScale(EditableBodyPart part,Vector3 scale,bool isKeep,float value)
    {
        CustomRoleUtility.UpdateBoneScale(ani, part,scale, isKeep, value);
    }

    public List<Transform> GetBonesTrans()
    {
        var bonesTrans = new List<Transform>();
        for (int i = 0; i < Enum.GetValues(typeof(HumanBodyBones)).Length - 1; i++)
        {
            var trans = ani.GetBoneTransform((HumanBodyBones)i);
            if (trans)
            {
                bonesTrans.Add(trans);
            }
        }

        return bonesTrans;
    }

    public void GetNormalAniBonesScale(ref Dictionary<string, Vector3> boneDic)
    {
        CustomRoleUtility.GetNormalAniBonesScale(ani,ref boneDic);
    }

    private Transform[] GetExtraAniBonesTrans(EditableBodyPart extraPart)
    {
        Transform[] targetTrans = null;
        switch (extraPart)
        {
            case EditableBodyPart.Chest:
                targetTrans = Chest;
                break;
            case EditableBodyPart.UpperArmUp:
                targetTrans = UpperArmUp;
                break;
            case EditableBodyPart.UpperArmDown:
                targetTrans = UpperArmDown;
                break;
            case EditableBodyPart.UpperLegUp:
                targetTrans = UpperLegUp;
                break;
            case EditableBodyPart.UpperLegDown:
                targetTrans = UpperLegDown;
                break;
            case EditableBodyPart.LowerLegUp:
                targetTrans = LowerLegUp;
                break;
            case EditableBodyPart.LowerLegDown:
                targetTrans = LowerLegDown;
                break;
            default:
                break;
        }
        return targetTrans;
    }

    public void GetExtraAniBonesScale(ref Dictionary<string, Vector3> boneDic,EditableBodyPart extraPart)
    {
        Transform[] targetTrans = GetExtraAniBonesTrans(extraPart);

        if(targetTrans != null)
        {
            for (int i = 0; i < targetTrans.Length; i++)
            {
                boneDic.Add(targetTrans[i].name, targetTrans[i].lossyScale);
            }
        }
    }

    public void GetExtraAniBonesRotate(ref Dictionary<string, Quaternion> boneDic, EditableBodyPart extraPart)
    {
        Transform[] targetTrans = GetExtraAniBonesTrans(extraPart);

        if (targetTrans != null)
        {
            for (int i = 0; i < targetTrans.Length; i++)
            {
                boneDic.Add(targetTrans[i].name, targetTrans[i].localRotation);
            }
        }
    }

    public void GetExtraAniBonesPosition(ref Dictionary<string, Vector3> boneDic, EditableBodyPart extraPart)
    {
        Transform[] targetTrans = GetExtraAniBonesTrans(extraPart);

        if (targetTrans != null)
        {
            for (int i = 0; i < targetTrans.Length; i++)
            {
                boneDic.Add(targetTrans[i].name, targetTrans[i].localPosition);
            }
        }
    }

    public void SetBonePos(string name,Vector3 value)
    {
        var bone = CustomRoleUtility.GetChild(transform,name);
        if(bone)
        {
            bone.transform.localPosition = value;
        }
    }

    public void SetBoneRot(string name, Quaternion value)
    {
        var bone = CustomRoleUtility.GetChild(transform, name);
        if (bone)
        {
            bone.transform.localRotation = value;
        }
    }

    public void SetBoneWorldScale(string name, Vector3 scale,Vector3 orginLocalScale,Vector3 orginWorldScale)
    {
        var bone = CustomRoleUtility.GetChild(transform, name);
        if (bone)
        {
            var value = scale.x;
            var trans = bone.transform;
            var beforeScale = trans.localScale;
            var world_l = orginWorldScale;
            trans.SetLocalScaleX(orginLocalScale.x * scale.x / world_l.x);
            trans.SetLocalScaleY(orginLocalScale.y * scale.y / world_l.y);
            trans.SetLocalScaleZ(orginLocalScale.z * scale.z / world_l.z);
            return;
            var lcount = trans.childCount;
            for (int j = 0; j < lcount; j++)
            {
                var childTrans = trans.GetChild(j);
                var oldScale = childTrans.localScale;
                childTrans.SetLocalScaleX(oldScale.x * beforeScale.x / scale.x);
                childTrans.SetLocalScaleY(oldScale.y * beforeScale.y / scale.y);
                childTrans.SetLocalScaleZ(oldScale.z * beforeScale.z / scale.z);
            }
        }
    }

    public void SetBoneScale(string name, Vector3 scale)
    {
        var bone = CustomRoleUtility.GetChild(transform, name);
        if (bone)
        {
            bone.transform.localScale = scale;
        }
    }

    public void SetBlendShape(string name,float value)
    {
        if (!body)
        {
            Debug.LogError(name + "不存在 SkinnedMeshRenderer");
            return;
        }
        if(name == "no")
        {
            Debug.LogError("表里还没配，快去改表吧！");
            return;
        }
        var index = body.sharedMesh.GetBlendShapeIndex(name);
        if(index < 0)
        {
            Debug.LogError(name + "不存在名称为 " + name + "变形器");
            return;
        }
        SetBlendShape(index, value);
    }

    public void SetBlendShape(int index,float value)
    {
        if(!body)
        {
            Debug.LogError(name + "不存在 SkinnedMeshRenderer");
            return;
        }
        body.SetBlendShapeWeight(index, value);
    }
    /// <summary>
    /// 重置所有变形器
    /// </summary>
    public void ResetAllBlendShape()
    {
        if (!body)
        {
            Debug.LogError(name + "不存在 SkinnedMeshRenderer");
            return;
        }
        var count = body.sharedMesh.blendShapeCount;
        for (int i = 0; i < count; i++)
        {
            SetBlendShape(i, 0);
        }
    }

    public void RotateSelf(float offset)
    {
        transform.Rotate(0, -offset/10, 0);
    }
}