using System.Collections.Generic;
using System.Linq;
using cfg.CharacterCfg;
using cfg.LevelCfg;
using Cysharp.Threading.Tasks;
using Framework;
using Gameplay;
using Gameplay.Character;
using Gameplay.Guide;
using Gameplay.Level;
using Gameplay.Net;
using Gameplay.Unit;
using NLDPB;
using TMPro;
using UnityEngine;
using UnityEngine.UI;
using Image = UnityEngine.UI.Image;
using DG.Tweening;
using Gameplay.Effect;
using System;
using Gameplay.Common;
using PhxhSDK;

public class UIPassGameController : UIWindow
{

	//UI GameObj
	///Auto Gen Start///
	public Image Image_WinBG;
	public Image Image_PosterLu;
	public Image Image_TextRect;
	public TMP_Text Text_Win;
	public Image Image_BlueBar;
	public TMP_Text Text_LevelNum;
	public TMP_Text Text_LevelName;
	public TMP_Text Text_FightTime;
	public Image Image_Clock;
	public TMP_Text Text_Time;
	public TMP_Text Text_CharacterID;
	public TMP_Text Text_CharacterLV;
	public Image Image_EXEmpty;
	public Image Image_EXFull;
	public TMP_Text Text_EX;
	public TMP_Text Text_LVUp;
	public TMP_Text Text_Target;
	public Image Image_DownShadow;
	public TMP_Text Text_GeneralEX;
	public Image Image_ELogo;
	public TMP_Text Text_EXPHave;
	public TMP_Text Text_EXPGet;
	public TMP_Text Text_Mode;

	///Auto Gen End///

	private static bool _isPvPSuccess;
	public static async UniTask<UIWindow> Open(ItemList itemList, bool isSweep)
	{
		ValueTuple<ItemList, bool> value = (itemList, isSweep);

		return await UIManager.Instance.CreateAndOpenWindow(UINameConst.UIPassGame, value);
	}

	public static async UniTask<UIWindow> PvPOpen(ItemList itemList, bool isSuccess)
	{
		ValueTuple<ItemList, bool> value = (itemList, false);

		_isPvPSuccess = isSuccess;
		return await UIManager.Instance.CreateAndOpenWindow(UINameConst.UIPassGame, value);
	}

	/// <summary>
	/// 高斯模糊遮罩
	/// </summary>
	private RawImage rawImageGaussianBlurMask;
	/// <summary>
	/// 台词文本
	/// </summary>
	private TMP_Text textDialogue;
	/// <summary>
	/// 角色名
	/// </summary>
	private TMP_Text textName;

	private List<Image> _imgWinStar;

	private List<Image> _imageFailedStart;

	private List<GameObject> _aimObjList;

	private int _levelID;

	private List<GameObject> _itemHeadList;

	private List<uint> _charIDs;

	private ItemList _itemList;
	private bool isSweep;
	private bool _isNormal;
	private bool _isWar;
	private bool _isPvP;
	
	private Sequence _seqPvp;
	private bool _isPlaying;
	private PVPSettleData _settleData;
	private PVPSettleData _newPVPData;

	private GameObject _goCharDetail;
	private GameObject _goMissionDetail;
	private GameObject _goPvPDetail;
	private GameObject _goWarDetail;
	private RecycleView _scrollWar;
	/// <summary>
	/// 台词语音
	/// </summary>
	private AudioInst dialogueAudio;

	/// <summary>
	/// 是否正在播放台词语音
	/// </summary>
	public bool IsDialoguePlaying
	{
		get { return dialogueAudio != null && dialogueAudio.IsPlaying; }
	}

	private bool _isPlayingAnim;			//是否正在播放升级动画
	private int _playerLvUp;				//获取到的升级
	private float _playerExpUp;				//需要最后涨的经验值
	private Sequence _seq;
	/// <summary>
	/// 临时处理，保证只添加过一次升级动画
	/// </summary>
	private bool isAddUpAnim;
	
