using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using CScript.Utilities;
using CScript.Net;
using CScript.Entity;
using System;
using System.IO;
using UnityEngine.UI;
using OpenCVForUnity.UnityUtils;
using OpenCVForUnity.CoreModule;
using OpenCVForUnity.ImgprocModule;
using OpenCVForUnity.ImgcodecsModule;
using SC.XR.Unity;
using System.Text;
using UnityEngine.Networking;
using Newtonsoft.Json;

namespace CScript.App
{
    public enum ConnectType
    { 
        None = 0,
        TCPServer = 1,
        Quic =2,
    }

    public class IpConfig
    {
        public string ip { get; set; }
        public int port { get; set; }
    }
    public class AppManager : MonoSingleton<AppManager>
    {
        Server _server;

        public ConnectType connectType = ConnectType.None;
        public Queue<NetMeshData> meshQueue = new Queue<NetMeshData>();
        private Dictionary<NetMeshData, Mat> _meshDataMatDic = new Dictionary<NetMeshData, Mat>();

        public GameObject MeshPoint;

        public Material meshFrontMaterial;
        public Material meshSideMaterial;
        public GameObject meshFrontPoint;
        public GameObject meshSidePoint;


        public GameObject meshFrontPointNew;
        public GameObject meshSidePointNew;

        public bool isRunHolographic;

        private Renderer _meshFrontRender;
        private MeshFilter _meshFrontFilter;

        private Renderer __meshFrontRenderChild;
        private MeshFilter _meshFrontFilterChild;

        private Renderer _meshSideRender;
        private MeshFilter _meshSideFilter;

        private NetMeshData _currMeshData;

        private Queue<byte[]> _meshDatas;

        private string configPath = "/Config/ConfigData.json";
        ConfigData configData;

        [SerializeField]
        private Transform meshPoint;

        IEnumerator renderThreadCoroutine;
        Mat _rgbMat;
        public Texture2D _tex;
        private bool _gotMeshData = false;
        public NetMeshData CurrMeshData
        {
            get
            {
                return _currMeshData;
            }
            private set
            {
                _currMeshData = value;
                if (_currMeshData != null)
                {
                    _rgbMat = _meshDataMatDic[_currMeshData];
                    //     Imgcodecs.imwrite(Application.dataPath+"xxx.jpg", _rgbMat);
                    if (_tex == null || _tex.width != _rgbMat.cols() || _tex.height != _rgbMat.rows())
                    {
                        _tex = new Texture2D(_rgbMat.cols(), _rgbMat.rows(), TextureFormat.RGB24, false);
                    }
                    _meshDataMatDic.Remove(_currMeshData);
                    DrawModel(_currMeshData);
                    CurrMeshData = null;
                    ReadMeshData();
                }
            }
        }

        private void Awake()
        {
           
            _server = Server.Instance;
            _meshFrontFilter = AppConfig.isNewMeshData ? meshFrontPointNew.AddComponent<MeshFilter>() : meshFrontPoint.AddComponent<MeshFilter>();
            _meshFrontRender = AppConfig.isNewMeshData ? meshFrontPointNew.AddComponent<MeshRenderer>() : meshFrontPoint.AddComponent<MeshRenderer>();
            _meshFrontRender.material = meshFrontMaterial;


            _meshSideFilter = AppConfig.isNewMeshData ? meshSidePointNew.AddComponent<MeshFilter>() : meshSidePoint.AddComponent<MeshFilter>();
            _meshSideRender = AppConfig.isNewMeshData ? meshSidePointNew.AddComponent<MeshRenderer>() : meshSidePoint.AddComponent<MeshRenderer>();

            _meshSideRender.material = meshSideMaterial;

            _currMeshData = null;
            Net.NetDistribute.Instance.drawMeshAction += DrawMeshHandler;
            Net.NetDistribute.Instance.OnConnectAction += ConnectSuccess;

            if (AppConfig.isNewMeshData)
            {
                //connectType = ConnectType.TCPServer;
            }
        }

