using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Xml.Serialization;
using DG.Tweening;
using Newtonsoft.Json;
using Spine.Unity;
using TowerClimberChronicles;
using Unity.VisualScripting;
using UnityEngine;

public class CreatFlower : MonoBehaviour
{
    // Start is called before the first frame update
    public Camera orthoCamera;
    public static CreatFlower instance;

    public List<GameObject> temp_slot_gameobject_list;//固定的暂存位置点位信息
    public List<GameObject> flower_slot_gameobject_list_0;
    public List<GameObject> flower_slot_gameobject_list_1;
    public List<GameObject> flower_slot_gameobject_list_2;
    public List<GameObject> flower_slot_gameobject_list_3;
    public List<GameObject> pot_object_list;
    public List<SpriteRenderer> pot_object_type_image;
    public List<SkeletonAnimation> pot_animation_list;
    public SkeletonAnimation clean_animation;
    public SkeletonAnimation refresh_animation;
    public List<GameObject> branch_list;
    public GameObject clean_pos_object;

    public List<GameObject> gray_pot_list;
    public List<GameObject> normal_branch_list;

    private List<GameObject> temp_slot_item_list = new List<GameObject>()
    {
        null,null,null,null,null
    };//暂存区的实例化的花
    public List<GameObject> clean_item_list = new List<GameObject>();//使用道具后的item
    private List<GameObject> flower_slot_list0 = new List<GameObject>();
    private List<GameObject> flower_slot_list1 = new List<GameObject>();
    private List<GameObject> flower_slot_list2 = new List<GameObject>();
    private List<GameObject> flower_slot_list3 = new List<GameObject>();
    // private List<GameObject> all_flower_list = new List<GameObject>();//所有还没被销毁的花


    public List<int> slot_type_list = new List<int>() { -1, -1, -1, -1 };

    private List<GameObject> bubble_prefab_list = new List<GameObject>();

    private List<Sprite> flower_image_list = new List<Sprite>();
    private List<Sprite> pot_image_list = new List<Sprite>();
    private List<GameObject> all_flower_in_pool_list = new List<GameObject>();//所有没被点击过的花;



    public bool CanClick = true;
    private GameObject top_area;

    // public bool slot_0_open = false;
    // public bool slot_1_open = false;
    private void Awake()
    {
        instance = this;

        // for (int i = 0; i < 16; i++)
        // {
        //     img_list.Add(Resources.Load<Sprite>("card/card_sprite/" + i));
        // }

        orthoCamera = GameObject.Find("GameCamera").GetComponent<Camera>();

        float size = (float)System.Math.Round(28.125f / ((float)Screen.width / Screen.height), 4);
        string type = SystemInfo.deviceModel.ToLower().Trim();
        // //////Debug.Log($"type==========={type}");
        if (type.Substring(0, 3) == "ipa")
        {//iPad机型
            size = 49.9f;
        }

        orthoCamera.orthographicSize = size;
        GameObject target = GameObject.Find("qiang");
        top_area = GameObject.Find("top_area");
        FitObjectToScreenWidth(target, orthoCamera);
        AlignObjectBottom(target, orthoCamera);
        AlignObjectTop(top_area, orthoCamera);
        for (int i = 1; i < 6; i++)
        {
            bubble_prefab_list.Add(Resources.Load<GameObject>("flower/item/item_" + i));
        }
        for (int i = 1; i < 13; i++)
        {
            flower_image_list.Add(Resources.Load<Sprite>("flower/image/" + i + "_b"));
            pot_image_list.Add(Resources.Load<Sprite>("flower/image/" + i + "_a"));
        }
        for (int i = 0; i < pot_animation_list.Count; i++)
        {
            pot_animation_list[i].gameObject.SetActive(false);
        }
        clean_animation.gameObject.SetActive(false);
        refresh_animation.gameObject.SetActive(false);
        // GameDispatcher.Instance.AddListener(GameMsg.FlowerEnd, ResetGame);
        GameDispatcher.Instance.AddListener(GameMsg.FlowerReset, ResetGame);
    }

    private GameObject Popup;
    // Update is called once per frame
    void Update()
    {
        if (Input.GetMouseButtonDown(0))
        {
            if (!CanClick) return;
            if (Popup == null) Popup = GameObject.Find("Popup");
            if (Popup.transform.childCount != 0) return;



            int layerMask = 1 << 7;
            // 如果射线与layerMask指定层的碰撞器发生碰撞
            Ray ray = orthoCamera.ScreenPointToRay(Input.mousePosition);
            RaycastHit2D hit = Physics2D.Raycast(ray.origin, ray.direction, Mathf.Infinity, layerMask);
            if (hit.collider != null)
            {
                if (hit.collider.CompareTag("flower_mask"))
                {
                    // 命中遮罩，不响应
                    return;
                }
                ChildItem child = hit.collider.GetComponent<ChildItem>();
                if (child != null) child.OnChildClicked();
            }

            else
            {
                // //////Debug.Log("No hit");
            }
        }
        if (show_finger)
        {
            finger_object.transform.rotation = Quaternion.identity;
        }
    }
    public void ResetGame(object a = null)
    {

        for (int i = bubble_parent.transform.childCount - 1; i >= 0; i--)
        {
            Destroy(bubble_parent.transform.GetChild(i).gameObject);
        }
        all_flower_in_pool_list.Clear();
        for (int i = 0; i < temp_slot_item_list.Count; i++)
        {
            if (temp_slot_item_list[i] != null) Destroy(temp_slot_item_list[i]);
        }
        for (int i = 0; i < clean_item_list.Count; i++)
        {
            Destroy(clean_item_list[i]);
        }
        clean_item_list.Clear();
        for (int i = 0; i < flower_slot_list0.Count; i++)
        {
            Destroy(flower_slot_list0[i]);
        }
        flower_slot_list0.Clear();
        for (int i = 0; i < flower_slot_list1.Count; i++)
        {
            Destroy(flower_slot_list1[i]);
        }
        flower_slot_list1.Clear();
        for (int i = 0; i < flower_slot_list2.Count; i++)
        {
            Destroy(flower_slot_list2[i]);
        }
        flower_slot_list2.Clear();
        for (int i = 0; i < flower_slot_list3.Count; i++)
        {
            Destroy(flower_slot_list3[i]);
        }
        flower_slot_list3.Clear();
        for (int i = 0; i < pot_object_list.Count; i++)
        {
            pot_object_list[i].SetActive(true);
        }
        for (int i = 0; i < pot_animation_list.Count; i++)
        {
            pot_animation_list[i].gameObject.SetActive(false);
        }

        GameDispatcher.Instance.Dispatch(GameMsg.RefreshFlowerCleanBtn);
        clean_item_list.Clear();
        all_flower_in_pool_list.Clear();
        slot_type_list = new List<int>() { -1, -1, -1, -1 };
        CanClick = true;
        DataMgr.FlowerLevelState.Value = 3;
        for (int i = 0; i < pot_object_list.Count; i++)
        {
            pot_object_list[i].transform.localScale = Vector3.one;
        }
        for (int i = 0; i < branch_list.Count; i++)
        {
            SpriteRenderer sr = branch_list[i].GetComponent<SpriteRenderer>();
            Color c = sr.color;
            c.a = 1f;   // 设置透明度为 1（完全不透明）
            sr.color = c;
        }
        CreatFlowerItem();
    }