	public override async void PreLoad(object data = null)
	{
		base.PreLoad(data);

		if (data is ValueTuple<ItemList, bool> value)
		{
			_itemList = value.Item1;
			isSweep = value.Item2;

			if (isSweep)
			{
				Team team = LevelManager.Instance.SettleData.Team;
				var teamCharacterIDs = team.GetAllCharacters();
				for (int i = 0; i < teamCharacterIDs.Count; i++)
				{
					uint uid = teamCharacterIDs[i];
					DataCharacterAttri cfg = TableManager.Instance.Tables.CharacterAttri.Get((int)uid);
					if (null != cfg)
					{
						string str = CommonUtils.GetDefaultHeadPathByUid((uint)cfg.RoleID);
						string posterStr = CommonUtils.GetCharacterPicPath(cfg.RoleID, CommonUtils.ECharacterPicPathType.Poster);
						await PostPreload<Sprite>(str);
						await PostPreload<Sprite>(posterStr);
					}
				}
			}
			else
			{
				if (LevelManager.Instance.CurrentLevel.IsPvPLevel)
				{
					_isPvP = true;
					_settleData = LevelManager.Instance.PvpSettleData;
					_newPVPData = new PVPSettleData();
					return;
				}
				_isWar = LevelManager.Instance.CurrentLevel.IsWar;
			}
        }
	}

	// Use this for initialization
	public override void OnInit()
	{
		//bind UI GameObj
		UIPassGameBinder.GetComponents(this);

		Text_Mode = GetComponent<TMP_Text>("Image_WinBG/Text_Win/Text_Mode");
		textName = GetComponent<TMP_Text>("Image_WinBG/Image_PosterLu/Image_ActorLineBG/Text_Name");
        textDialogue = GetComponent<TMP_Text>("Image_WinBG/Image_PosterLu/Image_ActorLineBG/Text_Describe");
		//rawImageGaussianBlurMask = GetComponent<RawImage>("GaussianBlurMask");
		

		//rawImageGaussianBlurMask.texture = CommonUtils.GetScreenTexture2D();
		_goCharDetail = FindObj("Image_WinBG/CharacterDetail");
		_goMissionDetail = FindObj("Image_WinBG/MissionDetail");
		_goWarDetail = FindObj("Image_WinBG/UI_WarLevel");
		_goPvPDetail = FindObj("Image_WinBG/UI_PVP");
		_scrollWar = GetComponent<RecycleView>("Image_WinBG/UI_WarLevel/Image_WarTarget/ScrollViewTarget");

		BindButton("Button_Close", _OnClickClose);

		_imgWinStar = new List<Image>();
		_imageFailedStart = new List<Image>();
		_aimObjList = new List<GameObject>();
		_itemHeadList = new List<GameObject>();
		_charIDs = new List<uint>();
		for (int i = 0; i < 3; i++)
		{
			var img = GetComponent<Image>("Image_WinBG/MissionDetail/ImageMissionBar" + i + "/ImageWinStart");
			var imgFail = GetComponent<Image>("Image_WinBG/MissionDetail/ImageMissionBar" + i + "/ImageFailedStart");
			_imgWinStar.Add(img);
			_imageFailedStart.Add(imgFail);

			_aimObjList.Add(FindObj("Image_WinBG/MissionDetail/ImageMissionBar" + i));
		}

		for (int i = 0; i < 7; i++)
		{
			var go = FindObj("Image_WinBG/HeroLevelUp/Image_DownShadow/ItemHead" + i);
			_itemHeadList.Add(go);
		}

		isAddUpAnim = false;
    }

	public override void OnRelease()
	{
        //AudioManager.Instance.AudioMgrObj.StopAllSounds();
        if (_seq != null)
        {
            DOTween.Kill(_seq);
            _seq = null;
        }
        
        if (_seqPvp != null)
        {
	        DOTween.Kill(_seqPvp);
	        _seqPvp = null;
        }

        base.OnRelease();
	}

	private void _Refresh()
	{
		var team = _isPvP? TeamEditManager.Instance.GetSelectTeam() : LevelManager.Instance.SettleData.Team;
		var charIDArray = team.GetAllCharacters();
		for (int i = 0; i < charIDArray.Count; i++)
		{
			if (charIDArray[i] != Team.NoneID)
			{
				_charIDs.Add(charIDArray[i]);
			}
		}

		_RefreshInfo();
		_RefreshMissionDetail();
		_RefreshWar();
		_RefreshPvP();
		_RefreshCommonExp();
		_RefreshHeads();

		if (charIDArray.Count() > 0)
		{
			int id = (int)charIDArray[0];

            DataCharacterAttri dataCharacterAttri = TableManager.Instance.Tables.CharacterAttri.Get(id);
			if (dataCharacterAttri == null)
			{
				DebugUtil.LogError($"获取角色配置失败，id：{id}");
				return;
			}

            textName.text = CommonUtils.GetLocalizeText(dataCharacterAttri.Name);
            dialogueAudio = DialogueManager.Instance.PlayDiaogue(id,
				cfg.DialogueCfg.E_DialogueType.LevelWin,
				(content) => { textDialogue.text = content; });
		}
	}

