using StackExchange.Redis;
using Google.Protobuf;
using Google.Protobuf.WellKnownTypes;


using ServerCore;
using ServerBase;
using ServerCommon;
using ServerCommon.BusinessLogDomain;
using MetaAssets;




namespace ServerCommon;

public class RentalOccupyCacheRequest : RedisRequestSharedBase
{
    // In
    private string m_shared_key;

    // Out
    private string m_occupied_user_guid = string.Empty;

    public RentalOccupyCacheRequest(string sharedKey, RedisConnector redisConnector)
        : base(sharedKey, redisConnector)
    {
        m_shared_key = sharedKey;
    }

    public override string toBasicString()
    {
        return $"RentalOccupy: In:{m_shared_key}, Out:{m_occupied_user_guid}";
    }

    protected override string onMakeKey()
    {
        return $"RentalOccupy:{m_shared_key}";
    }

    public static string makeShareKey(int landId, int buildingId, int floor)
    {
        var shared_key = string.Empty;

        if (landId > 0)
            shared_key = $"{landId}";
        else
            return shared_key;

        if (buildingId > 0)
            shared_key = $"{shared_key}:{buildingId}";
        else
            return shared_key;

        if (floor > 0)
            shared_key = $"{shared_key}:{floor}";

        return shared_key;
    }

    public string getOccupiedUserGuid() => m_occupied_user_guid;

    public async Task<Result> tryOccupyRental(string userGuid)
    {
        var result = new Result();
        var err_msg = string.Empty;

        try
        {
            result = await onPrepareRequest();
            if (result.isFail())
            {
                err_msg = $"Failed to onPrepareRequest() !!! : {result.toBasicString()}";
                Log.getLogger().error(err_msg);

                return result;
            }

            var database = getDatabase();
            if (!await database.StringSetAsync(getKey(), userGuid, TimeSpan.FromMinutes(1), When.NotExists))
            {
                err_msg = $"Failed to StringSetAsync to Redis !!! : redisKey:{getKey()}";
                result.setFail(ServerErrorCode.RedisLocationCacheSetFailed, err_msg);
                Log.getLogger().error(err_msg);

                return result;
            }

            return result;
        }
        catch (Exception e)
        {
            err_msg = $"Failed to tryOccupyRental in Redis !!! : message{e}";
            result.setFail(ServerErrorCode.TryCatchException, err_msg);
            Log.getLogger().error(result.toBasicString());

            return result;
        }
    }

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

        try
        {
            var database = getDatabase();

            _ = await database.KeyDeleteAsync(getKey());
            
            return result;
        }
        catch (Exception e)
        {
            err_msg = $"Failed to delete key in Redis !!! : message{e}";
            result.setFail(ServerErrorCode.TryCatchException, err_msg);
            Log.getLogger().error(result.toBasicString());

            return result;
        }
    }
}