    public Transform AddFlowerInTemp(GameObject obj, int type)
    {
        FlowerUI.start_update = true;
        if (FlowerUI.Stop_time >= 5)
        {
            GameDispatcher.Instance.Dispatch(GameMsg.FlowerHideclickAni);
        }
        FlowerUI.Stop_time = 0;
        all_flower_in_pool_list.Remove(obj);
        List<int> indices = new List<int>();
        for (int i = 0; i < slot_type_list.Count; i++)
        {
            if (slot_type_list[i] == type)
            {
                indices.Add(i);
            }
        }
        int index = -1;
        int in_slot_numbers = -1;
        if (indices.Count == 1)
        {
            index = indices[0];
        }
        else if (indices.Count > 1)
        {
            for (int i = 0; i < indices.Count; i++)
            {
                int index_numbres = 0;
                if (indices[i] == 0)
                {
                    index_numbres = flower_slot_list0.Count;
                }
                else if (indices[i] == 1)
                {
                    index_numbres = flower_slot_list1.Count;
                }
                else if (indices[i] == 2)
                {
                    index_numbres = flower_slot_list2.Count;
                }
                else if (indices[i] == 3)
                {
                    index_numbres = flower_slot_list3.Count;
                }
                if (index_numbres > in_slot_numbers)
                {
                    in_slot_numbers = index_numbres;
                    index = indices[i];
                }
            }
        }

        if (index >= 0)
        {
            if (index == 0 && flower_slot_list0.Count < 3)
            {
                flower_slot_list0.Add(obj);
                obj.GetComponent<SpriteRenderer>().sortingOrder = flower_slot_list0.Count;
                return flower_slot_gameobject_list_0[flower_slot_list0.Count - 1].transform;
            }
            else if (index == 1 && flower_slot_list1.Count < 3)
            {
                flower_slot_list1.Add(obj);
                obj.GetComponent<SpriteRenderer>().sortingOrder = flower_slot_list1.Count;
                return flower_slot_gameobject_list_1[flower_slot_list1.Count - 1].transform;
            }
            else if (index == 2 && flower_slot_list2.Count < 3)
            {
                flower_slot_list2.Add(obj);
                obj.GetComponent<SpriteRenderer>().sortingOrder = flower_slot_list2.Count;
                return flower_slot_gameobject_list_2[flower_slot_list2.Count - 1].transform;
            }
            else if (index == 3 && flower_slot_list3.Count < 3)
            {
                flower_slot_list3.Add(obj);
                obj.GetComponent<SpriteRenderer>().sortingOrder = flower_slot_list3.Count;
                return flower_slot_gameobject_list_3[flower_slot_list3.Count - 1].transform;
            }
        }

        int temp_numbers = 0;
        Transform transform_ = null;

        for (int i = 0; i < 5; i++)
        {
            if (temp_slot_item_list[i] == null)
            {

                transform_ = temp_slot_gameobject_list[i].transform;
                temp_slot_item_list[i] = obj;
                break;
            }
        }
        for (int i = 0; i < 5; i++)
        {
            if (temp_slot_item_list[i] != null)
            {
                temp_numbers++;
            }
        }
        if (temp_numbers >= 4)
        {

            bool next_have = false;
            for (int i = 0; i < temp_slot_item_list.Count; i++)
            {
                if (temp_slot_item_list[i] != null)
                {
                    //if ((index >= 0) && ((temp_slot_item_list[i].GetComponent<ChildItem>().type == next_type_list[index])))
                    if (next_type_list.Contains(temp_slot_item_list[i].GetComponent<ChildItem>().type) || slot_type_list.Contains(temp_slot_item_list[i].GetComponent<ChildItem>().type))
                    {
                        next_have = true;
                        break;
                    }
                }
            }
            if (temp_numbers >= 5)
            {
                CanClick = false;
                if (!next_have)
                {
                    if (DataMgr.FlowerLevelState.Value != 0)
                    {
                        UICtrlDispatcher.Instance.Dispatch(UICtrlMsg.FlowerRemakeUI_Open);
                        FlowerUI.start_update = false;
                    }
                    else
                    {
                        float[] ch_array = GameHelper.GetRewardValue(2);
                        var temp = new SuccessData();
                        temp.IsWin = false;
                        temp.ch_number = ch_array[0];
                        temp.IsLevelSuccess = true;
                        temp.IsH5Reward = false;
                        temp.boost_array = GameHelper.GetRewardBoost(2);
                        temp.level = DataMgr.FlowerLevel.Value;
                        UICtrlDispatcher.Instance.Dispatch(UICtrlMsg.FlowerEndUI_Open, temp);
                    }
                }
            }

            if (temp_numbers == 4)
            {
                if (!next_have)
                {
                    GameDispatcher.Instance.Dispatch(GameMsg.FlowerFullTips);
                }
            }
            //////Debug.Log("满了");
        }

        if (transform_ != null) return transform_;
        return null;

    }
    private int clear_pot_num;
    private int all_pot_num;
    private List<int> next_type_list = new List<int>()
    {
        -1,-1,-1,-1
    };