	//invoke when open window
	protected override void OnShowWindow(object data)
	{
		_levelID = _isPvP? GLConfig.Inst.data.PVPLevelID : LevelManager.Instance.SettleData.LevelID;

		_Refresh();
    }

	protected override void OnUpdate()
	{
		base.OnUpdate();

		Image_TextRect.gameObject.IsScaleShow(IsDialoguePlaying);
	}

	public override async UniTask<bool> OnBack(object data = null)
	{
		return false;
	}

	protected override void OnHideWindow()
	{
        //AudioManager.Instance.AudioMgrObj.StopAllSounds();

        base.OnHideWindow();
	}

	#region RefreshWindow

	private void _RefreshInfo()
	{
		_RefreshMapDetail();
	}

	private void _RefreshMapDetail()
	{
		_RefreshTime();
		_RefreshEv();
		_RefreshLevelInfo();
		_RefreshPlayerInfo();
	}

	private async void _RefreshEv()
	{
		var root = FindObj("Image_WinBG/MapDetail");
		var imgDay = CommonUtils.GetComponent<Image>(root, "Image_Fight");
		var txtDay = CommonUtils.GetComponent<TMP_Text>(root, "Image_Fight/Text_Fight");
		var imgWeather = CommonUtils.GetComponent<Image>(root, "Enviroments/Image_Enviroment0");
		var txtWeather = CommonUtils.GetComponent<TMP_Text>(root, "Enviroments/Image_Enviroment0/Text_Current");
		var imgEv = CommonUtils.GetComponent<Image>(root, "Enviroments/Image_Enviroment1");
		var txtEv = CommonUtils.GetComponent<TMP_Text>(root, "Enviroments/Image_Enviroment1/Text_Current");

		LevelInfo levelInfo;
		if (isSweep)
			levelInfo = LevelManager.Instance.CurrLevel;
		else
			LevelManager.Instance.TryGetLevelInfoByID(LevelManager.Instance.CurrentLevel.ID, out levelInfo);

		if (levelInfo != null)
		{
			var dayNightConfig = CommonUtils.GetDayNightConfig(levelInfo.Cfg.LevelTime);
			imgDay.sprite = await LoadAssetAsync<Sprite>(dayNightConfig.Icon);
			txtDay.text = CommonUtils.GetLocalizeText(dayNightConfig.NameLocal);
			
			var weatherType = levelInfo.Cfg.LevelWeather;
			var weatherConfig = CommonUtils.GetWeatherConfig(weatherType);
			imgWeather.sprite = await LoadAssetAsync<Sprite>(weatherConfig.Icon);
			txtWeather.text = CommonUtils.GetLocalizeText(weatherConfig.NameLocal);
			
			var type = levelInfo.Environment;
			var environmentCfg = CommonUtils.GetEnvironmentConfig(type);
			imgEv.sprite = await LoadAssetAsync<Sprite>(environmentCfg.Icon);
			txtEv.text = CommonUtils.GetLocalizeText(environmentCfg.NameLocal);
		}
	}

	private async void _RefreshLevelInfo()
	{
		var level = LevelManager.Instance.CurrLevel;
		//var levelName = level.Name;
		//Text_LevelName.text = levelName;
		if (_isPvP)
		{
			Text_Mode.text = CommonUtils.GetLocalizeText("level_chapter_type_pvp");
			Text_LevelNum.text = CommonUtils.GetLocalizeText("pvp_level_desc");
		}
		else if (_isWar)
		{
			Text_Mode.text = CommonUtils.GetLocalizeText("level_chapter_type_war");
			Text_LevelNum.text = LevelManager.Instance.LevelIDToNum(level.Cfg.Id);
		}
		else
		{
			Text_Mode.text = CommonUtils.GetLocalizeText("level_chapter_type_normal");//CommonUtils.GetCurLevelTypeStr();
			Text_LevelNum.text = LevelManager.Instance.LevelIDToNum(level.Cfg.Id);
		}
	}

	private void _RefreshTime()
	{
		if (isSweep)
		{
			Text_Time.gameObject.IsScaleShow(false);
            return;
		}

		var minutes = TeamManager.Instance.GetFightPastMinute();
		var seconds = TeamManager.Instance.GetFightPastSecond();
		var timeStr = "";

		if (minutes >= 10)
		{
			timeStr += minutes;
		}
		else
		{
			timeStr += "0";
			timeStr += minutes;
		}

		timeStr += ":";

		if (seconds >= 10)
		{
			timeStr += seconds;
		}
		else
		{
			timeStr += "0";
			timeStr += seconds;
		}

		Text_Time.text = timeStr;
        Text_Time.gameObject.IsScaleShow(true);
    }

