using System;
using System.Collections;
using System.Collections.Generic;
using System.IO;
using HK.Keyboard;
using HK.Tool;
using Runtime;
using SixLabors.ImageSharp;
using SixLabors.ImageSharp.Formats.Jpeg;
using SixLabors.ImageSharp.Processing;
using UnityEngine.UI;
using TMPro;
using UnityEngine;
using ZGame;
using ZXL.Helper;
using Image = UnityEngine.UI.Image;

namespace HK.FUJIFILM
{
    public class ProductDesginUI : UIBase
    {
        [SerializeField] private Transform goProduct;
        [SerializeField] private ScrollRect scrUp;
        [SerializeField] private Toggle togPhoto;
        [SerializeField] private Toggle togTemplate;
        [SerializeField] private ScrollRect scrPhoto;
        [SerializeField] private Button btnAddPhoto;
        [SerializeField] private ScrollRect scrTemplate;
        [SerializeField] private UpMenuItem goUpMenu;
        [SerializeField] private UploadPhotoPage uploadPhotoPage;
        [SerializeField] private Button btnFinish;

        private ProductScriptableObject _productScriptableObject;
        private string currentID;
        Camera _3DPreviewCamera; // 

        public override void OnInit()
        {
            base.OnInit();

            #region AutoGen_Init

            goProduct = GetValue<Transform>("goProduct");
            scrUp = GetValue<ScrollRect>("scrUp");
            togPhoto = GetValue<Toggle>("togPhoto");
            togTemplate = GetValue<Toggle>("togTemplate");
            scrPhoto = GetValue<ScrollRect>("scrPhoto");
            btnAddPhoto = GetValue<Button>("btnAddPhoto");
            scrTemplate = GetValue<ScrollRect>("scrTemplate");
            goUpMenu = GetValue<UpMenuItem>("goUpMenu");
            uploadPhotoPage = GetValue<UploadPhotoPage>("UploadPhotoPage");
            btnFinish = GetValue<Button>("btnFinish");

            scrUp.onValueChanged.AddListener(OnValueChangedscrUp);
            togPhoto.onValueChanged.AddListener(OnValueChangedtogPhoto);
            togTemplate.onValueChanged.AddListener(OnValueChangedtogTemplate);
            scrPhoto.onValueChanged.AddListener(OnValueChangedscrPhoto);
            btnAddPhoto.onClick.AddListener(OnClickbtnAddPhoto);
            scrTemplate.onValueChanged.AddListener(OnValueChangedscrTemplate);
            btnFinish.onClick.AddListener(ClickFinish);

            #endregion

            goUpMenu.ReturnAction += ReturnCallback;
            uploadPhotoPage.UploadCallbackAction += UploadCallback;
            EventManager.Instance.Subscribe(ProductEventArgs.EventId, ProductEvent);
            EventManager.Instance.Subscribe(ProductDesignItemEventArgs.EventId, ProductDesignItemEvent);
            EventManager.Instance.Subscribe(Set3DCameraEventArgs.EventId, Set3DCameraEvent);
            cartData = new ShoppingCartData();
            cartData.onlyOneID = GuidGenerator.GenerateStandardGuid();
        }

        ShoppingCartData cartData;

        private void Set3DCameraEvent(object sender, GameEventArgs e)
        {
            var args = e as Set3DCameraEventArgs;
            _3DPreviewCamera = args.camera;
        }

        private void ClickFinish()
        {
            StartCoroutine(WaitSaveFinish());
        }