    public void CheckPot()
    {
        for (int i = 0; i < 4; i++)
        {
            int index = i;
            List<GameObject> slot_list = null;
            if (index == 0) slot_list = flower_slot_list0;
            else if (index == 1) slot_list = flower_slot_list1;
            else if (index == 2) slot_list = flower_slot_list2;
            else if (index == 3) slot_list = flower_slot_list3;

            if (slot_list.Count >= 3)
            {
                int old_type = slot_type_list[index];
                slot_type_list[index] = -1;
                next_type_list[index] = CreatPotType();
                //   CanClick = false;
                DOVirtual.DelayedCall(0.5f, () =>
                {
                    for (int j = 0; j < 3; j++)
                    {
                        slot_list[j].GetComponent<SpriteRenderer>().DOFade(0f, 0.3f);
                    }
                    branch_list[index].GetComponent<SpriteRenderer>().DOFade(0f, 0.3f);

                });

                DOVirtual.DelayedCall(0.9f, () =>
                {
                    int ani_type = old_type + 1;
                    string ani_name;
                    if (ani_type < 10) ani_name = "0" + ani_type;
                    else ani_name = ani_type.ToString();
                    pot_animation_list[index].gameObject.SetActive(true);
                    pot_animation_list[index].state.SetAnimation(0, "hua_" + ani_name, false);
                    pot_animation_list[index].state.Complete += (trackEntry) =>
                    {

                        pot_object_list[index].transform.DOScale(new Vector3(0f, 0f, 0f), 0.3f).OnComplete(() =>
                        {
                            //////Debug.Log("缩放完成！");
                            pot_animation_list[index].gameObject.SetActive(false);
                            if (next_type_list[index] >= 0) branch_list[index].GetComponent<SpriteRenderer>().sprite = pot_image_list[next_type_list[index]];
                        });
                    };
                });
                DOVirtual.DelayedCall(1, () =>
                {



                    for (int j = 0; j < 3; j++)
                    {
                        // all_flower_list.Remove(slot_list[j]);
                        GameObject.Destroy(slot_list[j]);
                    }
                    slot_list.Clear();
                    clear_pot_num += 3;
                    //  CanClick = true;

                    // //////Debug.Log("新创建的类型是：" + ne);
                    //  pot_object_list[index].SetActive(false);



                    DOVirtual.DelayedCall(1.3f, () =>
                     {
                         //////Debug.Log($"slot_type_list[{index}] = {next_type_list[index]}");
                         slot_type_list[index] = next_type_list[index];
                         CheckNewPot(index);
                     });
                });

            }

        }


        if (all_flower_in_pool_list.Count == 0)
        {
            // bool temp_null = true;
            // for (int j = 0; j < temp_slot_item_list.Count; j++)
            // {
            //     if (temp_slot_item_list[j] != null)
            //     {
            //         temp_null = false;
            //         break;
            //     }
            // }
            // if (temp_null)
            // {
            //////Debug.Log("游戏结束");
            GameDispatcher.Instance.Dispatch(GameMsg.FlowelSuccess);
            //  }

        }
    }
    // private int next_type = -1;
    void CheckNewPot(int index)
    {
        if (slot_type_list[index] >= 0)
        {
            List<GameObject> slot_list = null;
            if (index == 0) slot_list = flower_slot_list0;
            else if (index == 1) slot_list = flower_slot_list1;
            else if (index == 2) slot_list = flower_slot_list2;
            else if (index == 3) slot_list = flower_slot_list3;
            //  pot_object_list[index].SetActive(true);
            if (slot_type_list[index] >= 0)
            {
                pot_object_type_image[index].sprite = flower_image_list[slot_type_list[index]];
            }
            branch_list[index].GetComponent<SpriteRenderer>().DOFade(1f, 0.1f);
            pot_object_list[index].transform.DOScale(new Vector3(1f, 1f, 1f), 0.3f).OnComplete(() =>
            {
                //////Debug.Log("放大完成！");
            });
            bool have_temp_ = false;
            for (int k = 0; k < temp_slot_item_list.Count; k++)
            {

                if (temp_slot_item_list[k] != null)
                {
                    ChildItem ChildItem_ = temp_slot_item_list[k].GetComponent<ChildItem>();
                    if (slot_type_list[index] == ChildItem_.type)
                    {
                        if (slot_list.Count < 3)
                        {
                            slot_list.Add(temp_slot_item_list[k]);

                            List<GameObject> target_list = null;
                            if (index == 0) target_list = flower_slot_gameobject_list_0;
                            else if (index == 1) target_list = flower_slot_gameobject_list_1;
                            else if (index == 2) target_list = flower_slot_gameobject_list_2;
                            else if (index == 3) target_list = flower_slot_gameobject_list_3;


                            ChildItem_.SetParentAndFly(top_area.transform, target_list[slot_list.Count - 1].transform, 0.5f);
                            temp_slot_item_list[k].GetComponent<SpriteRenderer>().sortingOrder = slot_list.Count;
                            temp_slot_item_list[k] = null;
                            have_temp_ = true;
                            CanClick = true;
                            //////Debug.Log("有相同的！！！！！！！！！！！！！");
                        }
                    }
                }
            }
            if (slot_list.Count < 3)
            {
                for (int n = 0; n < clean_item_list.Count; n++)
                {
                    ChildItem ChildItem_ = clean_item_list[n].GetComponent<ChildItem>();
                    if (ChildItem_.type == slot_type_list[index])
                    {
                        if (slot_list.Count >= 3) break;
                        slot_list.Add(clean_item_list[n]);
                        List<GameObject> target_list = null;
                        if (index == 0) target_list = flower_slot_gameobject_list_0;
                        else if (index == 1) target_list = flower_slot_gameobject_list_1;
                        else if (index == 2) target_list = flower_slot_gameobject_list_2;
                        else if (index == 3) target_list = flower_slot_gameobject_list_3;
                        ChildItem_.SetParentAndFly(top_area.transform, target_list[slot_list.Count - 1].transform, 0.5f);
                        clean_item_list[n].GetComponent<SpriteRenderer>().sortingOrder = slot_list.Count;
                        SpriteRenderer render = clean_item_list[n].GetComponent<SpriteRenderer>();

                        Color c = render.color;
                        c.a = 1f;
                        render.color = c;
                        render.sortingOrder = slot_list.Count;
                        clean_item_list[n] = null;
                        have_temp_ = true;
                    }
                }
                clean_item_list.RemoveAll(item => item == null);
                GameDispatcher.Instance.Dispatch(GameMsg.RefreshFlowerCleanBtn);
            }

            //////Debug.Log("再次调用检测方法");
            if (have_temp_)
            {
                DOVirtual.DelayedCall(0.3f, () =>
                {
                    CheckPot();
                });
            }

        }
    }