        bool isConnected;
        private void OnDestroy()
        {
            _server.Close();
            Net.NetDistribute.Instance.OnConnectAction -= ConnectSuccess;
            Net.NetDistribute.Instance.drawMeshAction -= DrawMeshHandler;
        }

        private byte[] PackMessage(NetMessage message)
        {
            byte[] package = null;
            using (MemoryStream ms = new MemoryStream())
            {
                ProtoBuf.Serializer.Serialize(ms, message);
                package = new byte[ms.Length];
                Buffer.BlockCopy(ms.GetBuffer(), 0, package, 0, (int)ms.Length);
            }
            return package;
        }

        void Start()
        {
            renderThreadCoroutine = CallAtEndOfFrames();
            _gotMeshData = false;
            Texture2D texture2D = Resources.Load("uvMap") as Texture2D;
            Mat imgMat = new Mat(texture2D.height, texture2D.width, CvType.CV_8UC4);
            Utils.texture2DToMat(texture2D, imgMat);
            ConectServerHandler();
        }
        string ipPath;
        IpConfig ip;
        private void ConectServerHandler()
        {
            // _server.Init("127.0.0.1", 5555);
            ipPath = Application.persistentDataPath + "/Ipconfig/" + "QXip.txt";
            StartCoroutine(SettingIP());

            //  _server.Init("192.168.50.17", 6666);
            //  _server.Connect();

        }
        private void ConnectSuccess(bool result, string reason)
        {
            if (result)
            {
                isConnected = true;
            }
        }

        IEnumerator SettingIP()
        {
            yield return new WaitForSeconds(0.2f);
            if (File.Exists(ipPath))
            {
                //var webRequest = UnityWebRequest.Get(ipPath);
                //yield return webRequest.SendWebRequest();

                //if (webRequest.error != null)
                //{
                //    Debug.Log("通信中");
                //    yield return webRequest;
                //}
                //var downloadHandler = webRequest.downloadHandler;
                //if (!downloadHandler.isDone)
                //{
                //    Debug.Log("下载中");
                //    yield return downloadHandler;
                //}
                //else
                //{
                //    Debug.Log("下载成功");

                //    Debug.Log(downloadHandler.data);
                //    // if (!File.Exists(Application.dataPath + "/Resources/YourVideoName.mp4"))
                //    string data = System.Text.Encoding.Default.GetString(downloadHandler.data);
                //    ip = JsonConvert.DeserializeObject<IpConfig>(data);

                //    if (ip.ip == null || ip.port <999)
                //        Application.Quit();
                //    _server.Init(ip.ip, ip.port);
                //    _server.Connect();
                //}

                FileStream fileStream = new FileStream(ipPath, FileMode.Open, FileAccess.Read);
                fileStream.Seek(0, SeekOrigin.Begin);
                //创建文件长度缓冲区
                byte[] bytes = new byte[fileStream.Length];

                //读取文件
                fileStream.Read(bytes, 0, (int)fileStream.Length);
                Debug.Log("  bytes   " + bytes.Length);
                //释放文件读取流
                fileStream.Close();
                fileStream.Dispose();
                fileStream = null;

                string data = System.Text.Encoding.Default.GetString(bytes);
                ip = JsonConvert.DeserializeObject<IpConfig>(data); _server.Init(ip.ip, ip.port);
                if (ip.ip == null || ip.port < 999)
                    Application.Quit();
                _server.Init(ip.ip, ip.port);
                _server.Connect();

            }
            else
            {
                Directory.CreateDirectory(Application.persistentDataPath + "/Ipconfig");
                FileInfo fileInfo = new FileInfo(ipPath);
                //设置Log文件输出地址
                FileStream FileWriter = fileInfo.Open(FileMode.Create, FileAccess.ReadWrite, FileShare.Read);
                UTF8Encoding encoding = new UTF8Encoding();
                ip = new IpConfig();
                ip.ip = "192.168.50.120";
                ip.port = 6666;
                string data = JsonConvert.SerializeObject(ip);
                FileWriter.Write(encoding.GetBytes(data), 0, encoding.GetByteCount(data));
                FileWriter.Close();
                _server.Init(ip.ip, ip.port);
                _server.Connect();
            }
        }


