using LitJson;
using Minio;
using Minio.DataModel.Args;
using Minio.Exceptions;
using System;
using System.Collections;
using System.Collections.Generic;
using System.IO;
using System.Threading;
using System.Threading.Tasks;
using UnityEngine;
using UnityEngine.Networking;
using XRTool.Util;

public class LangChaoMinIo : MonoSingleton<LangChaoMinIo>
{
    IMinioClient minio;
    string path;
    string bucket;
    string host;

    string tmpSecretId;
    string tmpSecretKey;
    string minioToken;

    int projectId;
    Thread thread;
    private void Start()
    {
        thread = new Thread(DoSomeWork);
        thread.Start();
    }

    bool isminioUpdate;
    bool isUpdate;
    void DoSomeWork()
    {
        while (true)
        {
            if (minio == null)
            {
                if (projectId != 0 && !isminioUpdate)
                {
                    isminioUpdate = true;
                    initMinIo((bool b) =>
                    {
                        isminioUpdate = false;
                    });

                }
            }
            else
            {
                if (Nowfd != null && !isUpdate)
                {
                    isUpdate = true;
                    Run().Wait();
                }
            }
            Thread.Sleep(1000);
        }
    }

    void initMinIo(Action<bool> callBack)
    {
        JsonData data = new JsonData();
        data["inspectionId"] = projectId;
        GameStart.Instance.StartCoroutine(HttpTool.Instance.SendHttp(HttpActionLang.storage_inspectionCredential, data.ToJson(), async (string str) =>
        {
            try
            {

                JsonData d = JsonMapper.ToObject(str);
                minioToken = d["data"]["credentials"]["token"].ToString();
                tmpSecretId = d["data"]["credentials"]["tmpSecretId"].ToString();
                tmpSecretKey = d["data"]["credentials"]["tmpSecretKey"].ToString();
                host = d["data"]["host"].ToString();
                bucket = d["data"]["bucket"].ToString();
                path = d["data"]["path"].ToString();
                Debug.Log(str);
                bool isHttps = host.Contains("https");
                var endpoint = host.Split("//")[1];
                var accessKey = tmpSecretId;//"tr6Nh5D8bnlGaLJE6vb5";
                var secretKey = tmpSecretKey;// "aVOYdXLnX4MCiKbit8aomZNWvAx8YSpzhiwzFhrI";
                Debug.Log("endpoint===>" + endpoint + "    isHttps==>" + isHttps);
                minio = new MinioClient()
                                    .WithEndpoint(endpoint)
                                    .WithCredentials(accessKey, secretKey)
                                    .WithSessionToken(minioToken)
                                    .WithSSL(isHttps)
                                    .Build();
                TimerMgr.Instance.CreateTimer(() =>
                {

                    minio = null;
                }, 1200);
                callBack?.Invoke(true);
            }
            catch
            {
                callBack?.Invoke(false);

            }

        }));
    }

    Queue<FileData> fdQueue = new Queue<FileData>();
    void putFile(string filePath, string fileName, Action<bool> callBack)
    {
        FileData fd = new FileData();
        fd.filePath = filePath;
        fd.fileName = fileName;
        fd.callBack = callBack;
        fdQueue.Enqueue(fd);
    }
    string DicName = "XunJian";
    public void saveFile(Texture tex, int projectId, string Index, int imgIndex, Action<bool> callBack)
    {
        this.projectId = projectId;


        Texture2D texture2D = TextureToTexture2D(tex);
        byte[] bytes = texture2D.EncodeToPNG();
        if (!Directory.Exists(Application.persistentDataPath + "/" + DicName))
            Directory.CreateDirectory(Application.persistentDataPath + "/" + DicName);

        string fileName = DicName + "_" + projectId + "_" + Index + "_" + imgIndex + ".png";
        string filePathname = Application.persistentDataPath + "/" + DicName + "/" + fileName;
        if (File.Exists(filePathname))
            File.Delete(filePathname);
        File.WriteAllBytes(filePathname, bytes);

        PlayerPrefs.SetString(fileName, filePathname);
        putFile(filePathname, fileName, callBack);

    }
    /// <summary>
    /// 运行模式下Texture转换成Texture2D
    /// </summary>
    /// <param name="texture"></param>
    /// <returns></returns>
    private Texture2D TextureToTexture2D(Texture texture)
    {
        Texture2D texture2D = new Texture2D(texture.width, texture.height, TextureFormat.RGBA32, false);
        RenderTexture currentRT = RenderTexture.active;
        RenderTexture renderTexture = RenderTexture.GetTemporary(texture.width, texture.height, 32);
        Graphics.Blit(texture, renderTexture);

        RenderTexture.active = renderTexture;
        texture2D.ReadPixels(new Rect(0, 0, renderTexture.width, renderTexture.height), 0, 0);
        texture2D.Apply();

        RenderTexture.active = currentRT;
        RenderTexture.ReleaseTemporary(renderTexture);

        return texture2D;
    }