    public GameObject bubble_parent;
    private FlowerMatch flowerMatch;
    float creatPotAccuracy;//生成的花盆可以直接被消除的概率

    public void AddSlost(int index)
    {
        //////Debug.Log("解锁。。。。。。。。。。" + index);
        if (index == 0)
        {

            gray_pot_list[0].SetActive(false);
            normal_branch_list[0].SetActive(true);
            slot_type_list[2] = CreatPotType();
            if (slot_type_list[2] >= 0)
            {
                pot_object_type_image[2].sprite = flower_image_list[slot_type_list[2]];
                CheckNewPot(2);
            }
            else
            {
                pot_object_list[2].transform.DOScale(new Vector3(0f, 0f, 0f), 0.3f);
            }

        }
        else if (index == 1)
        {
            gray_pot_list[1].SetActive(false);
            normal_branch_list[1].SetActive(true);
            slot_type_list[3] = CreatPotType();
            if (slot_type_list[3] >= 0)
            {
                pot_object_type_image[3].sprite = flower_image_list[slot_type_list[3]];
                CheckNewPot(3);
            }
            else
            {
                pot_object_list[3].transform.DOScale(new Vector3(0f, 0f, 0f), 0.3f);
            }
        }
        //  CheckPot();
    }
    public void UseTipsItem()
    {
        List<int> canremove_numbers = new List<int>() { 0, 0, 0, 0 };
        List<GameObject> canremove_obj = new List<GameObject>();
        CanClick = false;

        for (int i = 0; i < all_flower_in_pool_list.Count; i++)
        {
            if (all_flower_in_pool_list[i].transform.position.y < (temp_slot_gameobject_list[0].transform.position.y))//视为可以点击的
            {
                int item_type = all_flower_in_pool_list[i].GetComponent<ChildItem>().type;
                for (int j = 0; j < 4; j++)
                {
                    if (slot_type_list[j] == item_type)
                    {
                        canremove_obj.Add(all_flower_in_pool_list[i]);
                        canremove_numbers[j]++;
                        break;
                    }
                }
            }
        }
        canremove_obj.Sort((a, b) => a.transform.position.y.CompareTo(b.transform.position.y));

        List<int> can_remove_index_array = new List<int>();
        for (int i = 0; i < canremove_numbers.Count; i++)
        {
            if (canremove_numbers[i] >= 3)
            {
                can_remove_index_array.Add(i);//0，1，2，3
            }
        }

        int random_index = -1;

        if (can_remove_index_array.Count > 0)
        {
            random_index = can_remove_index_array[UnityEngine.Random.Range(0, can_remove_index_array.Count)];
        }

        if (random_index >= 0)
        {
            int tips_type = slot_type_list[random_index];
            List<GameObject> slot_list = null;
            if (random_index == 0) slot_list = flower_slot_list0;
            else if (random_index == 1) slot_list = flower_slot_list1;
            else if (random_index == 2) slot_list = flower_slot_list2;
            else if (random_index == 3) slot_list = flower_slot_list3;
            int slot_count = slot_list.Count;
            for (int i = 0; i < canremove_obj.Count; i++)
            {
                int item_type = canremove_obj[i].GetComponent<ChildItem>().type;
                if (item_type == tips_type)
                {
                    if (slot_count >= 3) break;
                    canremove_obj[i].GetComponent<ChildItem>().OnChildClicked();

                    slot_count++;
                }
            }
            CheckPot();
            DataMgr.FlowerItem0.Value = DataMgr.FlowerItem0.Value - 1;
            GameHelper.ShowTips("Randomly clear a target flower");
        }
        else
        {
            GameHelper.ShowTips("There are no flowers to remove");
        }
        DOVirtual.DelayedCall(0.5f, () =>
        {
            CanClick = true;
        });
        //////Debug.Log(JsonConvert.SerializeObject(canremove_numbers));

    }
    public void UseCleanItem()
    {
        bool is_null = true;
        CanClick = false;
        for (int i = 0; i < temp_slot_item_list.Count; i++)
        {
            if (temp_slot_item_list[i] != null)
            {
                is_null = false;
                break;
            }

        }
        if (is_null)
        {
            GameHelper.ShowTips("There are no flowers to clean");
            CanClick = true;
            return;
        }
        clean_animation.gameObject.SetActive(true);
        clean_animation.state.SetAnimation(0, "animation", false);
        clean_animation.state.Complete += (trackEntry) =>
         {
             clean_animation.gameObject.SetActive(false);
         };
        for (int i = 0; i < temp_slot_item_list.Count; i++)
        {
            if (temp_slot_item_list[i] != null)
            {
                clean_item_list.Add(temp_slot_item_list[i]);
                GameObject temp = temp_slot_item_list[i];
                DOVirtual.DelayedCall(1 - 0.1f * i, () =>
                {
                    temp.GetComponent<SpriteRenderer>().DOFade(0f, 0.1f);
                });
            }
            temp_slot_item_list[i] = null;
        }
        DOVirtual.DelayedCall(1, () =>
        {
            for (int i = 0; i < clean_item_list.Count; i++)
            {
                clean_item_list[i].transform.position = clean_pos_object.transform.position;
            }
            CanClick = true;
        });
        GameDispatcher.Instance.Dispatch(GameMsg.RefreshFlowerCleanBtn);
        DataMgr.FlowerItem1.Value = DataMgr.FlowerItem1.Value - 1;

    }
    public void UseRefreshItem()
    {
        CanClick = false;
        refresh_animation.gameObject.SetActive(true);
        refresh_animation.state.SetAnimation(0, "animation", false);
        refresh_animation.state.Complete += (trackEntry) =>
        {
            refresh_animation.gameObject.SetActive(false);
        };
        FlyIntoCircle(all_flower_in_pool_list, refresh_animation.gameObject.transform.position, 4, 0.3f);
    }

