using Thousandto.Code.Center;
using Thousandto.Core.Base;
using UnityEngine;
using Thousandto.Cfg.Data;
using Thousandto.CoreSDK;
using Thousandto.CoreSDK.Event;
using Thousandto.Code.Global;
using MSG_backpack;
using System.Net;
using System.Text;
using System.Collections.Generic;
using System.IO;
using UnityEngine.Networking;
using System.Collections;
using Thousandto.Plugins.Common;
using EventManager = UnityEngine.Gonbest.MagicCube.EventManager;
using EventSystemHandler = UnityEngine.Gonbest.MagicCube.EventSystemHandler;
using JSONNode = UnityEngine.Gonbest.MagicCube.JSONNode;
using JSON = UnityEngine.Gonbest.MagicCube.JSON;
using PathUtils = UnityEngine.Gonbest.MagicCube.PathUtils;
using CoroutinePool = UnityEngine.Gonbest.MagicCube.CoroutinePool;
using StringUtils = UnityEngine.Gonbest.MagicCube.StringUtils;
using AppPersistData = UnityEngine.Gonbest.MagicCube.AppPersistData;
using System;
using UnityEngine.Gonbest.MagicCube;
using BestHTTP.WebSocket;

namespace Thousandto.Code.Logic
{
    /// <summary>
    /// SDK 接入的管理类
    /// </summary>
    public class SDKSystem
    {
        #region //私有变量

        //保存的重置数据 物品ID,物品名称,人民币
        private string _itemId;
        private string _itemName;
        private float _rmb;

        //是否从sdk界面点击切换账号
        private bool _isLogoutFromSDKUI = true;

        private string _platformName = "defalt";
        private string _savePlayerId = "";
        private string _hasSendPowerInfoMsg = PlayerPrefs.GetString("HAS_SEND_POWERINFO");

        //LocalVersion.xml的fgi
        private int _localFgi = 0;
        //游戏版本号
        private string _appVersion = "1.0.0.0";

        // 绿岸获取商品列表 请求url
        private string _defaultPayReqUrl = string.Format("{0}/api/goods/list.do?app_id=16&chn_id=73", SDKCacheData.DefaultURL);

        private string PayReqUrl
        {
            get
            {
                if (string.IsNullOrEmpty(SDKCacheData.AppID))
                {
                    return _defaultPayReqUrl;
                }
                else
                {
                    _defaultPayReqUrl = string.Format("{0}/api/goods/list.do?app_id={1}&chn_id={2}",
                    GameCenter.SDKSystem.SDKImplement.GetServerUrl(),
                    SDKCacheData.AppID,
                    SDKCacheData.ChannelID);
                }
                return _defaultPayReqUrl;
            }
        }
        //缓存的渠道名字
        private string _cacheChnnelName = null;
        //缓存的当前货币符号
        private string _cacheMoneySign = null;

        /// <summary>
        /// 获取QQ大厅启动的参数
        /// </summary>
        /// <returns></returns>
        public Dictionary<string, string> GetPCParams()
        {
            return FuncellSDK.Instance.GetPCParams();
        }
        #endregion

        #region //成员和属性
        //是否新创建角色的标记
        public bool IsCreatePlayerFlag { get; set; }
        public long CreateRoleTime { get; set; }
        public string PlatformName
        {
            get
            {
                return _platformName = SDKBridge.GetPlatformName();
            }
        }

        /// <summary>
        /// 获取LocalVersion.xml的FGI，用作渠道判断
        /// </summary>
        public int LocalFGI
        {
            get
            {
                //取一次就行了，这个值不会变
                if (_localFgi != 0)
                {
                    return _localFgi;
                }
                if (AppManager.Instance.LocalVersionData.ContainsKey("fgi"))
                {
                    string fgi = AppManager.Instance.LocalVersionData["fgi"];
                    int.TryParse(fgi, out _localFgi);
                }
                return _localFgi;
            }
        }

        public string AppVersion
        {
            get
            {
                if (_appVersion != "1.0.0.0")
                {
                    return _appVersion;
                }
                if (AppManager.Instance.LocalVersionData.ContainsKey("local_app_version"))
                {
                    _appVersion = AppManager.Instance.LocalVersionData["local_app_version"];
                }
                return _appVersion;
            }
        }

        //SDK底层的一些具体实现
        public CoreSDK.FuncellSDK SDKImplement
        {
            get
            {
                return CoreSDK.FuncellSDK.Instance;
            }
        }
        #endregion

