using System.Globalization;


using StackExchange.Redis;


using ServerCore;
using ServerBase;


using USER_GUID = System.String;


namespace ServerCommon;

public class PartyInvitePartySendCache : CacheBase
{
    public Dictionary<string, DateTime> PartyInvitePartySends { get; set; } = new();
    
    public string toBasicString()
    {
        return $"PartyCache: PartyInvitePartySends:{PartyInvitePartySends}";
    }
}

public class PartyInvitePartySendCacheRequest : RedisRequestSharedBase
{
    // in
    private readonly string m_party_guid;
    
    // out
    private PartyInvitePartySendCache? m_party_invite_party_send_cache_nullable { get; set; }

    public PartyInvitePartySendCacheRequest(string party_guid, RedisConnector redisConnector) : base(party_guid,
        redisConnector)
    {
        m_party_guid = party_guid;
    }
    
    protected override string onMakeKey() => $"inviteparty:sendlist:{m_party_guid}";
    public override string toBasicString() => $"PartyInvitePartySendCache: In:PartyGuid:{m_party_guid}, Out:{m_party_invite_party_send_cache_nullable?.toBasicString()}";

    public async Task<Result> keepInvitePartySendCache()
    {
        var result = new Result();
        string err_msg;

        if (m_party_invite_party_send_cache_nullable == null || m_party_invite_party_send_cache_nullable.PartyInvitePartySends.Count <= 0) return result;
        
        try
        {
            result = await onPrepareRequest();
            if (result.isFail()) return result;

            var database = getDatabase();
            ArgumentNullException.ThrowIfNull(database);

            var redis_value = await database.KeyExpireAsync(getKey(), TimeSpan.FromMilliseconds(Constant.KEEP_PARTY_TIME));
            if (false == redis_value)
            {
                err_msg = $"Failed to set expire PartyInvitePartySendCache in Redis !!! : Key:{getKey()} - {nameof(keepInvitePartySendCache)}";
                result.setFail(ServerErrorCode.RedisGlobalPartyInvitePartySendCacheWriteFailed, err_msg);
                Log.getLogger().error(err_msg);
            }
        }
        catch (Exception e)
        {
            var error_code = ServerErrorCode.TryCatchException;
            err_msg = $"Failed to set expire PartyInvitePartySendCache from Redis !!! : : errorCode{error_code}, errMsg:{e.Message} - {nameof(keepInvitePartySendCache)}";
            result.setFail(error_code, err_msg);
            Log.getLogger().error(err_msg);
        }

        return result;
    }
    
    public PartyInvitePartySendCache? getPartyInvitePartySendCache() => m_party_invite_party_send_cache_nullable;

    public async Task<Result> fetchInvitePartySendCache()
    {
        var result = new Result();
        string err_msg;

        try
        {
            result = await onPrepareRequest();
            if (result.isFail()) return result;

            var database = getDatabase();
            ArgumentNullException.ThrowIfNull(database);

            var delete_time = DateTime.UtcNow.AddMilliseconds(-1 * Constant.KEEP_INVITEPARTY_TIME);
            var curr_party_invite_party_sends = new Dictionary<string, DateTime>();
            var delete_list = new List<string>();
            
            var redis_value = await database.HashGetAllAsync(getKey(), CommandFlags.PreferReplica);
            foreach (var send_value in redis_value)
            {
                var send_time = send_value.Value.ToString().toUtcTime();
                if (send_time < delete_time)
                {
                    delete_list.Add(send_value.Name.ToString());
                    continue;
                }
                curr_party_invite_party_sends.Add(send_value.Name.ToString(), send_time);
            }
            
            m_party_invite_party_send_cache_nullable ??= new PartyInvitePartySendCache();
            m_party_invite_party_send_cache_nullable.PartyInvitePartySends.Clear();
            foreach (var send in curr_party_invite_party_sends)
            {
                m_party_invite_party_send_cache_nullable.PartyInvitePartySends.Add(send.Key, send.Value);
            }

            result = await deleteInvitePartySendCache(delete_list); 
            
            return result;
            
        }
        catch (Exception e)
        {
            var error_code = ServerErrorCode.TryCatchException;
            err_msg = $"Failed to get PartyInvitePartySendCache from Redis !!! : : errorCode{error_code}, errMsg:{e.Message} - {nameof(fetchInvitePartySendCache)}";
            result.setFail(error_code, err_msg);
            Log.getLogger().error(err_msg);
        }

        return result;
    }