    public void FlyIntoCircle(List<GameObject> objs, Vector3 center, float radius, float duration)
    {
        if (objs == null || objs.Count == 0) return;

        int count = objs.Count;

        for (int i = 0; i < count; i++)
        {
            GameObject obj = objs[i];
            if (obj == null) continue;

            // 记录初始 localPosition
            Vector3 startLocalPos = obj.transform.localPosition;

            // 找到父物体上的 Rigidbody2D
            Rigidbody2D rb2d = obj.transform.parent != null ? obj.transform.parent.GetComponent<Rigidbody2D>() : null;
            if (rb2d != null && rb2d.simulated)
            {
                rb2d.simulated = false;
            }

            // 随机角度
            float angle = UnityEngine.Random.Range(0f, Mathf.PI * 2f);

            // 半径用 sqrt(Random.value)，保证均匀分布在圆内
            float r = radius * Mathf.Sqrt(UnityEngine.Random.value);

            // 目标位置：圆心 + 半径 * (cos, sin)
            Vector3 targetPos = center + new Vector3(Mathf.Cos(angle), Mathf.Sin(angle), 0) * r;

            // DOTween 移动到目标点位
            obj.transform.DOMove(targetPos, duration).SetEase(Ease.OutQuad)
                .OnComplete(() =>
                {
                    // 停留 0.1 秒后再返回
                    DOVirtual.DelayedCall(0.3f, () =>
                    {
                        // 在返回之前打乱 type 和 sprite
                        ShuffleItems(objs);
                        CanClick = true;
                        obj.transform.DOLocalMove(startLocalPos, duration).SetEase(Ease.InQuad)
                            .OnComplete(() =>
                            {
                                if (rb2d != null && !rb2d.simulated)
                                {
                                    rb2d.simulated = true;
                                }
                            });
                    });
                });
        }
    }


    void ShuffleItems(List<GameObject> objs)
    {
        // 收集所有 (type, sprite) 对
        List<(int type, Sprite sprite)> pairs = new List<(int, Sprite)>();

        foreach (var obj in objs)
        {
            if (obj == null) continue;
            ChildItem item = obj.GetComponent<ChildItem>();
            SpriteRenderer sr = obj.GetComponent<SpriteRenderer>();
            if (item != null && sr != null)
            {
                pairs.Add((item.type, sr.sprite));
            }
        }

        // 打乱 pairs 列表
        System.Random rand = new System.Random();
        pairs = pairs.OrderBy(x => rand.Next()).ToList();

        // 重新分配，保持对应关系
        int index = 0;
        foreach (var obj in objs)
        {
            if (obj == null) continue;
            ChildItem item = obj.GetComponent<ChildItem>();
            SpriteRenderer sr = obj.GetComponent<SpriteRenderer>();
            if (item != null && sr != null)
            {
                item.type = pairs[index].type;
                sr.sprite = pairs[index].sprite;
                index++;
            }
        }
    }