        #region 构造函数、初始化
        public SDKSystem()
        {
            RegFixEventHandle(SDKEventDefine.SDK_CALLBACK_LOGIN_SUCCESS, OnSDKLoginSuccess);
            RegFixEventHandle(SDKEventDefine.SDK_CALLBACK_LOGIN_FAIL, OnSDKLoginFailOrCancel);
            RegFixEventHandle(SDKEventDefine.SDK_CALLBACK_LOGIN_SWITCH_ACCOUNT, OnSDKLoginSwitchAccount);
            RegFixEventHandle(SDKEventDefine.SDK_CALLBACK_LOGIN_LOGOUT_ACCOUNT, OnSDKLogoutAccount);
            RegFixEventHandle(SDKEventDefine.SDK_CALLBACK_PAY_CALLBACK, OnSDKPayCallback);
            RegFixEventHandle(SDKEventDefine.SDK_CALLBACK_PAY_ORDER_BACK, OnSDKPayOrderback);
            RegFixEventHandle(SDKEventDefine.SDK_COMMIT_TO_APPSTORE, OnCommitToAppstore);
            RegFixEventHandle(SDKEventDefine.SDK_CALLBACK_SERVERS_LOADED, OnServerLoadedCallback);
            RegFixEventHandle(SDKEventDefine.SDK_CALLBACK_NOTICE, OnNoticeCallback);
            RegFixEventHandle(SDKEventDefine.SDK_CALLBACK_REALNAME_RESULT, OnRealNameCallback);
            RegFixEventHandle((int)LogicEventDefine.EID_EVENT_RECONNECT_SUCCESS, OnReConnectSuccess);
            RegFixEventHandle((int)LogicEventDefine.EID_EVENT_FIGHT_POWER_CHANGED, OnFightPowerChanged);
            RegFixEventHandle((int)LogicEventDefine.EID_EVENT_WELFARE_CARD_RECEIVED, OnWelfareCardUpdate);

            ClearFixEvent(SDKEventDefine.SDK_COMMIT_TO_APPSTORE);
            RegFixEventHandle(SDKEventDefine.SDK_COMMIT_TO_APPSTORE, (_obj, _sender) => { });

            ClearFixEvent(SDKEventDefine.SDK_EXIT_CALL);
            RegFixEventHandle(SDKEventDefine.SDK_EXIT_CALL, (_obj, _sender) =>
            {
                GameCenter.MsgPromptSystem.ShowMsgBox(DeclareMessageString.Get(DeclareMessageString.Exit_Game),
                (s) =>
                {
                    if (s == MsgBoxResultCode.Button2)
                    {
                        //退出游戏
                        CoreSDK.FuncellSDK.Instance.EventExit();
#if UNITY_STANDALONE_WIN
                        AppPersistData.WantExitResult = true;
#endif
                        Application.Quit();
                    }
                });
            });

            //清除TryExitGame的消息,然后再注册---在SDKRootScript也注册了这个消息
            ClearFixEvent(SDKEventDefine.SDK_TRY_EXIT_GAME);
            RegFixEventHandle(SDKEventDefine.SDK_TRY_EXIT_GAME,
                (_obj, _sender) =>
                {
                    //如果当前注册了关闭当前窗体的事件,那么就执行关闭当前窗体的处理
                    if (GameCenter.EventManager.IsExistEventHandler((int)LogicEventDefine.EID_EVENT_HIDE_CURRENT_FORM))
                    {
                        //将sdk的事件转接到游戏内的事件
                        GameCenter.PushFixEvent(LogicEventDefine.EID_EVENT_HIDE_CURRENT_FORM);
                    }
                    else
                    {
                        ExitGame();
                    }
                }
            );
            //RegFixEventHandle(SDKEventDefine.SDK_VOICE_ROOM_PERSON_NUM, OnVoiceRoomNumberResponse);
            //RegFixEventHandle(SDKEventDefine.SDK_VOICE_ROOM_ENTER_FAIL, OnJoinVoiceRoomFail);
            ClearFixEvent(SDKEventDefine.SDK_CLIP_IMG_CALLBACK);
            RegFixEventHandle(SDKEventDefine.SDK_CLIP_IMG_CALLBACK,
                    (_obj, _sender) =>
                    {
                        string path = _obj as string;
                        string bytesBase64 = _sender as string;
                        if (string.IsNullOrEmpty(path))
                        {
                            GameCenter.MsgPromptSystem.ShowPrompt("Error ImagePath Is Null");
                            return;
                        }
                        if (string.IsNullOrEmpty(bytesBase64))
                        {
                            GameCenter.MsgPromptSystem.ShowPrompt("Error ImageData Is Null");
                            return;
                        }
                        byte[] bytes = Convert.FromBase64String(bytesBase64);
                        //保存到文件
                        File.WriteAllBytes(path, bytes);
                        //将sdk的事件转接到游戏内的事件
                        GameCenter.PushFixEvent(LogicEventDefine.EID_EVENT_CLIP_IMG_CALLBACK, path);
                    }
                );

#if UNITY_ANDROID || UNITY_IPHONE
            //正式环境，从app包中读取app版本
#if !UNITY_EDITOR
            if (CoreSDK.FuncellSDK.Instance.UseSDK)
            {
                string appVers = "";
                string resVers = "";
                Update.Manager.UpdateManager.Instance.GetVersionInfo(out appVers, out resVers);
            }
#endif
#endif

#if UNITY_STANDALONE_WIN
            AppPersistData.WantExitResult = false;
            Application.wantsToQuit += () =>
            {
                if (!AppPersistData.WantExitResult)
                {
                    if (GameCenter.MainFunctionSystem.FunctionIsVisible(FunctionStartIdCode.ExitRewardTips))
                    {
                        GameCenter.MainFunctionSystem.DoFunctionCallBack(FunctionStartIdCode.ExitRewardTips, 0);
                    }
                    else
                    {
                        GameCenter.MsgPromptSystem.ShowMsgBox(DeclareMessageString.Get(DeclareMessageString.Exit_Game),
                          (s) =>
                          {
                              if (s == MsgBoxResultCode.Button2)
                              {
                                  //退出游戏
                                  CoreSDK.FuncellSDK.Instance.EventExit();
                                  AppPersistData.WantExitResult = true;
                                  Application.Quit();
                              }
                          });
                    }
                }
                return AppPersistData.WantExitResult;
            };
#endif
        }

        public void Initalize()
        {
            //增加计时器，每天00.01定时执行操作，循环的，主要是上海那边说要登记下第二天还没下线的玩家
            GameCenter.TimerEventSystem.AddTimeStampDayEvent(1, 1, true, null, SendLoginTypeMsg);
        }

