using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using TMPro;
using UnityEngine.SceneManagement;
using JumpTower;
using UnityEngine.Networking;
using Tudada;
using UnityEngine.UI;

namespace JumpTower
{



    public class SaveSystem : MonoBehaviour
    {
        private int lastTry;
        private int bestTry;
        [SerializeField] private TextMeshProUGUI tryText;
        [SerializeField] private TextMeshProUGUI errText;
        [SerializeField] private UnityEngine.UI.Image image_icon;
        [SerializeField] private UnityEngine.UI.Image image_icon2;

        void Awake()
        {


            if (!PlayerPrefs.HasKey("LastTry"))
            {
                PlayerPrefs.SetInt("LastTry", 0);
                lastTry = 0;
            }
            else
            {
                lastTry = PlayerPrefs.GetInt("LastTry");
            }

            if (!PlayerPrefs.HasKey("BestTry"))
            {
                PlayerPrefs.SetInt("BestTry", 0);
                bestTry = 0;
            }
            else
            {
                bestTry = PlayerPrefs.GetInt("BestTry");
            }
            SetTries();


            //WX.CreateUserInfoButton();

        }

        void Start()
        {
            //GameManager.Instance;

        }

        public void SaveTry(int aScore)
        {


        }

        private void SetTries()
        {
            if (tryText != null)
                tryText.text = "last " + lastTry.ToString() + "\nBest " + bestTry.ToString();
        }

        public void StartGame()
        {
            SceneManager.LoadScene("Game");
        }

        public void DoOnClickLoginGame()
        {
            {
                SetStorage();
            }


            //GameManager.Instance.TestLogin();
            //GameManager.Instance.EnsureLogin();

            Debug.LogWarning("DoOnClickLoginGame");
        }

        public void DoOnClickOpenPrivacyContractOption()
        {
            {
                GetStorage();
            }

        }

        public void DoOnClickRequirePrivacyAuthorizeOption()
        {
            List<string> listAPINames = new List<string>() {
                             "Login",
                             "CheckSession",
                             "GetUserInfo",
                             "SetStorage",
                             "SetStorageSync",
                             "GetStorage",
                             "GetStorageSync",
                             "RemoveStorage",
                             "RemoveStorageSync",
                             "ClearStorage",
                             "ClearStorageSync",
                             "GetStorageInfoSync",
                             "TudadaStoreSave",
                             "TudadaStoreGet",
                             "GetSystemInfo",
                             "GetWindowInfo",
                             "GetAppBaseInfo",
                             "GetDeviceInfo",
                             "GetMenuButtonBoundingClientRect",
                             "VibrateShort",
                             "VibrateLong",
                             "ShowKeyboard",
                             "HideKeyboard",
                             "SetClipboardData",
                             "GetClipboardData",
                             "ExitMiniProgram",
                             "RestartMiniProgram",
                             "StartAccelerometerSensor",
                             "StopAccelerometerSensor",
                             "CreateRewardedVideoAd",
                             "ShowRewardedAd",
                             "GetLaunchOptions",
                             "CheckFeature",
                             "CreateRewardedVideoAd",
                             "ShowRewardedAd",
                             "GetLaunchOptions",
                             "CheckFeature"
            };


            for (int i = 0, iMax = listAPINames.Count; i < iMax; i++)
            {
                TudadaSDK.Instance.CheckFeature(listAPINames[i],
                    onSuccess: getResult => DebugConsole.Log($"Suc cur Name : {listAPINames[i]}, result : {getResult.apiName}, {getResult.errMsg}, {getResult.status}, {getResult.StatusEnum.ToString()}, {getResult.detail}, {getResult.supported}"),
                    onFail: getResult => DebugConsole.Log($"Fail cur Name : {listAPINames[i]}, result : {getResult.apiName}, {getResult.errMsg}, {getResult.status}, {getResult.StatusEnum.ToString()}, {getResult.detail}, {getResult.supported}")
                    );
            }
        }

        public void DoOnClickAdsShow()
        {

            TudadaSDK.Instance.ShowRewardedAd("sample_rewarded_Ads_unit_id",
                onSuccess: (setRes) =>
            {
                DebugConsole.Log($"[DoOnClickAdsShow] SUCCESS : {setRes.isEnded}");
            },
            onFail: (err) =>
            {
                DebugConsole.LogError($"[DoOnClickAdsShow] FAILED error : {err}");
            });

            //ClearStorage();
        }