    public int CreatPotType()
    {
        float[] Difficulty_array = flowerMatch.Difficulty;
        if (((float)clear_pot_num) / all_pot_num > Difficulty_array[1])
        {
            creatPotAccuracy = flowerMatch.Accuracy[2];
        }
        else if (((float)clear_pot_num) / all_pot_num > Difficulty_array[0])
        {
            creatPotAccuracy = flowerMatch.Accuracy[1];
        }
        else
        {
            creatPotAccuracy = flowerMatch.Accuracy[0];
        }
        Debug.Log("flower---------当前完成进度:" + (float)clear_pot_num / all_pot_num);
        Debug.Log("flower---------当前击中率:" + creatPotAccuracy);
        List<int> canremove_numbers = new List<int>();
        List<int> all_numbers = new List<int>();
        for (int i = 0; i < all_flower_in_pool_list.Count; i++)
        {
            if (all_flower_in_pool_list[i].transform.position.y < (temp_slot_gameobject_list[0].transform.position.y))//视为可以点击的
            {
                canremove_numbers.Add(all_flower_in_pool_list[i].GetComponent<ChildItem>().type);
            }
            all_numbers.Add(all_flower_in_pool_list[i].GetComponent<ChildItem>().type);
        }

        for (int i = 0; i < temp_slot_item_list.Count; i++)
        {
            if (temp_slot_item_list[i] != null)
            {
                canremove_numbers.Add(temp_slot_item_list[i].GetComponent<ChildItem>().type);
                all_numbers.Add(temp_slot_item_list[i].GetComponent<ChildItem>().type);
            }
        }
        for (int i = 0; i < clean_item_list.Count; i++)
        {
            canremove_numbers.Add(clean_item_list[i].GetComponent<ChildItem>().type);
            all_numbers.Add(clean_item_list[i].GetComponent<ChildItem>().type);
        }

        IEnumerable<IGrouping<int, int>> grouped_all_number = all_numbers.GroupBy(x => x);
        List<int> result_pot = new List<int>();
        foreach (IGrouping<int, int> g in grouped_all_number)
        {
            int newCount = g.Count() / 3; // 出现次数除以3
            for (int i = 0; i < newCount; i++)
            {
                result_pot.Add(g.Key);
            }
        }
        for (int i = 0; i < slot_type_list.Count; i++)
        {
            result_pot.Remove(slot_type_list[i]);
        }
        for (int i = 0; i < next_type_list.Count; i++)
        {
            result_pot.Remove(next_type_list[i]);
        }

        IEnumerable<IGrouping<int, int>> grouped = canremove_numbers.GroupBy(x => x);

        System.Random rand = new System.Random();

        int randomMore = -1;
        IEnumerable<IGrouping<int, int>> moreThanThreeGroups = grouped.Where(g => g.Count() >= 3);
        List<int> moreThanThreeKeys = moreThanThreeGroups.Select(g => g.Key).ToList();
        if (moreThanThreeKeys.Count > 0)
        {
            int index = rand.Next(moreThanThreeKeys.Count);
            randomMore = moreThanThreeKeys[index];
        }

        int randomLess = -1;
        IEnumerable<IGrouping<int, int>> lessThanThreeGroups = grouped.Where(g => g.Count() < 3);
        List<int> lessThanThreeKeys = lessThanThreeGroups.Select(g => g.Key).ToList();
        if (lessThanThreeKeys.Count > 0)
        {
            int index = rand.Next(lessThanThreeKeys.Count);
            randomLess = lessThanThreeKeys[index];
        }

        // Console.WriteLine("随机选取的 ≥3 元素: " + randomMore);
        // Console.WriteLine("随机选取的 <3 元素: " + randomLess);

        System.Random randdom_ = new System.Random();
        double value = randdom_.NextDouble();
        if (value < creatPotAccuracy)//生成可以消除的
        {
            if (result_pot.Count <= 0) return -1;
            Debug.Log("flower---------当前击中了");
            if (creatPotAccuracy < 0)//目前显示出的没有可以消除的了，随机一个出来
            {
                Debug.Log("flower---------当前没有可以消除的元素，随机一个");
                return result_pot[UnityEngine.Random.Range(0, result_pot.Count)];
            }
            if (result_pot.Contains(randomMore))
            {
                Debug.Log("flower---------当前有可以消除的元素，生成一个");
                return randomMore;
            }
            else
            {
                Debug.Log("flower---------当前没有可以消除的元素，随机一个");
                return result_pot[UnityEngine.Random.Range(0, result_pot.Count)];
            }
        }
        else
        {
            if (result_pot.Count <= 0) return -1;
            Debug.Log("flower---------当前没有击中");
            if (randomLess < 0)
            {
                Debug.Log("flower---------当前没有不能消除的元素，随机一个");
                return result_pot[UnityEngine.Random.Range(0, result_pot.Count)];
            }
            if (result_pot.Contains(randomLess))
            {
                Debug.Log("flower---------生成不能消除的元素");
                return randomLess;
            }
            else
            {
                Debug.Log("flower---------当前没有不能消除的元素，随机一个");
                return result_pot[UnityEngine.Random.Range(0, result_pot.Count)];
            }
        }

    }
    private bool show_finger = false;
    private GameObject finger_object;
    public void DestoryFinger()
    {
        show_finger = false;
        Destroy(finger_object);
    }
    public void CreatFlowerItem()
    {
        int level = DataMgr.FlowerLevel.Value;
        //////Debug.Log(ConfigSystem.GetConfig<FlowerMatch>()[level]);
        flowerMatch = ConfigSystem.GetConfig<FlowerMatch>()[level];

#if UNITY_EDITOR
        //  flowerMatch.ElementCount = 21;
#endif

        List<int> elements = Allocate(flowerMatch.ElementCount, 12, flowerMatch.ElementTypes);
        //////Debug.Log(JsonConvert.SerializeObject(elements));
        // 输出示例： [3, 7, 7, 5, 2, 2, 9, 9, 9, ...] 共 30 个
        // 每个数字代表种类编号，数量分布是两个 6、两个 9

        all_pot_num = flowerMatch.ElementCount;

        int[] counts = Allocate(flowerMatch.ElementCount, (float)flowerMatch.TypeDistribution / 100);
        //////Debug.Log(JsonConvert.SerializeObject(counts));

        // 1. 收集所有要生成的对象
        List<GameObject> toSpawn = new List<GameObject>();
        for (int i = 0; i < 5; i++)
        {
            for (int j = 0; j < counts[i]; j++)
            {
                toSpawn.Add(bubble_prefab_list[i]);
            }
        }

        // 2. 打乱顺序
        toSpawn = toSpawn.OrderBy(x => UnityEngine.Random.value).ToList();
        //////Debug.Log(JsonConvert.SerializeObject(slot_type_list) + "??????????????8");
        // 3. 按顺序生成并摆放
        Vector3 basePos = bubble_parent.transform.position;
        float xSpacing = 20f;
        float ySpacing = 20f;
        int maxPerRow = 3;
        int image_index = 0;
        for (int counter = 0; counter < toSpawn.Count; counter++)
        {
            int row = counter / maxPerRow;
            int col = counter % maxPerRow;

            Vector3 pos = basePos + new Vector3(col * xSpacing, row * ySpacing, 0);

            GameObject piece = Instantiate(toSpawn[counter], pos, Quaternion.identity, bubble_parent.transform);

            // 获取所有子物体的 SpriteRenderer（排除自己）
            SpriteRenderer[] childRenderers = piece.transform.Cast<Transform>() // 遍历直接子物体 
            .Select(t => t.GetComponent<SpriteRenderer>()) // 获取子物体上的 SpriteRenderer 
             .Where(r => r != null) // 过滤掉没有 SpriteRenderer 的 
              .ToArray();

            // 遍历使用
            for (int i = 0; i < childRenderers.Length; i++)
            {
                childRenderers[i].sprite = flower_image_list[elements[image_index]];
                all_flower_in_pool_list.Add(childRenderers[i].gameObject);

                // 获取对应子物体上的脚本
                ChildItem script = childRenderers[i].gameObject.GetComponent<ChildItem>();

                script.type = elements[image_index]; // 举例调用

                image_index++;
            }
            if (DataMgr.FlowerLevel.Value == 0 && counter == 0)
            {
                GameObject spinePrefab = Resources.Load<GameObject>("flower/effect/guide/guide");
                //////Debug.Log(piece.transform.Find("child_0"));
                finger_object = Instantiate(spinePrefab, piece.transform.Find("child_0").transform);
                finger_object.transform.rotation = Quaternion.identity;
                SkeletonAnimation skeletonAnimation = finger_object.transform.Find("ani_parent").GetComponent<SkeletonAnimation>();
                skeletonAnimation.state.SetAnimation(0, "animation", true);
                show_finger = true;
            }


            Rigidbody2D rb = piece.GetComponent<Rigidbody2D>();
            if (rb != null)
            {
                rb.angularVelocity = UnityEngine.Random.Range(-200f, 200f);
            }

        }
        slot_type_list[0] = CreatPotType();
        branch_list[0].GetComponent<SpriteRenderer>().sprite = pot_image_list[slot_type_list[0]];
        pot_object_type_image[0].sprite = flower_image_list[slot_type_list[0]];

        slot_type_list[1] = CreatPotType();

        if (slot_type_list[1] >= 0)
        {
            pot_object_type_image[1].sprite = flower_image_list[slot_type_list[1]];
            branch_list[1].GetComponent<SpriteRenderer>().sprite = pot_image_list[slot_type_list[1]];
        }


        gray_pot_list[0].SetActive(true);
        gray_pot_list[1].SetActive(true);

        normal_branch_list[0].SetActive(false);
        normal_branch_list[1].SetActive(false);
    }