        public void Unitialize()
        {

        }
        #endregion

        #region 下载充值列表的数据
        /// <summary>
        /// 下载充值列表
        /// </summary>
        public void DownLoadPayList()
        {
            GameCenter.LuaSystem.Adaptor.DownLoadPayList();
        }
        #endregion

        #region // 逻辑代码, 设置数据，提供充值接口。 以下接口必须都被调用了，充值界面才能打开

        //参数1为计时器id，参数2为有效期剩余时间
        private void SendLoginTypeMsg(int eventId, double remainTime, object param)
        {
            //发送统计数据给SDK
            SDKCacheData.LoginType = "3";
            GameCenter.SDKSystem.SendEventServerInfo();
        }

        //设置角色信息
        public void SetRoleInfo()
        {
            if (SkipSDK()) return;

            var player = GameCenter.GameSceneSystem.GetLocalPlayer();
            if (player == null) return;
            //保存vip等级
            SDKCacheData.RoleVipLevel = player.VipLevel.ToString();
            var occName = GetOccName(player.Occ);
            var gold = GameCenter.ItemContianerSystem.GetEconomyWithType(ItemTypeCode.Gold);
            //角色性别
            int roleSex = DeclarePlayerOccupation.Get((int)player.Occ).Sex;
            //当前地图ID
            int mapId = GameCenter.GameSceneSystem.GetActivedMapID();
            FuncellSDK.Instance.SetRoleInfo
                (
                    player.Name,
                    player.ID.ToString(),
                    occName,
                    player.FightPower,
                    gold,
                    player.Level,
                    roleSex,
                    mapId,
                    AppVersion,
                    CreateRoleTime
                );
        }
        //获取职业的名字
        private string GetOccName(int occ)
        {
            var cfg = DeclarePlayerOccupation.Get(occ);
            if (cfg != null) return cfg.JobName;
            return "";
        }

        //初始化角色等级信息，当第一次进入游戏主场景时
        public void SetLevelInfoWhileFirstEnterGame(int level)
        {
            if (SkipSDK()) return;
            CoreSDK.FuncellSDK.Instance.SetLevelInfoWhileFirstEnterGame(level);
            Debug.Log("初始化玩家等级： #" + level);
        }

        //设置角色元宝余额
        public void SetGoldBalance(int balance)
        {
            if (SkipSDK()) return;
            CoreSDK.FuncellSDK.Instance.SetGoldBalance(balance);
        }

        //设置公会信息
        public void SetGuildName(string name)
        {
            if (SkipSDK()) return;
            CoreSDK.FuncellSDK.Instance.SetGuildName(name);
        }

        //设置服务器信息,选择服务器的时候就设置了
        public void SetServerInfo(string serverId, string serverName)
        {
            if (SkipSDK()) return;
            CoreSDK.FuncellSDK.Instance.SetServerInfo(serverId, serverName);
        }
        #endregion

        #region //主动调用SDK的功能， 充值、登陆、账号切换、等级变化、订单查询

        public void Login()
        {
            PlayerEventRecord.Instance.RecordEvent(PlayerEventEnum.ActionSDKLoginBegin);
            CoreSDK.FuncellSDK.Instance.SDKLogin();
        }

        public void Logout()
        {
            CoreSDK.FuncellSDK.Instance.SDKLogout();
        }

        //登出
        public void SDKLogout()
        {
            _isLogoutFromSDKUI = false;
            CoreSDK.FuncellSDK.Instance.SDKLogout();
        }

        public void SwitchAccount()
        {
            CoreSDK.FuncellSDK.Instance.SwitchAccount();
        }

        public void DealMessage(int id)
        {
            if (SkipSDK()) return;
            CoreSDK.FuncellSDK.Instance.DealMessage(id);
        }

        /// <summary>
        /// 升级时的时间
        /// </summary>
        /// <param name="levelUpTime"></param>
        public void SetLevelUpTime(long levelUpTime)
        {
            if (SkipSDK()) return;
            CoreSDK.FuncellSDK.Instance.SetRoleLevelupTime(levelUpTime);
        }

        public void ExitGame()
        {
            if (!GameCenter.LuaSystem.IsInit) return;
            int maxActive = GameCenter.LuaSystem.Adaptor.GetDailyMaxActive();
            long active = GameCenter.ItemContianerSystem.GetEconomyWithType(Code.Global.ItemTypeCode.ActivePoint);
            //需要网络是连接的
            if ((maxActive > active || active > 0) && GameCenter.Networker.IsConnected)
            {
                if (GameCenter.MainFunctionSystem.FunctionIsVisible(FunctionStartIdCode.ExitRewardTips))
                {
                    GameCenter.MainFunctionSystem.DoFunctionCallBack(FunctionStartIdCode.ExitRewardTips, 0);
                }
                else
                {
                    //GameCenter.MsgPromptSystem.ShowMsgBox(DeclareMessageString.Get(DeclareMessageString.Exit_Game), (code) =>
                    //{
                    //    if (code == MsgBoxResultCode.Button2)
                    //    {
                    //        Application.Quit();
                    //    }
                    //});
                    if (!FuncellSDK.Instance.ExitGame())
                    {
#if UNITY_STANDALONE_WIN
                        AppPersistData.WantExitResult = true;
#endif
                        Application.Quit();
                    }
                }
            }
            else
            {
                //GameCenter.MsgPromptSystem.ShowMsgBox(DeclareMessageString.Get(DeclareMessageString.Exit_Game), (code) =>
                //{
                //    if (code == MsgBoxResultCode.Button2)
                //    {
                //        Application.Quit();
                //    }
                //});
                if (!FuncellSDK.Instance.ExitGame())
                {
#if UNITY_STANDALONE_WIN
                        AppPersistData.WantExitResult = true;
#endif
                    Application.Quit();
                }
            }
        }