        IEnumerator WaitSaveFinish()
        {
            string tempStr;
            var tmpText = btnFinish.GetComponentInChildren<TMP_Text>();
            tempStr = tmpText.text;
            tmpText.text = "请等待";
            OnPause();

            cartData.produceID = _productScriptableObject.produceID;
            cartData.bookName = _productScriptableObject.produceName;
            cartData.bookAmount = _productScriptableObject.productPrice + _productScriptableObject.designPrice;
            cartData.bookDiscount = _productScriptableObject.discountPrice;
            cartData.count = 1;
            cartData.previewImage = new byte[] { };
            cartData.designImage = new List<byte[]>();

            bool isTrue = false;

            if (_productScriptableObject.is2D)
            {
                mugItem.StartRenderPrinting(Wait);

                void Wait(byte[] b, List<byte[]> c)
                {
                    cartData.previewImage = b;
                    cartData.designImage = c;
                    isTrue = true;
                }
                // switch (_productScriptableObject.capType)
                // {
                //     case CapType.OneToOne:
                //         DoubleCaptureSystem.Instance.CaptureTwice((bytes1, bytes2) =>
                //         {
                //             cartData.previewImage = bytes1;
                //             cartData.designImage.Add(bytes2);
                //             Finish();
                //         });
                //         break;
                //     case CapType.OneToMany:
                //         DoubleCaptureSystem.Instance.CaptureTwice_OneToMany((bytes1, bytes2) =>
                //         {
                //             cartData.previewImage = bytes1;
                //             cartData.designImage = bytes2;
                //             Finish();
                //         });
                //         break;
                //     case CapType.ManyToMany:
                //         DoubleCaptureSystem.Instance.CaptureTwice_ManyToMany((bytes1, bytes2) =>
                //         {
                //             cartData.previewImage = bytes1[0];
                //             cartData.designImage = bytes2;
                //             Finish();
                //         });
                //         break;
                //     default:
                //         throw new ArgumentOutOfRangeException();
                // }
            }
            else
            {
                mugItem.StartRenderPrintingOnlyDesign(Wait);

                void Wait(byte[] b, List<byte[]> c)
                {
                    cartData.previewImage = b;
                    cartData.designImage = c;
                    var texture2D = TextureHelper.SaveCameraToTexture(_3DPreviewCamera);
                    var previewBytes = texture2D.EncodeToPNG();
                    File.WriteAllBytes(
                        Path.Combine(RenderPrintingManager.Instance.FolderPath, $"Preview - {DateTime.Now.Ticks}.png"),
                        previewBytes);
                    cartData.previewImage = previewBytes;
                    isTrue = true;
                }
                // var texture2D = TextureHelper.SaveCameraToTexture(_3DPreviewCamera);
                // var previewBytes = texture2D.EncodeToPNG();
                // cartData.previewImage = previewBytes;
                // DoubleCaptureSystem.Instance.CaptureOnlyDesign((bytes2, folder) =>
                // {
                //     File.WriteAllBytes(Path.Combine(folder, "PreviewImage1.png"), previewBytes);
                //     cartData.designImage.Add(bytes2);
                //     Finish();
                // });
                // EventManager.Instance.FireNow(this, new SavePreviewAndDesignEventArgs(cartData));
            }

            while (!isTrue)
            {
                yield return null;
            }

            yield return new WaitForFixedUpdate();

            yield return cartData.designImage != null && cartData.previewImage != null;
            Finish();
            // GenPreviewImage(cartData.previewImage, cartData.designImage);

            void Finish()
            {
                EventManager.Instance.FireNow(this, new CloseKeyboardEventArgs());
                Runtime.ShoppingCartManager.Instance.AddToCart(cartData, _productScriptableObject);
                UIManager.Instance.ShowUI(nameof(ShoppingCartUI), this);
                tmpText.text = tempStr;
                OnResume();
            }
        }

        public void GenPreviewImage(byte[] previewBytes, byte[] designBytes)
        {
            try
            {
                // save
#if (PLATFORM_STANDALONE_WIN || UNITY_STANDALONE_WIN) && !UNITY_EDITOR
                string folder = $"{Application.persistentDataPath}/Notebook/{DateTime.Now.Ticks}";
                if (!Directory.Exists(folder))
                {
                    Directory.CreateDirectory(folder);
                }

                File.WriteAllBytes(Path.Combine(folder, "previewImage.png"), previewBytes);
                File.WriteAllBytes(Path.Combine(folder, "designImage.png"), designBytes);
#endif
            }
            catch (Exception e)
            {
                UnityEngine.Debug.Log(e);
            }

            // File.WriteAllBytes($"{Application.dataPath}/tupian.png", bytes);
        }