        public void DoOnClickInPageManagerOpen()
        {
            {
                SetStorageSync();

            }

        }

        public void DoOnClickCustomerServiceOpen()
        {
            {
                GetStorageSync();

            }

        }


        public void DoOnClickFeedbackOpen()
        {
            Tudada.TudadaLaunchOptions tOptions = TudadaSDK.Instance.GetLaunchOptions();
            if (tOptions == null || tOptions.referrerInfo == null)
            {
                errText.text = "TudadaLaunchOptions is Null !!!  ";
                return;
            }

            string strLog = string.Format("query : {0}, extraData : {1}", tOptions.query, tOptions.referrerInfo.extraData);
            errText.text = strLog;
            Debug.LogWarning(strLog);
            Debug.LogWarning("tOptions.query : " + tOptions.query);
            Debug.LogWarning("tOptions.referrerInfo.extraData : " + tOptions.referrerInfo.extraData);
        }

        public void DoOnClickSample()
        {
            TudadaSDK.Instance.OnAccelerometerChange += SampleCode;
            {
                //ClearStorageSync();

            }
            DebugConsole.Log("OnAccelerometerChange cLICK");
        }
        AccelerometerSensitivity sensitivityType = AccelerometerSensitivity.sensitive;
        public void DoOnClickSample2()
        {
            switch (sensitivityType)
            {
                case AccelerometerSensitivity.sensitive: sensitivityType = AccelerometerSensitivity.normal; break;
                case AccelerometerSensitivity.normal: sensitivityType = AccelerometerSensitivity.insensitive; break;
                case AccelerometerSensitivity.insensitive: sensitivityType = AccelerometerSensitivity.sensitive; break;
                default: sensitivityType = AccelerometerSensitivity.normal; break;
            }
        }

        public void DoOnClickSample3()
        {
            TudadaSDK.Instance.StopAccelerometerSensor(
                onSuccess: (setRes) =>
                {
                    DebugConsole.Log($"[StopAccelerometerSensor] SUCCESS : {setRes.errCode}");
                    DebugConsole.Log($"[StopAccelerometerSensor] SUCCESS : {setRes.errMsg}");
                },
            onFail: (err) =>
            {
                DebugConsole.LogError($"[StopAccelerometerSensor] FAILED error : {err}");
            });

            //TudadaSDK.Instance.ExitMiniProgram(
            //    onSuccess: (setRes) =>
            //    {
            //        DebugConsole.Log($"[ExitMiniProgram] SUCCESS : {setRes.errCode}");
            //        DebugConsole.Log($"[ExitMiniProgram] SUCCESS : {setRes.errMsg}");
            //    },
            //onFail: (err) =>
            //{
            //    DebugConsole.LogError($"[ExitMiniProgram] FAILED error : {err}");
            //});
            //{
            //    //ShowKeyboard();

            //}
            //SampleClientRect();
        }

        public void DoOnClickSample4()
        {
            TudadaSDK.Instance.StartAccelerometerSensor(sensitivityType,
                onSuccess: (setRes) =>
            {
                DebugConsole.Log($"[StartAccelerometerSensor] SUCCESS : {setRes.errCode}");
                DebugConsole.Log($"[StartAccelerometerSensor] SUCCESS : {setRes.errMsg}");
            },
            onFail: (err) =>
            {
                DebugConsole.LogError($"[StartAccelerometerSensor] FAILED error : {err}");
            });
            //ApplySafeArea();
            //ApplySafeArea2();

            //{
            //    TudadaSDK.Instance.RestartMiniProgram(
            //    onSuccess: (setRes) =>
            //    {
            //        DebugConsole.Log($"[RestartMiniProgram] SUCCESS : {setRes.errCode}");
            //        DebugConsole.Log($"[RestartMiniProgram] SUCCESS : {setRes.errMsg}");
            //    },
            //onFail: (err) =>
            //{
            //    DebugConsole.LogError($"[RestartMiniProgram] FAILED error : {err}");
            //});
            //    //HideKeyboard();
            //}
        }