        //充值接口
        public void Pay(string itemId, string itemName, int buyNum, float price, string goodsDealType, string payNotifyUrl, string rechargeType = "1", string extension = "1", int cfgId = 0, string orderNo = "0")
        {
            //先保存数据
            _rmb = price;
            _itemId = itemId;
            _itemName = itemName;

            SetRoleInfo();
            Debug.LogFormat(
                "SDKSystem Pay: " +
                "itemId = {0}, " +
                "itemName = {1}, " +
                "buyNum = {2}, " +
                "price = {3}, " +
                "goodsDealType = {4}, " +
                "payNotifyUrl = {5}, " +
                "rechargeType = {6}, " +
                "extension = {7}, " +
                "cfgId = {8}, " +
                "orderNo = {9}",
                itemId, itemName, buyNum, price, goodsDealType, payNotifyUrl, rechargeType, extension, cfgId, orderNo);
#if UNITY_EDITOR
            //编辑器模式下使用GM命令进行充值
            MSG_Chat.ChatReqCS req = new MSG_Chat.ChatReqCS();
            req.chattype = 0;
            req.recRoleId = 0;
            req.condition = string.Format("&rechargeid {0}", itemId);
            req.chatchannel = 0;
            req.Send();
#else
            FuncellSDK.Instance.Pay(itemId, itemName, buyNum, price, goodsDealType, payNotifyUrl, rechargeType, extension, cfgId, orderNo);
#endif
        }

        //调用SDK等级变化接口
        public void CallLevelChange(int level)
        {
            if (SkipSDK()) return;

            CoreSDK.FuncellSDK.Instance.OnLevelChange(level);
        }

        public void SendEventLogin()
        {
            if (SkipSDK()) return;
            CoreSDK.FuncellSDK.Instance.SendEventLogin();
        }

        public void EventExit()
        {
            if (SkipSDK()) return;
            CoreSDK.FuncellSDK.Instance.EventExit();
        }

        public void SendEventCreateRole()
        {
            if (SkipSDK()) return;
            CoreSDK.FuncellSDK.Instance.SendEventCreatRole();
        }

        public void SendEventServerInfo()
        {
            if (SkipSDK()) return;
            CoreSDK.FuncellSDK.Instance.SendEventServerInfo();
        }

        public void SendEventLevelUp()
        {
            if (SkipSDK()) return;
            CoreSDK.FuncellSDK.Instance.SendEventLevelUp();
        }

        public void SendEventTaskFinsh(int taskId, string taskType)
        {
            if (SkipSDK()) return;
            CoreSDK.FuncellSDK.Instance.SendEventTaskFinsh(taskId, taskType);
        }

        public void InstallApp(string pathOrUrl)
        {
            if (SkipSDK()) return;
            CoreSDK.FuncellSDK.Instance.InstallApp(pathOrUrl);
        }
        #endregion

        #region//SDK 回调相关

        //SDK登陆成功
        private void OnSDKLoginSuccess(object obj, object sender)
        {
            string msg = obj as string;
            if (msg == null || string.IsNullOrEmpty(msg))
            {
                Debug.LogError("SDK登陆失败，返回msg为null");
                GameCenter.PushFixEvent(LogicEventDefine.EID_EVENT_UPDATE_RECORDER_STEP, new object[] { Thousandto.Update.Recorder.StepType.StartSDKLogin, 1, "SDK登陆失败，返回msg为null" });
                return;
            }

            //如果是在游戏场景，则登陆无效。比如应用宝在返回主界面一段时间后再切回游戏会触发sdk授权成功的回调
            //这个时候是无效的
            if (GameCenter.GameStateSystem != null &&
                GameCenter.GameStateSystem.GetCurState() != null &&
                (GameStateId)GameCenter.GameStateSystem.GetCurState().GetStateId() == GameStateId.World)
            {
                Debug.LogError("SDK登陆无效，在游戏主场景中触发了登陆回调 -->" + msg);
                return;
            }

            GameCenter.MsgPromptSystem.ShowMsgBox(DeclareMessageString.Get(DeclareMessageString.C_LOGINFORM_MSGBOX_CONNECTING),
                null, null, null, false, true, 5, MsgInfoPriority.Highest, 0.3f);

            var json = JSON.Parse(msg);

            //账户名
            SDKCacheData.PlatUserName = json["username"].Value;
            //UID
            SDKCacheData.PlatformUID = json["userID"].Value;
            SDKCacheData.CPUserID = json["cpUserID"].Value;
            SDKCacheData.CPUserName = json["cpUserName"].Value;
            SDKCacheData.Token = json["token"].Value;
            //应用编号
            SDKCacheData.AppID = json["appID"].Value;
            //渠道编号
            SDKCacheData.ChannelID = json["channelID"].Value;
            int _channelID = 0;
            int.TryParse(json["channelID"].Value, out _channelID);
            SDKBridge.PlatformID = _channelID;
            Thousandto.Update.Recorder.StepRecorder.SetChannelName(SDKBridge.GetPlatformName());
            Thousandto.Update.Recorder.StepRecorder.SetAccountID(SDKCacheData.PlatformUID);

            GameCenter.PushFixEvent(LogicEventDefine.EID_EVENT_UPDATE_RECORDER_STEP, new object[] { Thousandto.Update.Recorder.StepType.StartSDKLogin });

            //GameCenter.LoginSystem.Account = "";
            //GameCenter.ServerListSystem.DownloadServerList();
            GameCenter.PushFixEvent(LogicEventDefine.EID_EVENT_SDK_LOGIN_SUCCESS);
            PlayerPrefs.SetString(GameGlobalData.PlayerPrefs_Account, SDKCacheData.PlatUserName);
        }