	private void _RefreshPlayerInfo()
	{
		if (_isPvP)
		{
			return;
		}
		var playerName = Actor.Instance.Base.Nickname;
		var playerLv = Actor.Instance.Base.GetProp(ActorProp.Level);
		Text_CharacterID.text = playerName;

		if (GuideManager.Instance.IsGuiding && 100001 == LevelManager.Instance.CurrLevel.Cfg.Id)
			Text_CharacterID.gameObject.IsScaleShow(false);
		else
            Text_CharacterID.gameObject.IsScaleShow(true);

        Text_CharacterLV.text = "LV." + playerLv;

		//var actorCfg = ActorLevelTableHelper.Instance.Get((int)playerLv);
		var max = ActorLevelTableHelper.Instance.GetLevelUpExp((int)playerLv);//actorCfg.Exp;
        var cur = Actor.Instance.Base.GetProp(ActorProp.Exp);
		var process = (float)cur / max;

		var oldLvExp = LevelManager.Instance.SettleData.PlayerLvExp;
		var lvDiff = playerLv - oldLvExp.Lv;
		var oldLv = oldLvExp.Lv;
		int add = _CalculateExp();
		Image_EXFull.fillAmount = (float)oldLvExp.Exp / max;
		Text_LVUp.text = "+" + add;
		Text_EX.text = cur + "/" + max;
		//Image_EXFull.fillAmount = process;
		_playerLvUp = (int)lvDiff;
		_PlayAnim(process);
	}

	private int _CalculateExp()
	{
		int retExp = 0;
		var oldExp = LevelManager.Instance.SettleData.PlayerLvExp.Exp;
		var oldLv = LevelManager.Instance.SettleData.PlayerLvExp.Lv;

		var curLv = Actor.Instance.Base.GetProp(ActorProp.Level);
		var curExp = Actor.Instance.Base.GetProp(ActorProp.Exp);
		if (oldLv < curLv)
		{
			var oldActorLvExp = ActorLevelTableHelper.Instance.GetLevelUpExp((int)oldLv);//Cfg = ActorLevelTableHelper.Instance.Get((int)oldLv);
			retExp += oldActorLvExp - (int)oldExp;
			for (uint i = oldLv + 1; i < curLv; i++)
			{
				var curLvExp = ActorLevelTableHelper.Instance.GetLevelUpExp((int)i);
				retExp += curLvExp;
			}

			retExp += (int)curExp;
		}
		else
		{
			retExp += (int)(curExp - oldExp);
		}

		return retExp;
	}
	private async void _RefreshWar()
	{
		if (!_isWar)
		{
			return;
		}
		
		_goMissionDetail.SetActive(false);
		_goCharDetail.SetActive(false);
		_goWarDetail.SetActive(true);
		_goPvPDetail.SetActive(false);
		_scrollWar.Init(_RefreshWarItem);
		
		var levelInfo = LevelManager.Instance.CurrentLevel.GetLevelInfo();
		var txtScore = CommonUtils.GetComponent<TMP_Text>(_goWarDetail, "Image_WarGrades/Text_Grades");
		var imgRating = CommonUtils.GetComponent<Image>(_goWarDetail, "Image_WarGrades/Image_RatingLevelIcon");
		txtScore.text = levelInfo.Score.ToString();
		imgRating.sprite = await LoadAssetAsync<Sprite>(WarRating.WarRatingPath[levelInfo.WarRating]);
		_scrollWar.ShowList(_GetScrollCount());
	}

	private void _RefreshWarItem(GameObject go, int index)
	{
		var complete = LevelManager.Instance.CurrentLevel.GetStarIsSuccess(index);
		var rootComplete = CommonUtils.GetGameObject(go, "UI_Complete");
		var rootInComplete = CommonUtils.GetGameObject(go, "UI_Incomplete");
		rootComplete.SetActive(complete);
		rootInComplete.SetActive(!complete);
		
		var root = complete ? rootComplete : rootInComplete;
		var txtScore = CommonUtils.GetComponent<TMP_Text>(root, "Text_PlusScore");
		var txtDesc = CommonUtils.GetComponent<TMP_Text>(root, "Text_TargetMission");
		var score = LevelManager.Instance.CurrentLevel.GetLevelInfo().GetScoreTarget(index);
		var desc = LevelManager.Instance.CurrentLevel.GetScoreTargetLocalization(index);
		txtScore.text = "+" + score;
		txtDesc.text = desc;
	}