        void SampleClientRect()
        {
            RectTransform rectTransform = image_icon.rectTransform;
            Canvas canvas = rectTransform.GetComponentInParent<Canvas>();
            RectTransform canvasRect = canvas.GetComponent<RectTransform>();

            float dpr = Screen.width / canvas.pixelRect.width;

            float screenX = TudadaSDK.Instance.GetMenuButtonBoundingClientRect().right * dpr;
            float screenY = (Screen.height - TudadaSDK.Instance.GetMenuButtonBoundingClientRect().top) * dpr;
            Debug.LogWarning("Sample screenY : " + screenY.ToString());
            Debug.LogWarning("Sample bottom : " + TudadaSDK.Instance.GetMenuButtonBoundingClientRect().bottom.ToString());
            Debug.LogWarning("Sample height : " + TudadaSDK.Instance.GetMenuButtonBoundingClientRect().height.ToString());

            Vector2 screenPos = new Vector2(screenX, screenY);

            RectTransformUtility.ScreenPointToLocalPointInRectangle(
                canvasRect,
                screenPos,
                canvas.renderMode == RenderMode.ScreenSpaceOverlay ? null : canvas.worldCamera,
                out Vector2 localPos
            );


            Debug.Log($"LocalPos: {localPos}");
            Debug.Log($"Canvas Rect: {canvasRect.rect.size}");
            Debug.Log($"Anchor: {rectTransform.anchorMin} ~ {rectTransform.anchorMax}");
            Debug.Log($"Pivot: {rectTransform.pivot}");
            Debug.Log($"ScaleFactor: {canvas.scaleFactor}");

            // Y 
            Debug.LogWarning("Sample rectTransform.anchoredPosition prev : " + rectTransform.anchoredPosition.ToString());
            rectTransform.anchoredPosition = new Vector2(rectTransform.anchoredPosition.x, localPos.y);
            Debug.LogWarning("Sample rectTransform.anchoredPosition next : " + rectTransform.anchoredPosition.ToString());

        }

        void SampleCode()
        {

        }


        void ApplySafeArea()
        {
            RectTransform rectTransform = image_icon.rectTransform;

            Rect safeArea = Screen.safeArea;
            float topInset = Screen.height - (safeArea.y + safeArea.height);

            //  е  (Y  )
            rectTransform.offsetMin = new Vector2(
                rectTransform.offsetMin.x,
                rectTransform.offsetMin.y
            );

            rectTransform.offsetMax = new Vector2(
                rectTransform.offsetMax.x,
                -topInset
            );
        }

        void ApplySafeArea2()
        {
            RectTransform rectTransform = image_icon2.rectTransform;
            SafeArea safeArea = TudadaSDK.Instance.GetWindowInfo().safeArea;
            float topInset = Screen.height - (safeArea.left + safeArea.height);

            //  е  (Y  )
            rectTransform.offsetMin = new Vector2(
                rectTransform.offsetMin.x,
                rectTransform.offsetMin.y
            );

            rectTransform.offsetMax = new Vector2(
                rectTransform.offsetMax.x,
                -topInset
            );
        }



        string keySample = "nLevel";
        string keyStage = "nStage";

        public void SetStorage()
        {

            TudadaSDK.Instance.SetStorage(keySample, "99999");
        }

        public void GetStorage()
        {
            TudadaSDK.Instance.GetStorage(keySample);
            TudadaSDK.Instance.GetStorage(keyStage);
        }

        public void RemoveStorage()
        {

            TudadaSDK.Instance.RemoveStorage(keySample);
        }

        public void ClearStorage()
        {
            TudadaSDK.Instance.ClearStorage();

        }

        public void SetStorageSync()
        {
            TudadaSDK.Instance.SetStorageSync(keyStage, "2222");
        }

        public void GetStorageSync()
        {
            string strLog = TudadaSDK.Instance.GetStorageSync(keyStage);
            Debug.LogWarning(string.Format("Get StorageSync Data : {0}", strLog));

            strLog = TudadaSDK.Instance.GetStorageSync(keySample);
            Debug.LogWarning(string.Format("Get StorageSync Data : {0}", strLog));

        }

        public void RemoveStorageSync()
        {
            TudadaSDK.Instance.RemoveStorageSync(keyStage);
        }