        private void OnSDKLogoutAccount(object obj, object sender)
        {
            GameCenter.GameSceneSystem.ReturnToLogin();
        }

        //切换账号，返回登陆界面
        private void OnSDKLoginSwitchAccount(object obj, object sender)
        {
            //直接调用返回登陆
            GameCenter.GameSceneSystem.ReturnToLogin();
        }

        //SDK登陆失败或取消
        private void OnSDKLoginFailOrCancel(object obj, object sender)
        {
            string msg = obj as string;
            if (msg == null || msg == "")
            {
                Debug.Log("登陆失败");
                return;
            }

            if (msg.IndexOf("0") > 0)
            {
                Debug.Log("登陆出错");
                if (LanguageSystem.Lang == LanguageConstDefine.TW)
                {
                    GameCenter.MsgPromptSystem.ShowMsgBox("目前您的網路不穩，建議您完整退出遊戲再重新嘗試登入", DeclareMessageString.Get(DeclareMessageString.C_MSGBOX_OK));
                }
            }

            if (msg.IndexOf("1") > 0)
            {
                Debug.Log("登陆取消");
            }
        }

        /// <summary>
        /// 充值回调，通知服务器加元宝
        /// </summary>
        /// <param name="obj"></param>
        private void OnSDKPayCallback(object obj, object sender)
        {
            GameCenter.PushFixEvent(UIEventDefine.UI_WAITING_CLOSE);
            string msg = obj as string;
            if (msg == null || string.IsNullOrEmpty(msg))
            {
                UnityEngine.Debug.LogError("充值返回订单信息是空的： " + msg);
                return;
            }

            UnityEngine.Debug.LogError("充值回调，通知服务器加元宝 OnSDKPayCallback： " + obj);

            var node = JSONNode.Parse(msg);
            string token = node["accessToken"].Value;
            string orderId = node["purchase_order"].Value;

            if (token == null || orderId == null)
            {
                UnityEngine.Debug.LogError("充值返回订单信息有问题： " + msg);
                return;
            }

            if (orderId == "")
            {
                UnityEngine.Debug.Log("SDK没有返回订单号，充值失败了！" + msg);
                return;
            }
        }


        //订单查询结果
        private void OnSDKPayOrderback(object obj, object sender)
        {
            GameCenter.PushFixEvent(UIEventDefine.UI_WAITING_CLOSE);

            UnityEngine.Debug.LogError("11111订单查询结果 OnSDKPayOrderback： " + obj);
            if ((Thousandto.CoreSDK.SDKBridge.SDKPlatform & SDKPlatform.Normal) == 0)
            {
                return;
            }
            if (obj == null || string.IsNullOrEmpty((string)obj))
            {
                UnityEngine.Debug.Log("没有漏单");
                return;
            }
            UnityEngine.Debug.LogError("22222订单查询结果 OnSDKPayOrderback： " + obj);

            //SendReqGetGold((string)obj);
            ResetPayData();
        }

        private void OnCommitToAppstore(object obj, object sender)
        {
            string url = obj as string;
            if (string.IsNullOrEmpty(url))
            {
                UnityEngine.Debug.LogError("OnCommitToAppstore: error url-" + obj);
                return;
            }

            CoreSDK.FuncellSDK.Instance.CommitToAppStore(url);
        }

        private void OnServerLoadedCallback(object obj, object sender)
        {
            string json = obj as string;
            if (string.IsNullOrEmpty(json))
            {
                UnityEngine.Debug.LogError("OnServerLoadedCallback: error servers -" + obj);
                return;
            }
            var node = JSONNode.Parse(json);
            //保存SDK过来的服务器列表
            SDKCacheData.ServersJson = node["servers"];
        }

        private void OnNoticeCallback(object obj, object sender)
        {
            string notice = obj as string;
            if (string.IsNullOrEmpty(notice))
            {
                UnityEngine.Debug.LogError("OnNoticeCallback: error notice-" + obj);
                return;
            }
            //保存SDK过来的公告的内容
            SDKCacheData.NoticeContent = notice;
        }

        private void OnReConnectSuccess(object obj, object sender)
        {
            //登录类型,普通登录 = 1，掉线重连 = 2 ，跨天登记 = 3
            SDKCacheData.LoginType = "2";
            GameCenter.SDKSystem.SendEventServerInfo();
        }

