using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Snxxz.UI;
using UnityEngine;

using System.Collections;

[XLua.LuaCallCSharp]
public class SettingEffectMgr : SingletonMonobehaviour<SettingEffectMgr>

{
    private bool _isAutoHangUp = false;
    private ItemConfig _tagItemModel;
    private FuncConfigConfig _tagFuncModel;
    private StoreConfig _tagShopModel;
    private int[] shopIdlist;

    PlayerPetDatas m_petModel;
    PlayerPetDatas petmodel {
        get {
            return m_petModel ?? (m_petModel = ModelCenter.Instance.GetModel<PlayerPetDatas>());
        }
    }


    PackModel _playerPack;
    PackModel playerPack {
        get { return _playerPack ?? (_playerPack = ModelCenter.Instance.GetModel<PackModel>()); }
    }

    PlayerDeadModel _deadModel;
    PlayerDeadModel DeadModel {
        get { return _deadModel ?? (_deadModel = ModelCenter.Instance.GetModel<PlayerDeadModel>()); }
    }

    StoreModel _storeModel;
    StoreModel m_storeModel {
        get { return _storeModel ?? (_storeModel = ModelCenter.Instance.GetModel<StoreModel>()); }
    }
    DungeonModel dungeonModel { get { return ModelCenter.Instance.GetModel<DungeonModel>(); } }

    private float delayTime = 2f;
    private bool isGetNewItem = false;
    public bool isStartDecompose { get; set; }
    public bool isStartOneKeySell { get; set; }

    private void Awake()
    {
        isGetNewItem = false;
        delayTime = 2;
        HeroBehaviour.OnStartHandupAI -= OnStartHandupAI;
        HeroBehaviour.OnStopHandupAI -= OnStopHandupAI;
        DeadModel.playerDieEvent -= OnPlayerDie;
        m_storeModel.RefreshBuyResultEvent -= RefreshBuySuccess;
        DeadModel.CloseRebornWinEvent -= PlayerRebornSuccess;
        HeroBehaviour.OnStartHandupAI += OnStartHandupAI;
        HeroBehaviour.OnStopHandupAI += OnStopHandupAI;
        DeadModel.playerDieEvent += OnPlayerDie;
        m_storeModel.RefreshBuyResultEvent += RefreshBuySuccess;
        DeadModel.CloseRebornWinEvent += PlayerRebornSuccess;
        playerPack.RefreshDecomAttrAct += DecomposeSuccess;
        DTC0721_tagMakeItemAnswer.MakeItemAnswerEvent += OneKeySellSuccess;
    }


    public void Begin()
    {
        _tagFuncModel = FuncConfigConfig.Get("AutoBuyDrug");
        shopIdlist = ConfigParse.GetMultipleStr<int>(_tagFuncModel.Numerical1);
        isStartDecompose = false;
        isStartOneKeySell = false;
    }

    float secondTimer = 0;
    float halfSecondTimer = 0;
    float autoSellCoolTimer = 0;
    float autoDecomposeCoolTimer = 0;
    private void LateUpdate()
    {
        if (!(StageLoad.Instance.currentStage is DungeonStage))
        {
            return;
        }

        secondTimer += Time.deltaTime;
        halfSecondTimer += Time.deltaTime;
        if (halfSecondTimer >= 0.5f)
        {
            halfSecondTimer = 0f;
            if (!DeadModel.playerIsDie)
            {
                bool isCool;
                KnapsackTimeCDMgr.Instance.GetItemCoolByCDType(1, out isCool);
                if (!isCool)
                {
                    AutoDrugSetting();
                }
            }
        }

        if (isStartDecompose)
        {
            autoDecomposeCoolTimer += Time.deltaTime;
            if (autoDecomposeCoolTimer >= 5f)
            {
                autoDecomposeCoolTimer = 0;
                isStartDecompose = false;
            }
        }

        if (isStartOneKeySell)
        {
            autoSellCoolTimer += Time.deltaTime;
            if (autoSellCoolTimer >= 5f)
            {
                autoSellCoolTimer = 0;
                isStartOneKeySell = false;
            }
        }

        if (secondTimer >= 1f)
        {
            secondTimer = 0f;
            RefreshBagItem();
        }

    }

    private void PlayerRebornSuccess()
    {
        StopAllCoroutines();
    }

    private void OneKeySellSuccess(H0721_tagMakeItemAnswer obj)
    {
        if (obj.MakeType != (byte)MakeType.Def_mitKeySell)
            return;

        isStartOneKeySell = false;
    }

    private void DecomposeSuccess()
    {
        isStartDecompose = false;
    }

    public bool GetSettingEffect()
    {
        return _isAutoHangUp;
    }

    private void OnStartHandupAI()
    {
        DebugEx.Log("OnStartHandupAI");
        _isAutoHangUp = true;
        RefreshBagItem();
    }