        /// <summary>
        /// Calls at end of frames.
        /// </summary>
        private IEnumerator CallAtEndOfFrames()
        {
            while (true)
            {
                // Wait until all frame rendering is done
                yield return new WaitForEndOfFrame();

                if (_rgbMat != null && _tex != null)
                {
                    Utils.matToTextureInRenderThread(_rgbMat, _tex);
                }
            }
        }
        private float imageDecodeTime;
        private void DrawMeshHandler(NetMeshData meshData, Mat rgbMat, int totalByte,float imageDecodeTime,int lostCount)
        {
            this.imageDecodeTime = imageDecodeTime;
            //this._rgbMat = rgbMat;
            // if (meshQueue.Count == 0)

            {
                meshQueue.Enqueue(meshData);
                _meshDataMatDic.Add(meshData, rgbMat);
                if (CurrMeshData == null)
                {
                    _gotMeshData = true;
                }
            }
        }

        private void ReadMeshData()
        {
            if (CurrMeshData == null)
            {
                if (meshQueue.Count > 0)
                {
                    CurrMeshData = meshQueue.Dequeue();
                }
            }
        }

        void Update()
        {
            if (_gotMeshData)
            {
                ReadMeshData();
            }
        }

        void DrawModel(NetMeshData meshData, bool isFront = true)
        {
            //Debug.LogWarning("DrawModel:"+ meshData.uvList.Length);
            if (_meshFrontFilter.sharedMesh != null)
            {
                _meshFrontFilter.sharedMesh.Clear();
            }
            _meshFrontFilter.sharedMesh = DrawMesh1(meshData);
            Utils.fastMatToTexture2D(_rgbMat, _tex);
            meshFrontMaterial.mainTexture = _tex;
            _meshFrontFilter.sharedMesh.uv = meshData.uvList;//uvArray;// meshData.uvList;
            _meshFrontFilter.sharedMesh.triangles = meshData.Triangles1;// triangles;// meshData.Triangles1;
            _meshFrontFilter.sharedMesh.colors = null;

            if (_meshSideFilter.sharedMesh != null)
            {
                _meshSideFilter.sharedMesh.Clear();
            }
            _meshSideFilter.sharedMesh = DrawMesh2(meshData);
            _meshSideFilter.sharedMesh.triangles = meshData.Triangles2;
            _meshSideFilter.sharedMesh.colors = meshData.colorList;
        }
        Mesh mesh1;
        Mesh mesh1Child;
        Mesh mesh2;
        Mesh DrawMesh1(NetMeshData meshData)
        {
            if (mesh1 == null)
            {
                mesh1 = new Mesh();
                mesh1.indexFormat = UnityEngine.Rendering.IndexFormat.UInt32;
            }
            mesh1.Clear();
            mesh1.vertices = meshData.frontVertexList;// meshData.frontVertexList;// newVertex;
            return mesh1;
        }


        Mesh DrawMesh2(NetMeshData meshData, bool isFront = true)
        {
            if (mesh2 == null)
            {
                mesh2 = new Mesh();
            }
            mesh2.Clear();
            mesh2.vertices = meshData.sideVertexList;// newVertex;
            return mesh2;
        }


        public void SaveConfig(string Path, string information)
        {
            FileStream aFile = new FileStream(@"" + Path, FileMode.OpenOrCreate, System.IO.FileAccess.ReadWrite, FileShare.ReadWrite);
            StreamWriter sw = new StreamWriter(aFile, Encoding.UTF8);
            sw.WriteLine(information);
            sw.Close();
            sw.Dispose();

        }
    }
}