using System;
using System.Collections.Generic;
using System.IO;
using System.Text;
using System.Threading.Tasks;
using Fort23.Core;
using Fort23.UTool;
using UnityEngine;
using TapSDK.Core;
using TapSDK.CloudSave;
using TapSDK.Login;
using TapSDK.UI;

public class CloudSaveManager : Singleton<CloudSaveManager>
{
    private CloudSaveManager()
    {
        TapCloudSaveCallback callback = new TapCloudSaveCallback();
        TapTapCloudSave.RegisterCloudSaveCallback(callback);
    }


    // 检查是否存在存档，若存在则加载，否则创建新存档
    public async CTask LoadOrCreateArchiveAsync()
    {
        try
        {
            // 获取存档列表
            List<ArchiveData> archives = await TapTapCloudSave.GetArchiveList();
            await AccountFileInfo.Instance.LoadPlayerData();
            //如果没有本地文件看有存档没有
            if (!File.Exists(AccountFileInfo.Instance.persistentDataPath) ||
                AccountFileInfo.Instance.playerData.Uuid == String.Empty ||
                archives.Find(a => a.Uuid == AccountFileInfo.Instance.playerData.Uuid) == null)
            {
                //有存档就读取第一个存档
                if (archives != null && archives.Count > 0)
                {
                    ArchiveData archive = archives[0];
                    AccountFileInfo.Instance.playerData.Uuid = archive.Uuid;
                    await LoadArchiveAsync();
                    AccountFileInfo.Instance.LoadPlayerData();
                    AccountFileInfo.Instance.playerData.Uuid = archive.Uuid;
                }
                else
                {
                    await AccountFileInfo.Instance.ClearPlayerData();
                    await CreateArchiveAsync();
                }
            }
            //有数据直接读取本地数据 然后更新一次存档避免上次游戏没有更新
            else
            {
                UpdateArchiveAsync();
            }
        }
        catch (TapException ex)
        {
            LogTool.Error($"Failed to check/load archive: {ex.Code} - {ex.Message}");
        }
        catch (Exception ex)
        {
            LogTool.Error($"Unexpected error checking/loading archive: {ex.Message}");
        }
    }


    /// <summary>
    /// 创建存档
    /// </summary>
    public async CTask<string> CreateArchiveAsync()
    {
        try
        {
            // 创建存档元信息
            ArchiveMetadata metadata = new ArchiveMetadata(
                archiveName: "playerData",
                archiveSummary: "玩家数据",
                archiveExtra: "额外信息",
                archivePlaytime: 0
            );


            // 创建存档
            ArchiveData createdArchive =
                await TapTapCloudSave.CreateArchive(metadata, AccountFileInfo.Instance.persistentDataPath, null);
            AccountFileInfo.Instance.lasetSaveTime = System.DateTime.Now.Ticks;
            AccountFileInfo.Instance.playerData.Uuid = createdArchive.Uuid;
            LogTool.Error($"存档创建成功，UUID: {createdArchive.Uuid}");

            return createdArchive.Uuid;
        }
        catch (TapException ex)
        {
            LogTool.Error($"创建存档失败: {ex.Code} - {ex.Message}");
            throw;
        }
        catch (Exception ex)
        {
            LogTool.Error($"创建存档失败: {ex.Message}");
            throw;
        }
    }

    // 更新存档
    public async CTask UpdateArchiveAsync()
    {
        if (AccountFileInfo.Instance.playerData.Uuid == "")
            return;
        try
        {
            // 更新存档元信息
            ArchiveMetadata metadata = new ArchiveMetadata(
                archiveName: "playerData",
                archiveSummary: "玩家数据",
                archiveExtra: "额外信息",
                archivePlaytime: 0
            );

            // 更新存档
            ArchiveData updatedArchive =
                await TapTapCloudSave.UpdateArchive(AccountFileInfo.Instance.playerData.Uuid, metadata,
                    AccountFileInfo.Instance.persistentDataPath,
                    null);
            LogTool.Log($"存档更新成功，UUID: {updatedArchive.Uuid}");
        }
        catch (TapException ex)
        {
            LogTool.Error($"更新存档失败: {ex.Code} - {ex.Message}");
            throw;
        }
        catch (Exception ex)
        {
            LogTool.Error($"更新存档失败: {ex.Message}");
            throw;
        }
    }

    // 查询存档
    public async CTask LoadArchiveAsync()
    {
        try
        {
            // 获取存档列表
            List<ArchiveData> archives = await TapTapCloudSave.GetArchiveList();

            ArchiveData archive = archives.Find(a => a.Uuid == AccountFileInfo.Instance.playerData.Uuid);
            if (archive == null)
            {
                LogTool.Error("没有查询到指定uuid存档");
                return;
            }
            // 下载存档文件

            byte[] data =
                await TapTapCloudSave.GetArchiveData(AccountFileInfo.Instance.playerData.Uuid,
                    archive.FileId);

            string str1 = Encoding.UTF8.GetString(data);
            LogTool.Log(str1);
            File.WriteAllBytes(AccountFileInfo.Instance.persistentDataPath, data);
            LogTool.Error("读取存档成功");
        }
        catch (TapException ex)
        {
            LogTool.Error($"加载存档失败: {ex.Code} - {ex.Message}");
            throw;
        }
        catch (Exception ex)
        {
            LogTool.Error($"加载存档失败: {ex.Message}");
            throw;
        }
    }

    // 删除存档
    public async Task DeleteArchiveAsync(string archiveUuid)
    {
        try
        {
            await TapTapCloudSave.DeleteArchive(archiveUuid);
            LogTool.Log($"存档删除成功，UUID: {archiveUuid}");
        }
        catch (TapException ex)
        {
            LogTool.Error($"删除存档失败: {ex.Code} - {ex.Message}");
            throw;
        }
        catch (Exception ex)
        {
            LogTool.Error($"删除存档失败: {ex.Message}");
            throw;
        }
    }
}