    public static List<int> Allocate(int total, int kinds, int choose)
    {
        if (total % 3 != 0)
            throw new ArgumentException("总数必须是3的倍数");

        System.Random rand = new System.Random();

        // 随机选出指定数量的种类（范围 0..kinds-1）
        var chosen = Enumerable.Range(0, kinds)   // 改成从 0 开始
                               .OrderBy(_ => rand.Next())
                               .Take(choose)
                               .ToArray();
        //////Debug.Log("当前随机出的花的种类" + JsonConvert.SerializeObject(chosen));
        // 以3为单位来分配
        int units = total / 3;                // 总共多少个“单位”
        int basePerKind = units / choose;     // 每种基础单位数
        int remainderUnits = units % choose;  // 余下的单位数

        // 分配数量
        int[] counts = new int[choose];
        for (int i = 0; i < choose; i++) counts[i] = basePerKind * 3;
        for (int i = 0; i < remainderUnits; i++) counts[i] += 3;

        // 打乱分配顺序
        counts = counts.OrderBy(_ => rand.Next()).ToArray();

        // 展开成元素列表
        var result = new List<int>(total);
        for (int i = 0; i < choose; i++)
        {
            for (int j = 0; j < counts[i]; j++)
            {
                result.Add(chosen[i]);
            }
        }

        // 打乱元素顺序
        result = result.OrderBy(_ => rand.Next()).ToList();

        return result;
    }




    ////////////////////计算方法
    /// 

    // 返回各类型道具数量：[type1, type2, type3, type4, type5]
    // N：总元素数量（必须精确满足）
    // rBig：大道具占比目标（按“道具数量”定义）
    // ratioTolerance：容错范围（例如 0.05 表示 ±5%）