	private int _GetScrollCount()
	{
		var levelData = LevelManager.Instance.CurrentLevel.GetLevelData();
		return levelData.scoreTarget.Count;
	}
	
	private void _RefreshMissionDetail()
	{
		if (_isWar || _isPvP)
		{
			return;
		}
		
		_goMissionDetail.SetActive(true);
		_goCharDetail.SetActive(true);
		_goWarDetail.SetActive(false);
		_goPvPDetail.SetActive(false);
		
		_RefreshStars();
		_RefreshAimInfo();
	}
	
	private void _RefreshStars()
	{
		if (isSweep)
		{
			return;
		}

		var starCount = LevelManager.Instance.CurrentLevel.StarCount;
		for (int i = 0; i < _imgWinStar.Count; i++)
		{
			var isFinish = LevelManager.Instance.CurrentLevel.GetStarIsSuccess(i);
			_imgWinStar[i].gameObject.SetActive(isFinish);
			_imageFailedStart[i].gameObject.SetActive(!isFinish);
		}
	}

	private void _RefreshAimInfo()
	{
		//var levelInfo = LevelManager.Instance.GetLevelInfoByID(_levelID);
		var levelCfg = TableManager.Instance.Tables.Level.GetOrDefault(_levelID);
		var levelRewardID = new List<List<int>>(3);
		if (levelCfg != null)
		{
			levelRewardID.Add(new List<int>(levelCfg.StarRewardID1));
			levelRewardID.Add(new List<int>(levelCfg.StarRewardID2));
			levelRewardID.Add(new List<int>(levelCfg.StarRewardID3));
		}

		for (int i = 0; i < _aimObjList.Count; i++)
		{
			var txtContent = "";
			var aimObj = _aimObjList[i];
			if (isSweep)
			{
				aimObj.gameObject.SetActive(false);
				continue;
			}
			else
				aimObj.gameObject.SetActive(true);
            var txtDesc = CommonUtils.GetComponent<TMP_Text>(aimObj, "TextDescribe");
			var isFinish = LevelManager.Instance.CurrentLevel.GetStarIsSuccess(i);
			var txtGetItem = CommonUtils.GetComponent<TMP_Text>(aimObj, "TextGetItem");
			var txtGetItemFailed = CommonUtils.GetComponent<TMP_Text>(aimObj, "TextGetItemFailed");
			txtGetItem.gameObject.SetActive(isFinish);
			txtGetItemFailed.gameObject.SetActive(!isFinish);
			txtDesc.text = LevelManager.Instance.CurrentLevel.GetStarTargetLocalization(i);

			if (levelCfg != null)
			{
				var levelRewardL = levelRewardID[i];
				if (levelRewardL.Count > 0)
				{
					var itemList = CommonUtils.GetFilterRewardItemList(levelRewardL);
					for (int n = 0; n < itemList.Count; n++)
					{
						var list = itemList[n];
						var itemID = list.ID;
						var itemCfg = TableManager.Instance.Tables.Item.GetOrDefault(itemID);
						if (itemCfg != null)
						{
							var name = CommonUtils.GetLocalizeText(itemCfg.NameLocal);
							txtContent += name + "x" + list.Count;
						}
					}
				}
			}

			txtGetItem.text = txtContent;
			txtGetItemFailed.text = txtContent;
		}
	}

	private void _RefreshCommonExp()
	{
		if (_isPvP)
		{
			Text_GeneralEX.gameObject.SetActive(false);
			return;
		}
		var list = _itemList.Lists;
		int itemCount = 0;
		for (var i = ItemSource.LevelPassNormal; i <= ItemSource.LevelPassStar3; i++)
		{
			itemCount += _CalculateExpItemCount(list[(int)i]);
		}

		var settleData = LevelManager.Instance.SettleData;
		Text_EXPHave.text = settleData.CommonExp.ToString();
		Text_EXPGet.text = "+" + itemCount;
	}

	private int _CalculateExpItemCount(ItemCounts itemCounts)
	{
		int retCount = 0;
		if (itemCounts.Ids.Count > 0)
		{
			var idx = itemCounts.Ids.IndexOf(3);
			if (idx >= 0)
			{
				var count = itemCounts.Counts[idx];
				retCount = (int)count;
			}
		}

		return retCount;
	}