        public override void OnOpen(UIBase lastUI)
        {
            base.OnOpen(lastUI);
            currentID = null;

// #if UNITY_EDITOR
//             btnFinish.gameObject.SetActive(true);
// #endif
        }

        public override void OnClose()
        {
            base.OnClose();
            EventManager.Instance.FireNow(this, new CloseKeyboardEventArgs());
        }

        private void ProductDesignItemEvent(object sender, GameEventArgs e)
        {
            var args = e as ProductDesignItemEventArgs;
            currentID = args.ID;
        }

        private void UploadCallback(List<Sprite> obj)
        {
            GenPhoto(obj);
        }

        private void ReturnCallback()
        {
            ShoppingCartManager.Instance.RemoveFromCart(cartData);
            EventManager.Instance.FireNow(this, new CloseKeyboardEventArgs());
        }

        A11ozCeramicsMugItem mugItem;

        private void ProductEvent(object sender, GameEventArgs e)
        {
            var args = e as ProductEventArgs;
            _productScriptableObject = args.productScriptableObject;
            var gridLayoutGroup = scrTemplate.content.GetComponent<GridLayoutGroup>();
            gridLayoutGroup.padding = _productScriptableObject.layoutRectOffset;
            gridLayoutGroup.cellSize = _productScriptableObject.cellSize;
            gridLayoutGroup.spacing = _productScriptableObject.layoutSpacingSize;
            gridLayoutGroup.constraint = _productScriptableObject.constraint;
            gridLayoutGroup.constraintCount = _productScriptableObject.constraintCount;
            GameObject currentDesignItem =
                ResourcesManager.Instance.LoadGameObject(_productScriptableObject.productUIPfbPath, goProduct);
            mugItem = currentDesignItem.GetComponent<A11ozCeramicsMugItem>();
            mugItem.SetData(_productScriptableObject);
            mugItem.OnShow();
            itemBases.Add(mugItem);
            GenTemplate();
        }

        void GenTemplate()
        {
            for (var index = 0; index < _productScriptableObject.templateSprites.Length; index++)
            {
                var templateSprite = _productScriptableObject.templateSprites[index];
                var designItem = _productScriptableObject.designItems[index];
                var loadGameObject = ResourcesManager.Instance.LoadGameObject(
                    AssetConst.Assets_Res_FUJIFILM_Prefabs_UI_Item_goDesignTemplateItem_prefab, scrTemplate.content);
                loadGameObject.SetActive(true);
                loadGameObject.transform.localScale = Vector3.one;
                var image = loadGameObject.GetComponent<Image>();
                image.sprite = templateSprite;
                var designTemplateItem = loadGameObject.GetComponent<DesignTemplateItem>();
                designTemplateItem.SetData(templateSprite, designItem);

                if (index == 0)
                    EventManager.Instance.FireNow(ProductA11ozCeramicsMugItemEventArgs.EventId,
                        new ProductA11ozCeramicsMugItemEventArgs(templateSprite, designItem));
                // ChangeImageSize(image, templateSprite, 450);
            }
        }

        List<DesignPhotoItem> designList = new List<DesignPhotoItem>();

