using UnityEngine;
using UnityEngine.UI;
using System.Collections.Generic;

using System;

namespace Snxxz.UI
{
    public class TaskTypeCell : MonoBehaviour
    {
        private Image _itemIcon;
        public Image itemIcon
        {
           get
            {
                if (_itemIcon == null)
                {
                    _itemIcon = transform.Find("ItemBg/ItemIcon").GetComponent<Image>();
                }
                return _itemIcon;
            }
        }

        private Image _doTaskImg;
        public Image doTaskImg
        {
            get
            {
                if (_doTaskImg == null)
                {
                    _doTaskImg = transform.Find("GoBtn").GetComponent<Image>();
                }
                return _doTaskImg;
            }
        }

        private Text _taskName;
        public Text taskName
        {
            get
            {
                if (_taskName == null)
                {
                    _taskName = transform.Find("TaskNameText").GetComponent<Text>();
                }
                return _taskName;
            }
        }
        private Text _taskProgress;
        public Text taskProgress
        {
            get
            {
                if (_taskProgress == null)
                {
                    _taskProgress = transform.Find("ProgressText").GetComponent<Text>();
                }
                return _taskProgress;
            }
        }

        private Text _remainNumText;
        public Text remainNumText
        {
            get
            {
                if (_remainNumText == null)
                {
                    _remainNumText = transform.Find("RemainNumText").GetComponent<Text>();
                }
                return _remainNumText;
            }
        }

        private Text _doTaskText;
        public Text doTaskText
        {
            get
            {
                if (_doTaskText == null)
                {
                    _doTaskText = transform.Find("GoBtn/Text").GetComponent<Text>();
                }
                return _doTaskText;
            }
        }

        private Button _doTaskBtn;
        public Button doTaskBtn
        {
            get
            {
                if (_doTaskBtn == null)
                {
                    _doTaskBtn = transform.Find("GoBtn").GetComponent<Button>();
                }
                return _doTaskBtn;
            }
        }

        private GameObject _rewardParent;
        public GameObject rewardParent
        {
            get
            {
                if (_rewardParent == null)
                {
                    _rewardParent = transform.Find("RewardParent").gameObject;
                }
                return _rewardParent;
            }
        }

        public List<Image> taskRewardImglist = new List<Image>();
        public List<Text> taskRewardCntlist = new List<Text>();

        private GameObject _haveReceiveImage;
        public GameObject haveReceiveImage
        {
            get
            {
                if (_haveReceiveImage == null)
                {
                    _haveReceiveImage = transform.Find("DrawImage").gameObject;
                }
                return _haveReceiveImage;
            }
        }

        private UIEffect _receiveEffect;
        public UIEffect receiveEffect
        {
            get
            {
                if(_receiveEffect == null)
                {
                    _receiveEffect = transform.Find("GoBtn/receiveEffect").GetComponent<UIEffect>();

                }
                return _receiveEffect;
            }
        }

        private Achievement achieve = null;
        private SuccessConfig successConfig = null;
        private RealmPracticeConfig practiceConfig = null;
        private int remainTaskCnt = 0;
        RealmPracticeModel practiceModel { get { return ModelCenter.Instance.GetModel<RealmPracticeModel>(); } }

        private void OnEnable()
        {
            practiceModel.AchieveModel.achievementProgressUpdateEvent += RefreshProgress;
        }

        private void OnDisable()
        {
            practiceModel.AchieveModel.achievementProgressUpdateEvent -= RefreshProgress;
        }

        public void InitModel(RealmPracticeConfig config)
        {
            achieve = null;
            int curNum = practiceModel.SetAchievement(config.AchieveID, out achieve);
            if (achieve == null) return;

            practiceConfig = config;
            remainTaskCnt = config.AchieveID.Length - curNum;
            successConfig = SuccessConfig.Get(achieve.id);

            InitUI();
        }

        private void InitUI()
        {
            taskName.text = AchievementModel.ParseAchievementDescription(achieve.id);
            itemIcon.SetSprite(practiceConfig.Icon);
            RefreshRemainTaskCnt();
            RefreshTaskProgress();
            RefreshTaskState();
            RefreshTaskReward();
        }