    /// <summary>
    /// 获取文件
    /// </summary>
    /// <param name="projectId">巡检ID</param>
    /// <param name="Index">步骤ID</param>
    /// <param name="imgIndex">步骤ID内图片ID</param>
    /// <param name="callBack"></param>
    public void getFile(int projectId, string Index, int imgIndex, Action<Texture2D> callBack)//, string path
    {
        this.projectId = projectId;

        string fileName = DicName + "_" + projectId + "_" + Index + "_" + imgIndex + ".png";
        string filePathname = PlayerPrefs.GetString(fileName);
        if (filePathname != "")
        {
            StartCoroutine(_GetTexture(filePathname, callBack));
        }
        else
        {
            callBack.Invoke(null);
        }
    }

    /// <summary>
    /// 请求图片
    /// </summary>
    /// <param name="url">图片地址,like 'http://www.my-server.com/image.png '</param>
    /// <param name="action">请求发起后处理回调结果的委托,处理请求结果的图片</param>
    /// <returns></returns>
    IEnumerator _GetTexture(string url, Action<Texture2D> actionResult)
    {
        UnityWebRequest uwr = new UnityWebRequest(url);
        DownloadHandlerTexture downloadTexture = new DownloadHandlerTexture(true);
        uwr.downloadHandler = downloadTexture;
        yield return uwr.SendWebRequest();
        Texture2D t = null;
        if (!(uwr.isNetworkError || uwr.isHttpError))
        {
            t = downloadTexture.texture;
        }
        else
        {
            Debug.Log("下载失败，请检查网络，或者下载地址是否正确: " + uwr.error);
        }

        if (actionResult != null)
        {
            actionResult(t);
        }
    }
    // File uploader task.
    private async Task Run()
    {
        try
        {

            var getListBucketsTask = await minio.ListBucketsAsync().ConfigureAwait(false);
            var bucketName = bucket;
            var objectName = path + "/" + Nowfd.fileName;
            var filePath = Nowfd.filePath;
            var contentType = "application/octet-stream";

            // Make a bucket on the server, if not already present.

            // Upload a file to bucket.
            var putObjectArgs = new PutObjectArgs()
                .WithBucket(bucketName)
                .WithObject(objectName)
                .WithFileName(filePath)
                .WithContentType(contentType);
            await minio.PutObjectAsync(putObjectArgs).ConfigureAwait(false);
            Debug.Log("33333333333333333");
            isUpdate = false;
            Nowfd = null;
            Nowfd.callBack?.Invoke(true);
        }
        catch
        {

            isUpdate = false;
            Nowfd = null;
            Nowfd.callBack?.Invoke(false);
        }
    }
    FileData Nowfd;
    private void Update()
    {
        if (fdQueue.Count > 0 && Nowfd == null)
        {
            Nowfd = fdQueue.Dequeue();
        }
    }

    public class FileData
    {
        public string filePath;
        public string fileName;
        public Action<bool> callBack;
    }

    public class GetFileData
    {

    }
}