        void GenPhoto(List<Sprite> list)
        {
            foreach (var templateSprite in list)
            {
                Debug.Log($"gen photo {templateSprite.name}");
                var loadGameObject = ResourcesManager.Instance.LoadGameObject(
                    AssetConst.Assets_Res_FUJIFILM_Prefabs_UI_Item_goDesignPhotoItem_prefab, scrPhoto.content);
                loadGameObject.SetActive(true);
                loadGameObject.transform.localScale = Vector3.one;
                var image = loadGameObject.GetComponent<Image>();
                image.sprite = templateSprite;
                ChangeImageSize(image, templateSprite, 300);
                var designPhotoItem = loadGameObject.GetComponent<DesignPhotoItem>();
                designPhotoItem.ClickDeleteCallback += ClickDelete;
                designPhotoItem.ClickDesignPhotoCallback += ClickDesignPhoto;
                designList.Add(designPhotoItem);
            }
        }

        private void Update()
        {
            if (Input.GetKeyDown(KeyCode.P))
            {
                List<Sprite> list = new List<Sprite>();
                list.Add(ResourcesManager.Instance.Load<Sprite>(AssetConst.Assets_Res_FUJIFILM_Art_Asset21_288x_png));
                list.Add(ResourcesManager.Instance.Load<Sprite>(AssetConst.Assets_Res_FUJIFILM_Art_Asset24_288x_png));
                list.Add(ResourcesManager.Instance.Load<Sprite>(AssetConst.Assets_Res_FUJIFILM_Art_Asset25_288x_png));
                GenPhoto(list);
            }
        }

        private void ClickDesignPhoto(DesignPhotoItem obj, Sprite sprite)
        {
            if (string.IsNullOrEmpty(currentID))
            {
                return;
            }

            EventManager.Instance.FireNow(this, new ProductDesgin_GenPhotoEventArgs(currentID, sprite));
        }

        private void ClickDelete(DesignPhotoItem obj)
        {
            GameObject.Destroy(obj.gameObject);
            designList.Remove(obj);
        }

        void ChangeImageSize(Image image, Sprite sprite, float maxSize)
        {
            image.sprite = sprite;
            ImageScaler.ScaleImageWithMaxSize(image, maxSize);
        }

        #region AutoGen_Method

        private void OnValueChangedscrUp(Vector2 v)
        {
        }

        private void OnValueChangedtogPhoto(bool b)
        {
            scrPhoto.gameObject.SetActive(b);
        }

        private void OnValueChangedtogTemplate(bool b)
        {
            scrTemplate.gameObject.SetActive(b);
        }

        private void OnValueChangedscrPhoto(Vector2 v)
        {
        }

        private void OnClickbtnAddPhoto()
        {
            uploadPhotoPage.OpenBeamer();
        }

        private void OnValueChangedscrTemplate(Vector2 v)
        {
        }

        #endregion

        public override void OnDispose()
        {
            base.OnDispose();
            goUpMenu.ReturnAction -= ReturnCallback;
            uploadPhotoPage.UploadCallbackAction -= UploadCallback;

            EventManager.Instance.Unsubscribe(ProductEventArgs.EventId, ProductEvent);
            EventManager.Instance.Unsubscribe(ProductDesignItemEventArgs.EventId, ProductDesignItemEvent);
            EventManager.Instance.Unsubscribe(Set3DCameraEventArgs.EventId, Set3DCameraEvent);

            #region AutoGen_Dispose

            scrUp.onValueChanged.RemoveListener(OnValueChangedscrUp);
            togPhoto.onValueChanged.RemoveListener(OnValueChangedtogPhoto);
            togTemplate.onValueChanged.RemoveListener(OnValueChangedtogTemplate);
            scrPhoto.onValueChanged.RemoveListener(OnValueChangedscrPhoto);
            btnAddPhoto.onClick.RemoveListener(OnClickbtnAddPhoto);
            scrTemplate.onValueChanged.RemoveListener(OnValueChangedscrTemplate);
            btnFinish.onClick.RemoveListener(ClickFinish);

            goProduct = null;
            scrUp = null;
            togPhoto = null;
            togTemplate = null;
            scrPhoto = null;
            btnAddPhoto = null;
            scrTemplate = null;
            goUpMenu = null;

            #endregion
        }
    }
}