        //战力改变
        private void OnFightPowerChanged(object obj, object sender = null)
        {
            //战力达到100万的统计，中度活跃用户
            //达到100万并且没有发送过
            string _playerRoleId = "";
            var localPlayer = GameCenter.GameSceneSystem.GetLocalPlayer();
            if (null == localPlayer)
            {
                return;
            }
            _playerRoleId = localPlayer.ID.ToString();
            //战力小于100万就不走了
            if (localPlayer.FightPower < 1000000)
            {
                return;
            }
            //加个判断，少点IO导致的GC
            if (string.IsNullOrEmpty(_savePlayerId))
            {
                _savePlayerId = PlayerPrefs.GetString("PLAYER_ROLEID");
                if (string.IsNullOrEmpty(_savePlayerId))
                {
                    PlayerPrefs.SetString("PLAYER_ROLEID", localPlayer.ID.ToString());
                    _savePlayerId = localPlayer.ID.ToString();
                }
                else
                {
                    //not a same role, save the player id
                    if (!_playerRoleId.Equals(_savePlayerId))
                    {
                        PlayerPrefs.SetString("PLAYER_ROLEID", localPlayer.ID.ToString());
                        _savePlayerId = localPlayer.ID.ToString();
                    }
                }
            }
            if (!_hasSendPowerInfoMsg.Equals(_savePlayerId))
            {
                PlayerPrefs.SetString("HAS_SEND_POWERINFO", "");
                _hasSendPowerInfoMsg = "";
            }
            //判断是否是同一个角色，并且还没发过统计消息
            if (localPlayer.ID.ToString().Equals(_savePlayerId) && string.IsNullOrEmpty(_hasSendPowerInfoMsg) && localPlayer.FightPower >= 1000000)
            {
                string playerID = localPlayer.ID.ToString();
                long fightPower = localPlayer.FightPower;
                PlayerPrefs.SetString("HAS_SEND_POWERINFO", playerID);
                _hasSendPowerInfoMsg = playerID;
                SDKCacheData.FightPower = fightPower.ToString();
                FuncellSDK.Instance.EventFightPower();
            }
        }

        //购买月卡周卡
        private void OnWelfareCardUpdate(object obj, object sender)
        {
            if (obj != null)
            {
                int id = int.Parse(obj.ToString());
                DeclareMonthCard cfg = DeclareMonthCard.Get(id);
                if (cfg != null)
                {
                    //周卡
                    if (cfg.Day < 30 && cfg.Day > 0)
                    {
                        FuncellSDK.Instance.EventWMCard(WeekMonthCard.CARD_WEEK);
                    }
                    //月卡
                    else
                    {
                        FuncellSDK.Instance.EventWMCard(WeekMonthCard.CARD_MONTH);
                    }
                }
            }
        }

        /// <summary>
        /// 实名认证的结果
        /// </summary>
        /// <param name="obj"></param>
        /// <param name="sender"></param>
        private void OnRealNameCallback(object obj, object sender)
        {
            UnityEngine.Debug.LogError("OnRealNameCallback: result-" + obj);
            string result = obj as string;
            if (string.IsNullOrEmpty(result))
            {
                UnityEngine.Debug.LogError("OnRealNameCallback: error result-" + obj);
                return;
            }
            var node = JSONNode.Parse(result);
            //这个是成功或者失败的标记
            bool res = node["result"].AsBool;
            //code 0:实名认证成功 
            //     2014:身份证错误
            //     2015:姓名错误
            int code = node["code"].AsInt;
            //认证成功了
            if (res || code == 0)
            {
                var msg = new MSG_Register.ReqNoticeCertifySuccess();
                msg.Send();
                GameCenter.MsgPromptSystem.ShowPrompt(Thousandto.Cfg.Data.DeclareMessageString.Get(Thousandto.Cfg.Data.DeclareMessageString.C_SHIMING_TONGGUO));
                GameCenter.MainFunctionSystem.SetFunctionVisible(FunctionStartIdCode.Certification, false);
            }
            //认证失败
            else
            {
                switch (code)
                {
                    //身份证错误
                    case 2014:
                        GameCenter.MsgPromptSystem.ShowPrompt(Thousandto.Cfg.Data.DeclareMessageString.Get(Thousandto.Cfg.Data.DeclareMessageString.C_SFYZSB));
                        break;
                    //姓名错误
                    case 2015:
                        GameCenter.MsgPromptSystem.ShowPrompt(Thousandto.Cfg.Data.DeclareMessageString.Get(Thousandto.Cfg.Data.DeclareMessageString.C_XMYZSB));
                        break;
                    default:
                        GameCenter.MsgPromptSystem.ShowPrompt(Thousandto.Cfg.Data.DeclareMessageString.Get(Thousandto.Cfg.Data.DeclareMessageString.C_SMYZSB));
                        break;
                }
            }
        }

        private void SendReqGetGold(string orderId)
        {
            //MSG_Recharge.ReqGetRechargeGold req = new MSG_Recharge.ReqGetRechargeGold();
            //req.access_token = SDKCacheData.Token;
            //req.orderId = orderId;
            //req.Send();
        }

        //重置保存的充值数据
        private void ResetPayData()
        {
            _itemId = "";
            _itemName = "";
            _rmb = 0;
        }

        private bool SkipSDK()
        {
#if UNITY_EDITOR
            return true;
#endif
            return false;
        }

        /// <summary>
        /// 获取当前网络类型
        /// </summary>
        /// <returns>WIFI 2G 3G 4G N/A</returns>
        public string GetNetworkType()
        {
            return CoreSDK.FuncellSDK.Instance.GetNetworkType();
        }

        private bool GetIsSDKLogin()
        {
            //如果这个标记是true，那么肯定是登陆成功了，这个是SDK初始化成功返回的消息，然后设置的标记
            if (CoreSDK.FuncellSDK.Instance.SDKInitFinish)
            {
                return true;
            }
            //根据渠道ID来判断是否是SDK登陆的,这个是SDK登陆成功之后就能获取到的
            return SDKInitialize.RumtimePlatform > MyRuntimePlatform.StandaloneEditor && !string.IsNullOrEmpty(SDKCacheData.Token);
        }