	private async void _RefreshHeads()
	{
        for (int i = 0; i < _itemHeadList.Count; i++)
        {
			_itemHeadList[i].IsScaleShow(false);
        }

        await AssetManager.Instance.WaitAllPreloads();

        for (int i = 0; i < _itemHeadList.Count; i++)
		{
			_RefreshHead(i);
            _itemHeadList[i].IsScaleShow(true);
        }
	}

	private async void _RefreshHead(int idx)
	{
		var item = _itemHeadList[idx];
		if (idx >= _charIDs.Count)
		{
			item.SetActive(false);
			return;
		}
		item.SetActive(true);

		var uid = _charIDs[idx];
		var headNode = CommonUtils.GetComponent<UIHeadItemNode>(item, "HeadNode");
		if (headNode)
		{
			var headInfo = new UIHeadInfo(uid);
			headNode.SetData(headInfo);
			headNode.Refresh(false);
		}

		var imgPro = CommonUtils.GetComponent<Image>(item, "ImageProfessionRect/ImageProfession");
		var job = CommonUtils.GetProfessionByUid(uid);
		var jobData = TableManager.Instance.Tables.JobAttri.GetOrDefault((int)job);
		var spritePath = jobData.IconPath;
		var sprite = await LoadAssetAsync<Sprite>(spritePath);
		imgPro.sprite = sprite;
		
		if (_isPvP)
		{
			CommonUtils.GetGameObject(item, "ImageFavorate").SetActive(false);
			CommonUtils.GetGameObject(item, "ImageHeroEXpEmpty").SetActive(false);
			CommonUtils.GetGameObject(item, "Image_SerialNumber").SetActive(false);
			CommonUtils.GetGameObject(item, "TextHeroLV").SetActive(false);
			return;
		}
		
		var txtTeamIdx = CommonUtils.GetComponent<TMP_Text>(item, "Image_SerialNumber/Text_Number");
		var team = LevelManager.Instance.SettleData.Team;
		var teamIdx = team.GetAllCharacterIdx(uid);//team.GetAllCharacters().IndexOf(uid);
		txtTeamIdx.text = (teamIdx + 1).ToString();

		var txtExpAdd = CommonUtils.GetComponent<TMP_Text>(item, "ImageHeroEXpEmpty/TextHeroEXPUp");
		var imgExpProcess = CommonUtils.GetComponent<Image>(item, "ImageHeroEXpEmpty/ImageHeroEXpFull");
		var txtLv = CommonUtils.GetComponent<TMP_Text>(item, "TextHeroLV");
		var addExp = _CalculateCharExpAdd(uid);
		if (addExp > 0)
			
			
		{
			txtExpAdd.text = "+" + addExp;
		}
		else
		{
			txtExpAdd.text = "";
		}

		if (CharacterDataInfoManager.Instance.DataDic.TryGetValue(uid, out var charDataInfo))
		{
			var cur = charDataInfo.Exp;
			var cfg = TableManager.Instance.Tables.CharacterLevelExp.GetOrDefault((int)charDataInfo.Level);
			var process = (float)cur / cfg.EXP;
			imgExpProcess.fillAmount = process;
			txtLv.text = "LV " + charDataInfo.Level;
		}

		var imgLikely = CommonUtils.GetComponent<Image>(item, "ImageFavorate");
		var txtLikely = CommonUtils.GetComponent<TMP_Text>(item, "ImageFavorate/TextFavorateEXp");
		var likely = _CalculateLikely(uid);
		if (likely > 0)
		{
			txtLikely.text = "+" + likely;
			imgLikely.gameObject.SetActive(true);
		}
		else
		{
			imgLikely.gameObject.SetActive(false);
		}
	}

	#endregion

	#region Data
	private int _CalculateCharExpAdd(uint roleID)
	{
		int add = 0;
		var lvExp = LevelManager.Instance.SettleData.ExpDic[roleID];
		if (CharacterDataInfoManager.Instance.DataDic.TryGetValue(roleID, out var charDataInfo))
		{
			var oldLv = lvExp.Lv;
			var oldExp = (int)lvExp.Exp;

			var curLv = charDataInfo.Level;
			var curExp = (int)charDataInfo.Exp;

			if (curLv == TableManager.Instance.Tables.CharacterLevelExp.DataList.Count)
			{
				return 0;
			}

			if (oldLv < curLv)
			{
				var expCfg = TableManager.Instance.Tables.CharacterLevelExp.GetOrDefault((int)oldLv + 1);
				add += (expCfg.EXP - oldExp);

				for (uint i = oldLv + 1; i < curLv; i++)
				{
					var cfg = TableManager.Instance.Tables.CharacterLevelExp.GetOrDefault((int)i);
					add += cfg.EXP;
				}

				add += curExp;
			}
			else
			{
				add += curExp - oldExp;
			}
		}

		return add;
	}