    private void OnStopHandupAI()
    {
        DebugEx.Log("OnStopHandupAI");
        _isAutoHangUp = false;
    }

    private void RefreshBuySuccess(int obj)
    {
        if (shopIdlist != null)
        {
            if (shopIdlist.Contains(obj))
            {
                AutoDrugSetting();
            }
        }
    }

    public void RefreshBagItem()
    {
        if (!_isAutoHangUp)
        {
            return;
        }
        DealBagItem();
    }

    /// <summary>
    /// 背包小于5格处理物品
    /// </summary>
    private void DealBagItem()
    {
        if (playerPack.GetEmptyGridCount(PackType.Item) < 5 && ItemLogicUtility.Instance.isPackResetOk)
        {
            if (HangUpSetModel.Instance.GetBool(HangUpAutoBoolType.isAutoSell)
             && !isStartOneKeySell
             && ItemLogicUtility.Instance.GetSellItemList().Count > 0)
            {
                ItemLogicUtility.Instance.SendOneKeySellQuest(ItemLogicUtility.Instance.GetSellItemList());
                return;
            }

            if (HangUpSetModel.Instance.GetBool(HangUpAutoBoolType.isAutoDevour) && !isStartDecompose)
            {
                if (playerPack.IsReachMinDecomposeNum())
                {
                    playerPack.SendEquipdevourQuest();
                    return;
                }
            }
        }
    }

    /// <summary>
    /// 自动吃药和买药的逻辑判断
    /// </summary>
    private void AutoDrugSetting()
    {
        if (CrossServerUtility.IsCrossServerOneVsOne()) return;

        float hpPercent = Mathf.RoundToInt((float)PlayerDatas.Instance.baseData.HP / PlayerDatas.Instance.extersion.MaxHP * 100);
        if (hpPercent <= HangUpSetModel.Instance.GetHpSet())
        {
            SinglePack singlePack = playerPack.GetSinglePack(PackType.Item);
            if (singlePack == null)
                return;

            int i = 0;
            int length = shopIdlist.Length;
            for (i = length - 1; i > -1; i--)
            {
                _tagShopModel = StoreConfig.Get(shopIdlist[i]);
                _tagItemModel = ItemConfig.Get(_tagShopModel.ItemID);
                if (PlayerDatas.Instance.baseData.LV >= _tagItemModel.LV)
                {
                    if (singlePack.GetCountById(_tagItemModel.ID) > 0)
                    {
                        var list = singlePack.GetItemsById(_tagItemModel.ID);
                        ItemOperateUtility.Instance.GotoUseItem(list[0].itemPlace);
                        break;
                    }
                    else
                    {
                        if (HangUpSetModel.Instance.GetBool(HangUpAutoBoolType.isAutoBuyDrug) && playerPack.GetEmptyGridCount(PackType.Item) > 0)
                        {
                            if (m_storeModel.MoneyIsEnough(_tagShopModel.MoneyType, (ulong)_tagShopModel.MoneyNumber))
                            {
                                m_storeModel.SendBuyShopItem(_tagShopModel, 1);
                                break;
                            }
                        }
                    }
                }
            }
        }
    }

    private int[] RebornConditions;
    private int rebornPrice;
    private void OnPlayerDie()
    {
        if (!_isAutoHangUp || !HangUpSetModel.Instance.GetBool(HangUpAutoBoolType.isAutoReborn)
            || !DeadModel.IsCanReborn || IsDungeon())
            return;

        RebornConditions = DeadModel.RebornConditions;
        rebornPrice = RebornConditions[2];
        StartCoroutine(PlayerReborn(5));
    }

    private bool IsDungeon()
    {
        var mapId = PlayerDatas.Instance.baseData.MapID;
        var mapConfig = MapConfig.Get(mapId);
        return mapConfig != null && mapConfig.MapFBType != 0;
    }

    IEnumerator PlayerReborn(float time)
    {
        while (true)
        {
            DebugEx.Log("PlayerReborn");
            time -= 1;
            if (time <= 0 && DeadModel.playerIsDie)
            {
                if (DeadModel.IsRebornCoinsEnough())
                {
                    DeadModel.SendRebornQuest(3);
                }
                else
                {
                    if (DeadModel.IsCanInplaceReborn(rebornPrice))
                    {
                        DeadModel.SendRebornQuest(2);
                    }
                }

                break;
            }
            yield return new WaitForSeconds(1);
        }
    }

    private int CompareID(int start, int end)
    {
        return -start.CompareTo(end);
    }

    private int CompareDrugLv(ItemModel start, ItemModel next)
    {
        _tagItemModel = ItemConfig.Get((int)start.itemId);
        int lv1 = _tagItemModel.LV;
        _tagItemModel = ItemConfig.Get((int)next.itemId);
        int lv2 = _tagItemModel.LV;
        return -lv1.CompareTo(lv2);
    }


}