        /// <summary>
        /// 是否SDK登陆
        /// 备注，这里单独写个函数多此一举是因为IOS那边打内网包（类:BuildEditor.UI.PackageWindow）需要替换成 return false; dinghuaqiang -2020/05/19
        /// </summary>
        /// <returns></returns>
        public bool IsSDKLogin()
        {
            return GetIsSDKLogin();
        }

        /// <summary>
        /// 是否是模拟器
        /// </summary>
        /// <returns></returns>
        public bool IsEmulator()
        {
            return FuncellSDK.Instance.IsEmulator();
        }

        /// <summary>
        /// 判断是否已经实名制了
        /// </summary>
        /// <returns></returns>
        public bool IsRealNameAuthorized()
        {
            return FuncellSDK.Instance.IsRealNameAuthorized();
        }

        /// <summary>
        /// 调用实名制接口
        /// </summary>
        /// <param name="name"></param>
        /// <param name="idcard"></param>
        public void DoRealNameAuthority(string name, string idcard)
        {
            FuncellSDK.Instance.DoRealNameAuthority(name, idcard);
        }

        /// <summary>
        /// 调用SDK重启App
        /// </summary>
        public void ReStartGame()
        {
            FuncellSDK.Instance.ReStartGame();
        }



        public void WebSocket()
        {
            WebSocket ws = new WebSocket(new Uri(""));
            ws.OnMessage = OnWebSocketMsgReceived;
            ws.Open();
            ws.Send("");
        }

        public void OnWebSocketMsgReceived(WebSocket webSocket, string message)
        {

        }



        #endregion

        #region 游戏统计
        public void ActionEvent(ActionEventCode code, string key, string value)
        {
            switch (code)
            {
                case ActionEventCode.CreateChar:
                    DealMessage(CoreSDK.PLATFORM_DEAL_TYPE.PDT_TOTAL_CREATEROLE, key, value);
                    break;
                case ActionEventCode.SelectChar:
                    //DealMessage(CoreSDK.PLATFORM_DEAL_TYPE., key, value);
                    break;
                case ActionEventCode.EnterServer:
                    DealMessage(CoreSDK.PLATFORM_DEAL_TYPE.PDT_TOTAL_ENTERGAME, key, value);
                    break;
                case ActionEventCode.ChargeSuccess:
                    //DealMessage(CoreSDK.PLATFORM_DEAL_TYPE.PDT_TOTAL_CREATEROLE, key, value);
                    break;
                case ActionEventCode.ChargeLevel:
                    //DealMessage(CoreSDK.PLATFORM_DEAL_TYPE.PDT_TOTAL_CREATEROLE, key, value);
                    break;
            }
        }

        /// <summary>
        /// 热云：自定义事件
        /// </summary>
        private void DealMessage(CoreSDK.PLATFORM_DEAL_TYPE eventCode, string key, string value)
        {
            CoreSDK.FuncellSDK.Instance.DealMessage((int)eventCode, value);
        }

        /// <summary>
        /// 货币改变
        /// </summary>
        /// <param name="coin"></param>
        public void ActionCoinChange(ResCoinChange coin)
        {
            int type = coin.changeCoin.type;
            long oldValue = GameCenter.ItemContianerSystem.GetEconomyWithType(type);
            long offsetValue = coin.changeCoin.value - oldValue;

            // 现在勇者没有真气，这里先把真气的判断暂时去掉
            if (type == ItemTypeCode.Exp)
            {
                return;
            }
            if (offsetValue > 0)
            {
                if (IsCoinType(type))
                {
                    //保存本次充值的元宝数量
                    SDKCacheData.RoleRechargeBalance = offsetValue.ToString();
                    //玩家剩余的元宝数量
                    SDKCacheData.RoleGoldBalance = coin.changeCoin.value.ToString();
                    EventManager.SharedInstance.PushFixEvent(SDKEventDefine.SDK_ENENT_ADD_GOLD_CALLBACK);
                    //ActionEvent(((ItemTypeCode)coin.changeCoin.type).ToString(), ActionItemChangeCode.Add.ToString(), offsetValue.ToString());
                }
            }
            else
            {
                if (IsCoinType(type))
                {
                    //ActionEvent(((ItemTypeCode)coin.changeCoin.type).ToString(), ActionItemChangeCode.Reduce.ToString(), offsetValue.ToString());
                }
            }
        }

        private bool IsCoinType(int type)
        {
            //只管蓝砖，这个才是真实发货
            switch (type)
            {
                case ItemTypeCode.Gold:
                    //case ItemTypeCode.BindGold:
                    //case ItemTypeCode.BindMoney:
                    return true;
            }
            return false;
        }
        #endregion

        #region 东南亚sdk特殊接口
        public void SetSDKLanguage()
        {
            CoreSDK.FuncellSDK.Instance.SetSDKLan();
        }
        #endregion

        #region 渠道判断
        //是否韩国GP平台
        public bool IsKRGP()
        {
            string chnnel = GetChnnelNameByCfg();
            return chnnel == Enum.GetName(ChannelName.KR.GetType(), ChannelName.KR);
            //return SDKBridge.IsKRGP();
        }

        //判断是否东南亚sdk
        public bool IsDongNanYaSDK()
        {
            string chnnel = GetChnnelNameByCfg();
            return chnnel == Enum.GetName(ChannelName.TH.GetType(), ChannelName.TH) || chnnel == Enum.GetName(ChannelName.VIE.GetType(), ChannelName.VIE);
            //return SDKBridge.IsDongNanYaSDK();
        }