	private int _CalculateLikely(uint roleID)
	{
		int retCount = 0;
		var lvExp = LevelManager.Instance.SettleData.FavorDic[roleID];
		if (CharacterDataInfoManager.Instance.DataDic.TryGetValue(roleID, out var charDataInfo))
		{
			var oldExp = (int)lvExp.Exp;
			var oldLv = (int)lvExp.Lv;

			var curLv = (int)charDataInfo.LikelyLevel;
			var curExp = (int)charDataInfo.LikelyExp;

			if (oldLv < curLv)
			{
				var expCfg = TableManager.Instance.Tables.CharacterLikability.Get((int)roleID, oldLv + 1);
				if (expCfg == null)
				{
					return 0;
				}
				retCount += expCfg.LikabilityExp - oldExp;

				for (int i = oldLv + 1; i < curLv; i++)
				{
					var cfg = TableManager.Instance.Tables.CharacterLikability.Get((int)roleID, i + 1);
					retCount += cfg.LikabilityExp;
				}

				retCount += curExp;
			}
			else
			{
				retCount += curExp - oldExp;
			}
		}

		return retCount;
	}

	#endregion

	private async void _OnClickClose()
	{
		if (_isPlayingAnim || _isPlaying)
			return;

		int rewardCnt = 0;
		foreach(var item in _itemList.Lists)
        {
            rewardCnt += item.Counts.Count;
        }

		async void Cb()
		{
			await GameSceneHelper.Instance.UnLoadSceneForRt();
			AudioManager.Instance.StopAll();
			AudioManager.Instance.ReleaseAllAudios();
			LevelManager.Instance.ExitLevelDirectly();
			EffectManager.instance.rootObj.SetActive(true);
			//PVPManager.Instance.RewardItemList = null;
			CloseWindow();
		}
		if (_isPvP)
		{
			if (rewardCnt <= 0)
			{
				await GameSceneHelper.Instance.UnLoadSceneForRt();
				AudioManager.Instance.StopAll();
				AudioManager.Instance.ReleaseAllAudios();
				LevelManager.Instance.ExitLevelDirectly();
				EffectManager.instance.rootObj.SetActive(true);
				//PVPManager.Instance.RewardItemList = null;
				CloseWindow();
				return;
			}
			
			await UI_GetItemWindowController.Open(_itemList, UI_GetItemWindowController.EShowType.StorySettle, Cb);
			return;

		}
		if (rewardCnt > 0)
		{
			//await UI_GetItemSettleController.Open(_itemList);
			await UI_GetItemWindowController.Open(_itemList, UI_GetItemWindowController.EShowType.StorySettle, cb: () =>
			{
				ExitFromLevel();
			});
			if (isSweep)
				CloseWindow();

			return;
		}

		await GameSceneHelper.Instance.UnLoadSceneForRt();
		AudioManager.Instance.StopAll();
		AudioManager.Instance.ReleaseAllAudios();
		LevelManager.Instance.ExitLevelDirectly();
		EffectManager.instance.rootObj.SetActive(true);
		CloseWindow();
		
	}
    async void ExitFromLevel()
    {
        await GameSceneHelper.Instance.UnLoadSceneForRt();
        AudioManager.Instance.StopAll();
        AudioManager.Instance.ReleaseAllAudios();
        LevelManager.Instance.ExitLevelDirectly();
        EffectManager.instance.rootObj.SetActive(true);
        UIManager.Instance.CloseWindow(UINameConst.UIMissionWin);
    }

    #region Anim

    private async void _PlayAnim(float process)
	{
		if (!_isPlayingAnim)
		{
			_seq = DOTween.Sequence();
			//await UniTask.Delay(250);
			_seq.AppendInterval(0.4f);
			if (_playerLvUp > 0)
			{
				for (int i = 1; i <= _playerLvUp; i++)
				{
					_seq.Append(Image_EXFull.DOFillAmount(1, 0.8f));
					_seq.AppendCallback(() =>
					{
						Image_EXFull.fillAmount = 0;
					});
				}
			}
			if (process > 0 && !isAddUpAnim)
			{
				isAddUpAnim = true;
                _seq.Append(Image_EXFull.DOFillAmount(process, 0.5f));
				_seq.AppendInterval(0.25f);
				_seq.AppendCallback(_ShowRewardWindow);
			}
		}
	}