        public void ClearStorageSync()
        {
            TudadaSDK.Instance.ClearStorageSync();
        }

        public void GetSystemInfo()
        {
            TudadaSDK.Instance.GetSystemInfo(
                onSuccess: (setRes) =>
                {
                    DebugConsole.Log($"[TestClipboard][GetSystemInfo] SUCCESS language: {setRes.language}");
                    DebugConsole.Log($"[TestClipboard][GetSystemInfo] SUCCESS system: {setRes.system}");
                    DebugConsole.Log($"[TestClipboard][GetSystemInfo] SUCCESS model: {setRes.model}");
                },
            onFail: (err) =>
            {
                DebugConsole.LogError($"[TestClipboard][GetSystemInfo] FAILED error : {err}");
            });
        }

        public void ShowKeyboard()
        {
            DebugConsole.Log("[TestClipboard] Showing keyboard...");
            TudadaSDK.OnKeyboardConfirm += (res) =>
            {
                DebugConsole.Log($"[TestClipboard][OnKeyboardConfirm] Keyboard confirm - input: {res.value}");

                TudadaSDK.Instance.SetClipboardData(
                    data: res.value,
                    onSuccess: (setRes) =>
                    {
                        DebugConsole.Log($"[TestClipboard][OnKeyboardConfirm] SUCCESS - Saved to clipboard: {res.value}");
                    },
                    onFail: (err) =>
                    {
                        DebugConsole.LogError($"[TestClipboard][OnKeyboardConfirm] FAILED to save: {err}");
                    }
                );
            };

            TudadaSDK.OnKeyboardInput += (res) =>
            {
                DebugConsole.Log($"[TestClipboard][OnKeyboardInput] Keyboard confirm - input: {res.value}");

                TudadaSDK.Instance.SetClipboardData(
                    data: res.value,
                    onSuccess: (setRes) =>
                    {
                        DebugConsole.Log($"[TestClipboard][OnKeyboardInput] SUCCESS - Saved to clipboard: {res.value}");
                    },
                    onFail: (err) =>
                    {
                        DebugConsole.LogError($"[TestClipboard][OnKeyboardInput] FAILED to save: {err}");
                    }
                );
            };

            TudadaSDK.OnKeyboardComplete += (res) =>
            {
                DebugConsole.Log($"[TestClipboard][OnKeyboardComplete] Keyboard confirm - input: {res.value}");

                TudadaSDK.Instance.SetClipboardData(
                    data: res.value,
                    onSuccess: (setRes) =>
                    {
                        DebugConsole.Log($"[TestClipboard][OnKeyboardComplete] SUCCESS - Saved to clipboard: {res.value}");
                    },
                    onFail: (err) =>
                    {
                        DebugConsole.LogError($"[TestClipboard][OnKeyboardComplete] FAILED to save: {err}");
                    }
                );
            };

            TudadaSDK.Instance.ShowKeyboard(
                defaultValue: "",
                maxLength: 100,
                confirmType: KeyboardConfirmType.done,
                onSuccess: (res) =>
                {
                    DebugConsole.Log("[ShowKeyboard] SUCCESS - Keyboard shown");
                },
                onFail: (err) =>
                {
                    DebugConsole.LogError($"[ShowKeyboard] FAILED to show keyboard: {err}");
                }
            );

            StartCoroutine(delayHideKeyBoard());
            Invoke(nameof(DelayedFunc), 3f);
        }

        public IEnumerator delayHideKeyBoard()
        {
            yield return new WaitForSeconds(2f);
            HideKeyboard();
        }


        void DelayedFunc()
        {
            Debug.Log("Invoke ");
            HideKeyboard();
        }


        public void HideKeyboard()
        {
            TudadaSDK.Instance.HideKeyboard(
                onSuccess: (res) =>
                {
                    DebugConsole.Log("[HideKeyboard] SUCCESS - Keyboard shown");
                },
                onFail: (err) =>
                {
                    DebugConsole.LogError($"[HideKeyboard] FAILED to show keyboard: {err}");
                }
            );

        }

        void SampleCode(AccelerometerChangeResult result)
        {
            Debug.LogWarning(string.Format("result.x : {0}, result.y : {1}, result.z : {2}", result.x, result.y, result.z));
        }

    }






}