        //判断是否港澳台sdk
        public bool IsGangAoTai()
        {
            string chnnel = GetChnnelNameByCfg();
            return chnnel == Enum.GetName(ChannelName.TW.GetType(), ChannelName.TW);
            //return SDKBridge.IsGangAoTai();
        }

        //判断是越南sdk
        public bool IsYueNan()
        {
            string chnnel = GetChnnelNameByCfg();
            return chnnel == Enum.GetName(ChannelName.VIE.GetType(), ChannelName.VIE);
        }

        //判断是日本sdk
        public bool IsJapan()
        {
            string chnnel = GetChnnelNameByCfg();
            return chnnel == Enum.GetName(ChannelName.JP.GetType(), ChannelName.JP);
        }

        //判断是否是PC版本QQ大厅
        public bool IsQQPC()
        {
            string chnnel = GetChnnelNameByCfg();
            return chnnel == Enum.GetName(ChannelName.QQ.GetType(), ChannelName.QQ);
        }

        /// <summary>
        /// 是否是4399渠道
        /// </summary>
        /// <returns></returns>
        public bool Is4399()
        {
            return SDKBridge.Is4399();
        }

        /// <summary>
        /// 根据配置表获取渠道名称
        /// </summary>
        /// <returns></returns>
        private string GetChnnelNameByCfg()
        {
            if (_cacheChnnelName == null)
            {
                _cacheChnnelName = "CH";
                var cfg = DeclareSdkplatform.Get(LocalFGI);
                if (cfg != null)
                {
                    _cacheChnnelName = cfg.Chanel;
                }
            }
            return _cacheChnnelName;
        }
        /// <summary>
        /// 根据配置表获取当前货币符号
        /// </summary>
        /// <param name="eid"></param>
        /// <param name="handler"></param>
        public string GeMoneySignByCfg()
        {
            if (_cacheMoneySign == null)
            {
                _cacheMoneySign = "¥";
                var cfg = DeclareSdkplatform.Get(LocalFGI);
                if (cfg != null)
                {
                    _cacheMoneySign = cfg.MoneySign;
                }
            }
            return _cacheMoneySign;
        }
        #endregion

        #region SDK事件处理
        public void RegFixEventHandle(int eid, EventSystemHandler handler)
        {
            EventManager.SharedInstance.RegFixEventHandle(eid, handler);

        }

        public void PushFixEvent(object target, int eid, object param, object sender)
        {
            EventManager.SharedInstance.PushFixEvent(eid, param, sender, target);
        }

        public void PushFixEvent(int eid, object obj = null)
        {
            EventManager.SharedInstance.PushFixEvent(eid, obj);
        }

        public void ClearFixEvent(int eid)
        {
            EventManager.SharedInstance.ClearFixEvent(eid);
        }

        public void UnRegFixEventHandle(int eventType, EventSystemHandler handler)
        {
            EventManager.SharedInstance.UnRegFixEventHandle(eventType, handler);
        }
        #endregion

        #region 其他的支撑函数
        //复制到剪贴板
        public void CopyToClipboard(string text)
        {
            CoreSDK.FuncellSDK.Instance.CopyToClipboard(text);
        }

        //头像 type: 0 从相册取， 1 拍照
        public void GetPhoto(int type, string path, int width, int height)
        {

            if (type == 0 || HardwareManager.MemoryInfo.GetFreeMemory() >= 350)
            {
#if UNITY_EDITOR
                try
                {
                    var filePath = UnityEditor.EditorUtility.OpenFilePanel("Change Layer Prefab Path", "", "jpg");
                    if (string.IsNullOrEmpty(filePath))
                    {
                        return;
                    }
                    var bytes = File.ReadAllBytes(filePath);
                    File.WriteAllBytes(path, bytes);
                    GameCenter.PushFixEvent(LogicEventDefine.EID_EVENT_CLIP_IMG_CALLBACK, path);
                }
                catch (Exception ex)
                {
                    Debug.LogError(ex.ToString());
                }
#else
                CoreSDK.FuncellSDK.Instance.GetPhoto(type, path, width, height);
#endif
            }
            else
            {
                //如果是拍照,并且剩余内存小于指定数值,那么就提示内存不足.
                GameCenter.MsgPromptSystem.ShowMsgBox(DeclareMessageString.Get(DeclareMessageString.C_SYSMEMLOW_CAMERA_DISABLED), DeclareMessageString.Get(DeclareMessageString.C_MSGBOX_OK));
            }
        }

        /// <summary>
        /// 去分享
        /// </summary>
        /// <param name="url">分享的链接</param>
        public void DoShare(string url)
        {
            FuncellSDK.Instance.DoShare(url);
        }

        /// <summary>
        /// 去应用商店评论
        /// </summary>
        /// <param name="appstoreURL">应用市场的app地址</param>
        public void DoRate(string appstoreURL)
        {
            FuncellSDK.Instance.DoRate(appstoreURL);
        }

        /// <summary>
        /// 点赞[其实只是打开下链接]
        /// </summary>
        /// <param name="needOpenUrl"></param>
        public void OpenURL(string needOpenUrl)
        {
            FuncellSDK.Instance.OpenUrl(needOpenUrl);
        }

        //执行退出
        public void HandlePCExit()
        {
#if UNITY_STANDALONE_WIN
            AppPersistData.WantExitResult = true;
            Application.Quit();
#endif
        }
        #endregion
    }
}