    public async Task<List<string>?> organizeInvitePartySendCache()
    {
        if (null == m_party_invite_party_send_cache_nullable) return null;

        var delete_time = DateTime.UtcNow.AddMilliseconds(-1 * Constant.KEEP_INVITEPARTY_TIME);
        var delete_sends = (from send in m_party_invite_party_send_cache_nullable.PartyInvitePartySends where send.Value < delete_time select send.Key).ToList();
        _ = await deleteInvitePartySendCache(delete_sends);

        return delete_sends;
    }
    public async Task<Result> addInvitePartySendCache(IReadOnlyList<USER_GUID> add_user_guids)
    {
        var result = new Result();
        string err_msg;

        try
        {
            result = await onPrepareRequest();
            if (result.isFail()) return result;

            var database = getDatabase();
            ArgumentNullException.ThrowIfNull(database);

            foreach (var add_user in add_user_guids)
            {
                var invite_time = DateTime.UtcNow.ToString(CultureInfo.InvariantCulture);
                _ = await database.HashSetAsync(getKey(), add_user, invite_time);   
            }

            result = await keepInvitePartySendCache();
        }
        catch (Exception e)
        {
            var error_code = ServerErrorCode.TryCatchException;
            err_msg = $"Failed to add party invite party send from Redis !!! : : errorCode{error_code}, errMsg:{e.Message} - {nameof(addInvitePartySendCache)}";
            result.setFail(error_code, err_msg);
            Log.getLogger().error(err_msg);
        }

        return result;
    }

    public async Task<Result> deleteAllInvitePartySendCache()
    {
        var result = new Result();

        try
        {
            result = await onPrepareRequest();
            if (result.isFail()) return result;

            var database = getDatabase();
            ArgumentNullException.ThrowIfNull(database);

            m_party_invite_party_send_cache_nullable = null;
            _ = await database.KeyDeleteAsync(getKey(), CommandFlags.FireAndForget);
                        
            return result;
            
        }
        catch (Exception e)
        {
            var error_code = ServerErrorCode.TryCatchException;
            var err_msg = $"Failed to delete party invite party send from Redis !!! : : errorCode{error_code}, errMsg:{e.Message} - {nameof(deleteAllInvitePartySendCache)}";
            result.setFail(error_code, err_msg);
            Log.getLogger().error(err_msg);
        }

        return result;
    }
    
    public async Task<Result> deleteInvitePartySendCache(IReadOnlyList<string> delete_user_guids)
    {
        var result = new Result();
        string err_msg;

        try
        {
            result = await onPrepareRequest();
            if (result.isFail()) return result;

            var database = getDatabase();
            ArgumentNullException.ThrowIfNull(database);

            var delete_values = new List<RedisValue>(delete_user_guids.Select(x => new RedisValue(x)));
            _ = await database.HashDeleteAsync(getKey(), delete_values.ToArray(), CommandFlags.PreferReplica);

            foreach (var delete in delete_user_guids)
            {
                m_party_invite_party_send_cache_nullable?.PartyInvitePartySends.Remove(delete);
            }
                        
            return result;
            
        }
        catch (Exception e)
        {
            var error_code = ServerErrorCode.TryCatchException;
            err_msg = $"Exception !!!, Failed to delete party invite party send from Redis !!! : : errorCode:{error_code}, exception:{e} - {nameof(deleteInvitePartySendCache)}";
            result.setFail(error_code, err_msg);
            Log.getLogger().error(err_msg);
        }

        return result;
    }
}