using System;
using Cysharp.Threading.Tasks;
using Newtonsoft.Json;
using UnityEngine.Assertions;

namespace Ubisoft.Hotel.Cache
{
    /// <summary>
    /// Cache driver that converts T to json and viceversa using JsonConvert
    /// </summary>
    /// <typeparam name="T">The data type managed by the cache driver. It must be a nullable type.</typeparam>
    public class GenericCacheDriver<T> : AbstractCacheDriver
    {
        public delegate UniTask<string> SyncMethod();

        public string Filepath { get; private set; }

        public static async UniTask<GenericCacheDriver<T>> CreateAsync(string rootFolder, string filePath, CacheSettings settings)
        {
            Assert.IsFalse(string.IsNullOrEmpty(rootFolder));

            GenericCacheDriver<T> driver = new GenericCacheDriver<T>();
            driver.RootFolder = rootFolder;
            driver.Filepath = filePath;
            await driver.InitAsync(settings);
            return driver;
        }

        private GenericCacheDriver()
        {
            // We can't enforce T to be a nullable type using a generic constraint (such constraint doesn't exist). So instead we do the following JIT compile-time check
            if (default(T) != null)
            {
                throw new InvalidOperationException("GenericCacheDriver<T> requires T to be a nullable type");
            }
        }

        public async UniTask<T> GetDataAsync(string filter = "")
        {
            string json = await CacheManager.GetDataAsync(GetRelativeCacheFilepath(Filepath), filter);
            if (!string.IsNullOrEmpty(json))
            {
               return JsonConvert.DeserializeObject<T>(json);
            }

            return default(T); // This should always be null, since T is a nullable type
        }

        public async UniTask<string> GetCrcAsync(string filter = "")
        {
            CacheFileMetadata metadata = await CacheManager.GetFileMetadataAsync(GetRelativeCacheFilepath(Filepath), filter);
            if(metadata != null)
            {
                return metadata.Crc;
            }

            return null;
        }

        public async UniTask SaveDataAsync(T data, string filter = "")
        {
            string json = JsonConvert.SerializeObject(data);
            await CacheManager.UpdateDataAsync(Filepath, json, filter);
        }

        public void InvalidateData(string filter = "")
        {
            CacheManager.InvalidateFile(GetRelativeCacheFilepath(Filepath), filter);
        }
    }
}