    public static int[] Allocate(int N, float rBig, float ratioTolerance = 0.05f, int maxIters = 10000)
    {
        if (N < 0) throw new ArgumentOutOfRangeException(nameof(N));
        if (rBig < 0f || rBig > 1f) throw new ArgumentOutOfRangeException(nameof(rBig));
        if (ratioTolerance < 0f || ratioTolerance > 1f) throw new ArgumentOutOfRangeException(nameof(ratioTolerance));

        // 容量: 1..5
        int[] caps = { 1, 2, 3, 4, 5 };
        // 小/大索引集合
        int[] smallIdx = { 0, 1, 2 };
        int[] bigIdx = { 3, 4 };

        // 1) 基于目标占比估算平均容量，估算总道具数 M
        float avgSmall = (1 + 2 + 3) / 3f;   // 2.0
        float avgBig = (4 + 5) / 2f;       // 4.5
        float avgCap = (1f - rBig) * avgSmall + rBig * avgBig;
        int M = Math.Max(1, (int)Math.Round(N / avgCap));

        // 2) 先按占比分道具数量，再组内平均
        int bigCount = (int)Math.Round(M * rBig);
        int smallCount = M - bigCount;

        int[] counts = new int[5];
        EvenSplitInto(counts, smallIdx, smallCount);
        EvenSplitInto(counts, bigIdx, bigCount);

        // 3) 容量校正：保证 sum(caps[i]*counts[i]) == N
        int S = TotalCapacity(counts, caps);

        // 贪心迭代：每次增加/减少一个道具，选择对“容量差”和“占比偏差”综合更优的类型
        for (int iter = 0; iter < maxIters && S != N; iter++)
        {
            int sumProps = counts.Sum();
            float currentBigRatio = sumProps > 0 ? (counts[3] + counts[4]) / (float)sumProps : 0f;
            float ratioError = Math.Abs(currentBigRatio - rBig);

            // 我们构造一个候选集合：当 S < N 需要增加一个道具；当 S > N 需要减少一个道具（数量必须 >0）
            bool needAdd = S < N;
            int diff = Math.Abs(N - S);

            // 评分函数：优先弥补容量差，同时尽量减小占比偏差
            // score 越小越好
            double bestScore = double.PositiveInfinity;
            int bestType = -1;

            for (int i = 0; i < 5; i++)
            {
                if (!needAdd && counts[i] == 0) continue; // 不能减到负数

                // 试探性变更
                int dProps = needAdd ? +1 : -1;
                int newSumProps = sumProps + dProps;
                if (newSumProps <= 0) continue;

                int newS = S + (needAdd ? +caps[i] : -caps[i]);

                // 新的大道具比例
                int newBigCount = counts[3] + counts[4];
                if (i == 3 || i == 4) newBigCount += needAdd ? 1 : -1;
                float newBigRatio = newBigCount / (float)newSumProps;

                // 容量误差与占比误差
                int newDiff = Math.Abs(N - newS);
                float newRatioError = Math.Abs(newBigRatio - rBig);

                // 打分：容量误差权重高，细微平衡占比误差
                // 你可以根据需要调整权重 wRatio 以强化/弱化占比优先级。
                const double wRatio = 0.5; // 越大越重视靠近占比
                double score = newDiff + wRatio * Math.Max(0f, newRatioError - ratioError);

                // 为了平滑地贴近 diff，也考虑容量步长的合适性（越接近 diff 越好）
                score += 0.01 * Math.Abs(caps[i] - diff);

                if (score < bestScore)
                {
                    bestScore = score;
                    bestType = i;
                }
            }

            if (bestType < 0)
                break; // 没有可行动作（理论上不应该发生），保护性退出

            // 应用最佳动作
            if (needAdd)
            {
                counts[bestType]++;
                S += caps[bestType];
            }
            else
            {
                counts[bestType]--;
                S -= caps[bestType];
            }
        }

        // 4) 若仍未达成精确容量（极少数边缘案例），回退到纯容量贪心补齐
        if (S != N)
        {
            // 简单补齐：优先用 5/4 增加或用 1/2 减少
            if (S < N)
            {
                S += GreedyCapacityFix(counts, caps, N - S, add: true);
            }
            else
            {
                S -= GreedyCapacityFix(counts, caps, S - N, add: false);
            }
        }

        // 5) 可选：如果你希望严格将大道具比例限制在 [rBig ± ratioTolerance] 范围，
        // 可以在此做一次微调，但必须保持 S == N（通过“等容量替换”实现）。
        // 示例策略：在小/大组内等容量交换（比如用一个3替代一个1+2），保证容量不变只改比例。
        // 为简洁，这里先不给出额外等容量替换；若需要，我可以加一个安全的交换器。

        return counts;
    }

    private static void EvenSplitInto(int[] counts, int[] indices, int total)
    {
        if (indices.Length == 0 || total <= 0) return;
        int q = total / indices.Length;
        int r = total % indices.Length;
        for (int i = 0; i < indices.Length; i++) counts[indices[i]] += q;
        for (int i = 0; i < r; i++) counts[indices[i]] += 1; // 轮询余数
    }

    private static int TotalCapacity(int[] counts, int[] caps)
    {
        int sum = 0;
        for (int i = 0; i < counts.Length; i++) sum += counts[i] * caps[i];
        return sum;
    }

    // 只考虑容量差的贪心修正（作为兜底）
    private static int GreedyCapacityFix(int[] counts, int[] caps, int diff, bool add)
    {
        int changed = 0;
        if (add)
        {
            // 优先用高容量填补
            for (int i = caps.Length - 1; i >= 0 && changed < diff; i--)
            {
                int step = caps[i];
                int canDo = (diff - changed) / step;
                if (canDo <= 0) continue;
                counts[i] += canDo;
                changed += canDo * step;
            }
            // 若仍有剩余，用最小步长补到位
            for (int i = caps.Length - 1; i >= 0 && changed < diff; i--)
            {
                counts[i] += 1;
                changed += caps[i];
            }
        }
        else
        {
            // 优先从低容量减
            for (int i = 0; i < caps.Length && changed < diff; i++)
            {
                int step = caps[i];
                int canDo = Math.Min(counts[i], (diff - changed) / step);
                if (canDo <= 0) continue;
                counts[i] -= canDo;
                changed += canDo * step;
            }
            // 若仍有剩余，从最低容量逐个减
            for (int i = 0; i < caps.Length && changed < diff; i++)
            {
                if (counts[i] <= 0) continue;
                counts[i] -= 1;
                changed += caps[i];
                i--; // 继续在同一类型尝试
            }
        }
        return changed;
    }
    void AlignObjectTop(GameObject obj, Camera cam)
    {
        // 相机顶部的世界坐标
        float topY = cam.transform.position.y + cam.orthographicSize;
        // 物体一半高度
        float objHalfHeight = 50f;

        Vector3 pos = obj.transform.position;
        pos.y = topY - objHalfHeight;
        obj.transform.position = pos;
    }

    void FitObjectToScreenWidth(GameObject obj, Camera cam)
    {
        float worldWidth = 2f * cam.orthographicSize * cam.aspect;
        float objWidth = obj.GetComponent<SpriteRenderer>().bounds.size.x;

        float scale = worldWidth / objWidth;
        obj.transform.localScale = new Vector3(scale, scale, 1f);
    }
    void AlignObjectBottom(GameObject obj, Camera cam)
    {
        float bottomY = cam.transform.position.y - cam.orthographicSize;
        float objHalfHeight = obj.GetComponent<SpriteRenderer>().bounds.extents.y;

        Vector3 pos = obj.transform.position;
        pos.y = bottomY + objHalfHeight + 12;
        obj.transform.position = pos;
    }



}