	private async void _ShowRewardWindow()
	{
		if (_playerLvUp < 1)
		{
			return;
		}

        var oldLvExp = LevelManager.Instance.SettleData.PlayerLvExp;
		var curLv = Actor.Instance.Base.GetProp(ActorProp.Level);
		await UI_PlayerLevelUpInfoController.Open((int)oldLvExp.Lv, (int)curLv);
	}
	
	#endregion
	
	#region PVP
	private void _RefreshPvP()
	{
		if (!_isPvP)
		{
			return;
		}
		
		_goMissionDetail.SetActive(false);
		_goCharDetail.SetActive(false);
		_goWarDetail.SetActive(false);
		_goPvPDetail.SetActive(true);

		_RefreshTitle();
		_RefreshAnim();
	}

	private void _RefreshTitle()
	{
		if (_isPvPSuccess)
		{
			Text_Win.text = CommonUtils.GetLocalizeText("pvp_settle_title_suc");
			return;
		}
		Text_Win.text = CommonUtils.GetLocalizeText("pvp_settle_title_defeat");
	}
	
	private void _RefreshAnim()
	{
		if (_seqPvp == null)
		{
			_seqPvp = DOTween.Sequence();
		}
		_RefreshPvPScore();
		_RefreshPvPRank();
	}
	
	private void _RefreshPvPScore()
	{
		var old = _settleData.Score;
		var now = _newPVPData.Score;
		var add = now - old;
		var txtScoreChange = CommonUtils.GetComponent<TMP_Text>(_goPvPDetail, "Image_Score/Text_Change");
		var txtScore = CommonUtils.GetComponent<TMP_Text>(_goPvPDetail, "Image_Score/Text_Current");
		var imgAdd = CommonUtils.GetComponent<Image>(_goPvPDetail, "Image_Score/Image_Increase");
		var imgDecrease = CommonUtils.GetComponent<Image>(_goPvPDetail, "Image_Score/Image_Decrease");
		if (add == 0)
			txtScoreChange.text = "";
		else
		{
			imgAdd.gameObject.SetActive(_isPvPSuccess);
			imgDecrease.gameObject.SetActive(!_isPvPSuccess);
			txtScoreChange.text = _isPvPSuccess? $"<color=#B9BC09>+{add}</color>" : $"<color=#C61D1B>{add}</color>";
		}
		_PlayScoreAnim(old, now, txtScore);
	}
	
	private void _RefreshPvPRank()
	{
		var old = _settleData.Rank;
		var now = _newPVPData.Rank;
		var add = old - now;
		var txtRankChange = CommonUtils.GetComponent<TMP_Text>(_goPvPDetail, "Image_Ranking/Text_Change");
		var txtScore = CommonUtils.GetComponent<TMP_Text>(_goPvPDetail, "Image_Ranking/Text_Current");
		var imgAdd = CommonUtils.GetComponent<Image>(_goPvPDetail, "Image_Ranking/Image_Increase");
		var imgDecrease = CommonUtils.GetComponent<Image>(_goPvPDetail, "Image_Ranking/Image_Decrease");
		if (add == 0)
			txtRankChange.text = "";
		else
		{
			if (old <= 0 && add < 0)
			{
				add = -add;
			}
			imgAdd.gameObject.SetActive(_isPvPSuccess);
			imgDecrease.gameObject.SetActive(!_isPvPSuccess);
			txtRankChange.text = _isPvPSuccess? $"<color=#B9BC09>+{add}</color>" : $"<color=#C61D1B>{add}</color>";
		}
		_PlayRankAnim(old, now, txtScore);
	}
	
	private void _PlayScoreAnim(int old, int now, TMP_Text txt)
	{
		var tw = DOTween.To(() => old, value =>
		{
			_isPlaying = true;
			txt.text = value.ToString();
		}, now, 1.5f);
		_seqPvp.Append(tw);
	}

	private void _PlayRankAnim(int old, int now, TMP_Text txt)
	{
		var tw = DOTween.To(() => old, value =>
		{
			txt.text = value.ToString();
		}, now, 1.5f);
		_seqPvp.Join(tw);
		_seqPvp.AppendCallback(() =>
		{
			_isPlaying = false;
		});
	}
	
	#endregion
}