        private void RefreshRemainTaskCnt()
        {
            remainNumText.text = Language.Get("RealmPractice113", remainTaskCnt);
            if (achieve.completed)
            {
                remainNumText.gameObject.SetActive(false);
            }
            else
            {
                if (practiceConfig.Type == 1)
                {
                    remainNumText.gameObject.SetActive(true);
                }
                else
                {
                    remainNumText.gameObject.SetActive(false);
                }
            }

        }

        private void RefreshTaskProgress()
        {
            string s = "";
            if (achieve.completed)
            {
                string maxProgress = UIHelper.ReplaceLargeNum(successConfig.NeedCnt);
                 s = StringUtility.Contact(maxProgress, "/", maxProgress);
            }
            else
            {
                s = StringUtility.Contact(UIHelper.ReplaceLargeNum(achieve.progress), "/", UIHelper.ReplaceLargeNum(successConfig.NeedCnt));
            }
         
            taskProgress.text = Language.Get("RealmPractice111", s);
        }

        private void RefreshTaskState()
        {
            doTaskBtn.onClick.RemoveAllListeners();
            if (achieve.completed)
            {
                doTaskText.text = Language.Get("RealmPractice110");
                doTaskBtn.gameObject.SetActive(false);
                receiveEffect.gameObject.SetActive(false);
                haveReceiveImage.SetActive(true);
            }
            else
            {
                doTaskBtn.gameObject.SetActive(true);
                haveReceiveImage.SetActive(false);
                if (Achievement.IsReach(achieve.id, achieve.progress))
                {
                    doTaskText.text = Language.Get("RealmPractice109");
                    doTaskImg.SetSprite("JingJieIcon2");
                    doTaskBtn.onClick.AddListener(() => { OnClickReceiveReward(achieve.id); });
                    receiveEffect.gameObject.SetActive(true);
                    practiceModel.RefreshAchieveState(achieve.id);
                }
                else
                {
                    doTaskImg.SetSprite("JingJieIcon1");
                    doTaskText.text = Language.Get("RealmPractice108");
                    doTaskBtn.onClick.AddListener(() => { OnClickGoTo(); });
                    receiveEffect.gameObject.SetActive(false);
                }
            }
        }

        private void RefreshTaskReward()
        {
            for (int i = 0; i < taskRewardImglist.Count; i++)
            {
                taskRewardImglist[i].gameObject.SetActive(false);
            }

            int rewardLength1 = achieve.rewardCurrency.Length;
            for (int k = 0; k < rewardLength1; k++)
            {
                taskRewardImglist[k].gameObject.SetActive(true);
                UIHelper.SetIconWithMoneyType(taskRewardImglist[k], achieve.rewardCurrency[k].id);
                taskRewardCntlist[k].text = UIHelper.ReplaceLargeNum(achieve.rewardCurrency[k].count);
            }

            for (int j = 0; j < achieve.rewardItem.Length; j++)
            {
                taskRewardImglist[rewardLength1 + j].gameObject.SetActive(true);
                ItemConfig tagItemModel = ItemConfig.Get(achieve.rewardItem[j].id);
                if (tagItemModel != null)
                {
                    taskRewardImglist[rewardLength1 + j].SetSprite(tagItemModel.IconKey);
                }
                taskRewardCntlist[rewardLength1 + j].text = UIHelper.ReplaceLargeNum(achieve.rewardItem[j].count);
            }
        }

        private void OnClickReceiveReward(int id)
        {
            practiceModel.AchieveModel.GetAchievementReward(id);
        }

        private void OnClickGoTo()
        {
            if (achieve == null) return;
            ModelCenter.Instance.GetModel<AchievementModel>().GotoCompleteAchievement(achieve.id);
        }

        private void RefreshProgress(int id)
        {
            if (id != achieve.id) return;
            RefreshTaskState();
            RefreshTaskProgress();
        }
    }
}