using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;


using Newtonsoft.Json;
using StackExchange.Redis;



using ServerCore; using ServerBase;


using REDIS_REQUEST_HANDLER_TYPE = System.UInt32;
using REDIS_KEY_FORMAT_TYPE = System.UInt32;
using REDIS_KEY_FORMAT = System.String;
using REDIS_KEY_PLACE_HOLDER = System.String;
using REDIS_KEY_REPLACE = System.String;
using REDIS_KEY = System.String;
using WORLD_META_ID = System.UInt32;
using SERVER_NAME = System.String;
using ServerControlCenter;
using System.Drawing;


namespace ServerBase;


/*=================================================================================================
  * Server Metrics Key

    SET     :
        + Channel
            serverinfo:Keys:{ChannelKey}:{WorldMetaId}
            MEMBER
                serverinfo:{Channel}:{WorldId}:{ChannelNo}
        
        + Etc
            serverinfo:Keys:{ServerTypeKey}
            MEMBER
                serverinfo:{ServerType}:{IP}_{Port}            

=================================================================================================*/

public class ServerMetricsHandler : ServerMetricsCacheRequest
{
    // for RedisRequest 종류
    private enum HandlerType
    {
        InitByServerKeyWithServerName,
        GetByServerKey,
        GetByServerName,
        RemoveByServerKey,
        RemoveByServerName,
        UpdateByServerName,
    }

    // for RedisKey 종류
    private enum KeyType
    {
        Default,
        ChannelsInWorld,
        ServerName,
    }

    public readonly string KEY_DEFAULT_FORMAT =            $"serverinfo:Keys:{{ServerTypeKey}}";
    public readonly string KEY_CHANNELS_IN_WORLD_FORMAT =  $"serverinfo:Keys:{{ServerTypeKey}}:{{WorldMetaId}}";
    public readonly string KEY_SERVER_NAME_FORMAT =        $"serverinfo:{{ServerName}}";

    private string serverType2ServerKeyType(ServerType serverType)
    {
        if      (ServerType.Login == serverType)    { return "LoginKey"; }
        else if (ServerType.Channel == serverType)  { return "ChannelKey"; }
        else if (ServerType.Indun == serverType)    { return "IndunKey"; }
        else { throw new TypeAccessException($"Invalid ServerType : {serverType}"); }
    }

    private (KeyType, Dictionary<REDIS_KEY_PLACE_HOLDER, REDIS_KEY_REPLACE>) buildRedisKeyByServerInfo(ServerType serverType, WORLD_META_ID worldMetaId = 0)
    {
        var key_type = KeyType.Default;
        var redis_key = new Dictionary<REDIS_KEY_PLACE_HOLDER, REDIS_KEY_REPLACE>();

        redis_key.Add("ServerTypeKey", serverType2ServerKeyType(serverType));

        if (ServerType.Channel == serverType)
        {
            key_type = KeyType.ChannelsInWorld;
            redis_key.Add("WorldMetaId", worldMetaId.ToString("000"));
        }

        return (key_type, redis_key);
    }

    private (KeyType, Dictionary<REDIS_KEY_PLACE_HOLDER, REDIS_KEY_REPLACE>) buildRedisKeyByServerInfo(SERVER_NAME serverName)
    {
        var redis_key = new Dictionary<REDIS_KEY_PLACE_HOLDER, REDIS_KEY_REPLACE>();

        redis_key.Add("ServerName", serverName);

        return (KeyType.ServerName, redis_key);
    }

    public ServerMetricsHandler(ServerMetricsManager manager, RedisConnector redisConnector)
        : base(manager, redisConnector)
    {
        var default_format =                new RedisKeyFormat((uint)KeyType.Default,               KEY_DEFAULT_FORMAT);
        var channels_in_world_format =      new RedisKeyFormat((uint)KeyType.ChannelsInWorld,       KEY_CHANNELS_IN_WORLD_FORMAT);
        var server_name_format =            new RedisKeyFormat((uint)KeyType.ServerName,            KEY_SERVER_NAME_FORMAT);


        //=========================================================================================
        // for RedisRequest Handler
        //=========================================================================================
        registerRequestHandler( (uint)HandlerType.InitByServerKeyWithServerName,    new RedisKeyFormat[] { default_format, channels_in_world_format, server_name_format },      onRedisHandle_InitByServerTypeKeyWithServerName );
        registerRequestHandler( (uint)HandlerType.GetByServerKey,                   new RedisKeyFormat[] { default_format, channels_in_world_format },                          onRedisHandle_GetByServerTypeKey );
        registerRequestHandler( (uint)HandlerType.GetByServerName,                  new RedisKeyFormat[] { server_name_format },                                                onRedisHandle_GetByServerName );
        registerRequestHandler( (uint)HandlerType.RemoveByServerKey,                new RedisKeyFormat[] { default_format },                                                    onRedisHandle_RemoveByServerTypeKey );
        registerRequestHandler( (uint)HandlerType.RemoveByServerName,               new RedisKeyFormat[] { server_name_format },                                                onRedisHandle_RemoveByServerName );
        registerRequestHandler( (uint)HandlerType.UpdateByServerName,               new RedisKeyFormat[] { server_name_format },                                                onRedisHandle_UpdateByServerName );


        //=========================================================================================
        // for Metrics Handler
        //=========================================================================================
        registerTriggerHandler((uint)TriggerType.ServerMetrics_Init,                            onTrigger_ServerMetricsInit);
        registerTriggerHandler((uint)TriggerType.ServerMetrics_AllGetAndFill,                   onTrigger_ServerMetricsAllGetAndFill);
        registerTriggerHandler((uint)TriggerType.ServerMetrics_ServerTypeGetAndFill,            onTrigger_ServerMetricsServerTypeGetAndFill);
        registerTriggerHandler((uint)TriggerType.ServerMetrics_ChannelTargetGetAndFill,         onTrigger_ServerMetricsChannelTargetGetAndFill);
        registerTriggerHandler((uint)TriggerType.ServerMetrics_GetByServerName,                 onTrigger_ServerMetricsGetByServerName);
        registerTriggerHandler((uint)TriggerType.ServerMetrics_ExpiredAllRemove,                onTrigger_ServerMetricsExpriredAllRemove);
        registerTriggerHandler((uint)TriggerType.ServerMetrics_RemoveByServerName,              onTrigger_ServerMetricsRemoveByServerName);
        registerTriggerHandler((uint)TriggerType.ServerMetrics_UpdateToCache,                   onTrigger_ServerMetricsUpdateToCache);
    }



    //=============================================================================================
    // RedisRequest 핸들러 함수
    //=============================================================================================

    public async Task<IWithResult> onRedisHandle_InitByServerTypeKeyWithServerName(REDIS_KEY[] redisKeys, object[] handlerParams)
    {
        ConditionValidCheckHelper.throwIfFalseWithCondition( () => redisKeys.Length == 2
                                                           , () => $"Invalid Parameter RedisKey !!! : 2 == redisKeyCount:{redisKeys.Length} - {toBasicString()}");
        var redis_key = redisKeys[0];
        var server_name_key = redisKeys[1];
        ArgumentNullReferenceCheckHelper.throwIfNull(server_name_key, () => $"server_name_key is null !!! - {toBasicString()}");

        var redis_connector = getRedisConnector();

        var result = new Result();

        try
        {
            var redis_database = redis_connector.getDatabase();
            NullReferenceCheckHelper.throwIfNull(redis_database, () => $"redis_database is null !!! - {toBasicString()}");

            await redis_database.SetAddAsync(redis_key, server_name_key, CommandFlags.PreferReplica);

            return new ResultOnly(result);
        }
        catch (Exception e)
        {
            var error_code = ServerErrorCode.RedisException;
            var err_msg = $"Exception !!!, Failed to perform in onRedisHandle_InitByServerTypeKey() !!! : errorCode:{error_code}, exception:{e} - {toBasicString()}";
            result.setFail(error_code, err_msg);
            Log.getLogger().error(err_msg);

            return new ResultOnly(result);
        }
    }

    public async Task<IWithResult> onRedisHandle_GetByServerTypeKey(REDIS_KEY[] redisKeys, object[] handlerParams)
    {
        ConditionValidCheckHelper.throwIfFalseWithCondition( () => redisKeys.Length == 1
                                                           , () => $"Invalid Parameter RedisKey !!!  : 1 == redisKeyCount:{redisKeys.Length} - {toBasicString()}");

        var redis_key = redisKeys[0];

        var redis_connector = getRedisConnector();
        var result_value = new ResultValue<List<RedisValue>>(new Result(), new List<RedisValue>());

        var result = new Result();

        try
        {
            var redis_database = redis_connector.getDatabase();
            NullReferenceCheckHelper.throwIfNull(redis_database, () => $"redis_database is null !!! - {toBasicString()}");

            var server_info_keys = await redis_database.SetMembersAsync(redis_key, CommandFlags.PreferReplica);
            result_value.ValueOfResult.AddRange(server_info_keys);

            return result_value;
        }
        catch (Exception e)
        {
            var error_code = ServerErrorCode.RedisException;
            var err_msg = $"Exception !!!, Failed to perform !!!, in onRedisHandle_GetByServerTypeKey() : errorCode:{error_code}, exception:{e} - {toBasicString()}";
            result.setFail(error_code, err_msg);
            Log.getLogger().error(err_msg);

            return new ResultOnly(result);
        }
    }

    public async Task<IWithResult> onRedisHandle_GetByServerName(REDIS_KEY[] redisKeys, object[] handlerParams)
    {
        ConditionValidCheckHelper.throwIfFalseWithCondition( () => redisKeys.Length == 1
                                                           , () => $"Invalid Parameter RedisKey !!!  : 1 == redisKeyCount:{redisKeys.Length} - {toBasicString()}");

        var redis_key = redisKeys[0];

        var redis_connector = getRedisConnector();

        var result = new Result();

        try
        {
            var redis_database = redis_connector.getDatabase();
            NullReferenceCheckHelper.throwIfNull(redis_database, () => $"redis_database is null !!! - {toBasicString()}");

            var redis_result = await redis_database.StringGetAsync(redis_key, CommandFlags.PreferReplica);
            if(true == redis_result.IsNull)
            {
                Log.getLogger().debug($"redis_result.IsNull == true !!!, StringGetAsync(), in onRedisHandle_GetByServerName() : redisKey:{redis_key} - {toBasicString()}");
                return new ResultOnly(result);
            }

            var server_info = JsonConvert.DeserializeObject<ServerInfo>(redis_result.ToString());
            if(null == server_info)
            {
                Log.getLogger().debug($"ServerInfo is Null !!!, JsonConvert.DeserializeObject<ServerInfo>(), in in onRedisHandle_GetByServerName() : redisKey:{redis_key} - {toBasicString()}");
                return new ResultOnly(result);
            }

            return new ResultValue<ServerInfo>(result, server_info);
        }
        catch (Exception e)
        {
            var error_code = ServerErrorCode.RedisException;
            var err_msg = $"Exception !!!, Failed to perform !!!, in onRedisHandle_GetByServerName() : errorCode:{error_code}, exception:{e} - {toBasicString()}";
            result.setFail(error_code, err_msg);
            Log.getLogger().error(err_msg);

            return new ResultOnly(result);
        }
    }

    public async Task<IWithResult> onRedisHandle_RemoveByServerTypeKey(REDIS_KEY[] redisKeys, object[] handlerParams)
    {
        ConditionValidCheckHelper.throwIfFalseWithCondition( () => redisKeys.Length == 1
                                                           , () => $"Invalid Parameter RedisKey !!! : 1 == redisKeyCount:{redisKeys.Length} - {toBasicString()}");

        var redis_key = redisKeys[0];

        var redis_connector = getRedisConnector();

        var result = new Result();

        try
        {
            var redis_database = redis_connector.getDatabase();
            NullReferenceCheckHelper.throwIfNull(redis_database, () => $"redis_database is null !!! - {toBasicString()}");

            var server_info_keys = await redis_database.SetMembersAsync(redis_key, CommandFlags.PreferReplica);
            foreach (var data_key in server_info_keys)
            {
                if (data_key.IsNull == true)
                {
                    continue;
                }

                var value = await redis_database.StringGetAsync(data_key.ToString(), CommandFlags.PreferReplica);
                if (value.IsNull == true)
                {
                    Log.getLogger().debug($"ServerInfo is Null !!! : serverKey:{data_key} - {toBasicString()}");
                    await redis_database.SetRemoveAsync(redis_key, data_key);
                }
            }

            return new ResultOnly(result);
        }
        catch (Exception e)
        {
            var error_code = ServerErrorCode.RedisException;
            var err_msg = $"Exception !!!, Failed to perform !!!, in onRedisHandle_RemoveByServerTypeKey() : errorCode:{error_code}, exception:{e} - {toBasicString()}";
            result.setFail(error_code, err_msg);
            Log.getLogger().error(err_msg);

            return new ResultOnly(result);
        }
    }

    public async Task<IWithResult> onRedisHandle_RemoveByServerName(REDIS_KEY[] redisKeys, object[] handlerParams)
    {
        ConditionValidCheckHelper.throwIfFalseWithCondition( () => redisKeys.Length == 1
                                                           , () => $"Invalid Parameter RedisKey !!!  : 1 == redisKeyCount:{redisKeys.Length} - {toBasicString()}");

        var redis_key = redisKeys[0];

        var redis_connector = getRedisConnector();

        var result = new Result();

        try
        {
            var redis_database = redis_connector.getDatabase();
            NullReferenceCheckHelper.throwIfNull(redis_database, () => $"redis_database is null !!! - {toBasicString()}");

            await redis_database.KeyDeleteAsync(redis_key);

            return new ResultOnly(result);
        }
        catch (Exception e)
        {
            var error_code = ServerErrorCode.RedisException;
            var err_msg = $"Exception !!!, Failed to perform !!!, in onRedisHandle_RemoveByServerName() : errorCode:{error_code}, exception:{e} - {toBasicString()}";
            result.setFail(error_code, err_msg);
            Log.getLogger().error(err_msg);

            return new ResultOnly(result);
        }
    }

    public async Task<IWithResult> onRedisHandle_UpdateByServerName(REDIS_KEY[] redisKeys, object[] handlerParams)
    {
        ConditionValidCheckHelper.throwIfFalseWithCondition( () => redisKeys.Length == 1
                                                           , () => $"Invalid Parameter RedisKey !!!  : 1 == redisKeyCount:{redisKeys.Length} - {toBasicString()}");
        ConditionValidCheckHelper.throwIfFalseWithCondition( () => handlerParams.Length == 1
                                                           , () => $"Invalid Parameter handlerParams !!!  : 1 == handlerParamsCount:{handlerParams.Length} - {toBasicString()}");
        var redis_key = redisKeys[0];
        var server_info = handlerParams[0] as ServerInfo;
        NullReferenceCheckHelper.throwIfNull(server_info, () => $"server_info is null !!! - {toBasicString()}");

        var redis_connector = getRedisConnector();

        var result = new Result();

        try
        {
            var redis_database = redis_connector.getDatabase();
            NullReferenceCheckHelper.throwIfNull(redis_database, () => $"redis_database is null !!! - {toBasicString()}");

            string json = JsonConvert.SerializeObject(server_info);
            await redis_database.StringSetAsync(redis_key, json, TimeSpan.FromMilliseconds(ServerMetricsManager.KEEP_SERVER_UPDATE_INTERVAL_MSEC));

            return new ResultOnly(result);
        }
        catch (Exception e)
        {
            var error_code = ServerErrorCode.RedisException;
            var err_msg = $"Exception !!!, Failed to perform !!!, in onRedisHandle_UpdateByServerName() : errorCode:{error_code}, exception:{e} - {toBasicString()}";
            result.setFail(error_code, err_msg);
            Log.getLogger().error(err_msg);

            return new ResultOnly(result);
        }
    }



    //=============================================================================================
    // Metrics Trigger 핸들러 함수
    //=============================================================================================

    //---------------------------------------------------------------------------------------------
    // handlerParams : SERVER_NAME, ServerType, WORLD_META_ID
    //---------------------------------------------------------------------------------------------
    public async Task<IWithResult> onTrigger_ServerMetricsInit(object[] handlerParams)
    {
        ConditionValidCheckHelper.throwIfFalseWithCondition( () => handlerParams.Length == 3
                                                           , () => $"Invalid Parameter count !!! : 3 == paramCount:{handlerParams.Length} - {toBasicString()}" );
        var server_name = handlerParams[0] as string;
        ArgumentNullReferenceCheckHelper.throwIfNull(server_name, () => $"server_name is null !!! - {toBasicString()}");
        var server_type = (ServerType)handlerParams[1];
        ArgumentNullReferenceCheckHelper.throwIfNull(server_type, () => $"server_type is null !!! - {toBasicString()}");
        var world_meta_id = (WORLD_META_ID)Convert.ToUInt32(handlerParams[2]);
        ArgumentNullReferenceCheckHelper.throwIfNull(world_meta_id, () => $"world_meta_id is null !!! - {toBasicString()}");

        var err_msg = string.Empty;

        var to_replace_params = new Dictionary<REDIS_KEY_FORMAT_TYPE, Dictionary<REDIS_KEY_PLACE_HOLDER, REDIS_KEY_REPLACE>>();

        var handler_type = HandlerType.InitByServerKeyWithServerName;
        var redis_key_1 = buildRedisKeyByServerInfo(server_type, world_meta_id);
        to_replace_params.Add((uint)redis_key_1.Item1, redis_key_1.Item2);
        var redis_key_2 = buildRedisKeyByServerInfo(server_name);
        to_replace_params.Add((uint)redis_key_2.Item1, redis_key_2.Item2);

        var with_result = await executeRequestHandlerByHandlerType( (uint)handler_type, to_replace_params );
        if (with_result.Result.isFail())
        {
            err_msg = $"Failed to executeRequestHandlerByHandlerType !!!, in onTrigger_ServerMetricsInit() : {with_result.Result.toBasicString()}, handlerType:{handler_type} - {toBasicString()}";
            Log.getLogger().error(err_msg);
            return with_result;
        }

        return with_result;
    }

    //---------------------------------------------------------------------------------------------
    // handlerParams : 조회 대상 WORLD_META_ID 목록
    //---------------------------------------------------------------------------------------------
    public async Task<IWithResult> onTrigger_ServerMetricsAllGetAndFill(object[] handlerParams)
    {
        ConditionValidCheckHelper.throwIfFalseWithCondition( () => handlerParams.Length == 1
                                                           , () => $"Invalid Parameter count !!! : 1 == paramCount:{handlerParams.Length} - {toBasicString()}");

        var result_value = new ResultValue<List<ServerInfo>>(new Result(), new List<ServerInfo>());

        var server_typies = new List<ServerType>() { ServerType.Login, ServerType.Channel, ServerType.Indun };
        var world_meta_ids = handlerParams[0] as List<WORLD_META_ID>;
        NullReferenceCheckHelper.throwIfNull(world_meta_ids, () => $"world_meta_ids is null !!! - {toBasicString()}");

        var params_for_redis_requests = new List<(HandlerType, Dictionary<REDIS_KEY_FORMAT_TYPE, Dictionary<REDIS_KEY_PLACE_HOLDER, REDIS_KEY_REPLACE>>)>();

        foreach (var server_type in server_typies)
        {
            var handler_type = HandlerType.GetByServerKey;
            if (ServerType.Channel == server_type)
            {
                for (var i = 0; i < world_meta_ids.Count; i++)
                {
                    var world_meta_id = (WORLD_META_ID)world_meta_ids[i];

                    var redis_key = buildRedisKeyByServerInfo(server_type, world_meta_id);
                    var to_replace_params = new Dictionary<REDIS_KEY_FORMAT_TYPE, Dictionary<REDIS_KEY_PLACE_HOLDER, REDIS_KEY_REPLACE>>();
                    to_replace_params.Add((uint)redis_key.Item1, redis_key.Item2);

                    params_for_redis_requests.Add((handler_type, to_replace_params));
                }
            }
            else
            {
                var redis_key = buildRedisKeyByServerInfo(server_type);
                var to_replace_params = new Dictionary<REDIS_KEY_FORMAT_TYPE, Dictionary<REDIS_KEY_PLACE_HOLDER, REDIS_KEY_REPLACE>>();
                to_replace_params.Add((uint)redis_key.Item1, redis_key.Item2);

                params_for_redis_requests.Add((handler_type, to_replace_params));
            }
        }

        return await getAndFillServerInfos(params_for_redis_requests);
    }

    //---------------------------------------------------------------------------------------------
    // handlerParams : 조회 대상 ServerType, WORLD_META_ID
    //---------------------------------------------------------------------------------------------
    public async Task<IWithResult> onTrigger_ServerMetricsServerTypeGetAndFill(object[] handlerParams)
    {
        ConditionValidCheckHelper.throwIfFalseWithCondition( () => handlerParams.Length == 2
                                                           , () => $"Invalid Parameter count !!! : 2 == paramCount:{handlerParams.Length} - {toBasicString()}");

        var server_type = (ServerType)handlerParams[0];
        var world_meta_id = (WORLD_META_ID)Convert.ToUInt32(handlerParams[1]);

        var params_for_redis_requests = new List<(HandlerType, Dictionary<REDIS_KEY_FORMAT_TYPE, Dictionary<REDIS_KEY_PLACE_HOLDER, REDIS_KEY_REPLACE>>)>();

        var handler_type = HandlerType.GetByServerKey;
        if (ServerType.Channel == server_type)
        {
            var redis_key = buildRedisKeyByServerInfo(server_type, world_meta_id);
            var to_replace_params = new Dictionary<REDIS_KEY_FORMAT_TYPE, Dictionary<REDIS_KEY_PLACE_HOLDER, REDIS_KEY_REPLACE>>();
            to_replace_params.Add((uint)redis_key.Item1, redis_key.Item2);

            params_for_redis_requests.Add((handler_type, to_replace_params));
        }
        else
        {
            var redis_key = buildRedisKeyByServerInfo(server_type);
            var to_replace_params = new Dictionary<REDIS_KEY_FORMAT_TYPE, Dictionary<REDIS_KEY_PLACE_HOLDER, REDIS_KEY_REPLACE>>();
            to_replace_params.Add((uint)redis_key.Item1, redis_key.Item2);

            params_for_redis_requests.Add((handler_type, to_replace_params));
        }

        return await getAndFillServerInfos(params_for_redis_requests);
    }


    //---------------------------------------------------------------------------------------------
    // handlerParams : 조회 대상 WORLD_META_ID, ChannelNo
    //---------------------------------------------------------------------------------------------
    public async Task<IWithResult> onTrigger_ServerMetricsChannelTargetGetAndFill(object[] handlerParams)
    {
        ConditionValidCheckHelper.throwIfFalseWithCondition( () => handlerParams.Length == 2
                                                           , () => $"Invalid Parameter count !!! : 2 == paramCount:{handlerParams.Length} - {toBasicString()}");

        var world_meta_id = (WORLD_META_ID)Convert.ToUInt32(handlerParams[0]);
        var channel_no = Convert.ToUInt32(handlerParams[1]);

        var params_for_redis_requests = new List<(HandlerType, Dictionary<REDIS_KEY_FORMAT_TYPE, Dictionary<REDIS_KEY_PLACE_HOLDER, REDIS_KEY_REPLACE>>)>();

        var server_name = ServerBase.ServerHelper.makeGameServerName(ServerType.Channel, (int)world_meta_id, (int)channel_no);

        var handler_type = HandlerType.GetByServerName;
        var to_replace_params = new Dictionary<REDIS_KEY_FORMAT_TYPE, Dictionary<REDIS_KEY_PLACE_HOLDER, REDIS_KEY_REPLACE>>();
        var redis_key = buildRedisKeyByServerInfo(server_name);
        to_replace_params.Add((uint)redis_key.Item1, redis_key.Item2);

        var with_result = await executeRequestHandlerByHandlerType((uint)handler_type, to_replace_params);
        if (with_result.Result.isFail())
        {
            var err_msg = $"Failed to executeRequestHandlerByHandlerType !!!, in onTrigger_ServerMetricsChannelTargetGetAndFill() : {with_result.Result.toBasicString()}, handlerType:{handler_type} - {toBasicString()}";
            Log.getLogger().error(err_msg);
            return with_result;
        }

        if (with_result.isResultOnly())
        {
            var err_msg = $"isResultOnly() == true, in onTrigger_ServerMetricsChannelTargetGetAndFill(), Not found ServerInfo - handlerType:{handler_type}, {toBasicString()}";
            Log.getLogger().debug(err_msg);
            return with_result;
        }

        var result_value_server_info = with_result as ResultValue<ServerInfo>;
        NullReferenceCheckHelper.throwIfNull(result_value_server_info, () => $"result_value_server_info is null !!! - handlerType:{handler_type}");

        return result_value_server_info;
    }

    private async Task<IWithResult> getAndFillServerInfos(List<(HandlerType, Dictionary<REDIS_KEY_FORMAT_TYPE, Dictionary<REDIS_KEY_PLACE_HOLDER, REDIS_KEY_REPLACE>>)> paramForRedisRequests)
    {
        var result_value = new ResultValue<List<ServerInfo>>(new Result(), new List<ServerInfo>());

        var manager = getServerMetricsManager();
        var cache_servers = manager.getCacheServers();

        long curr_tick = Environment.TickCount64;

        foreach (var param in paramForRedisRequests)
        {
            var handler_type = param.Item1;
            var redis_key = param.Item2;

            bool to_upsert_cache_server = false;

            var server_keys = replaceByHandlerType((uint)handler_type, redis_key);
            if (0 >= server_keys.Length)
            {
                var err_msg = $"Nothing was replaced in the format !!!, in getAndFillServerInfos() : handlerType:{handler_type}, {toBasicString()}";
                Log.getLogger().error(err_msg);
                continue;
            }

            var server_key = server_keys[0];
            if (false == cache_servers.TryGetValue(server_key, out var found_cache_server))
            {
                to_upsert_cache_server = true;

                found_cache_server = new ServerMetricsCacheRequest.CacheServerKey();
            }
            else
            {
                if ((curr_tick - found_cache_server.tick) > 100)
                {
                    to_upsert_cache_server = true;
                }
            }

            var with_result = await executeRequestHandlerByHandlerType((uint)handler_type, redis_key);
            if (with_result.Result.isFail())
            {
                var err_msg = $"Failed to executeRequestHandlerByHandlerType !!!, in getAndFillServerInfos() : {with_result.Result.toBasicString()} - handlerType:{handler_type}, {toBasicString()}";
                Log.getLogger().error(err_msg);
                continue;
            }

            if (with_result.isResultOnly())
            {
                continue;
            }

            var with_result_value = with_result as ResultValue<List<RedisValue>>;
            NullReferenceCheckHelper.throwIfNull(with_result_value, () => $"with_result_value is null !!! - handlerType:{handler_type}");

            if (true == to_upsert_cache_server)
            {
                found_cache_server.key = server_key;
                found_cache_server.tick = curr_tick;
                found_cache_server.redisValue.AddRange(with_result_value.ValueOfResult);

                cache_servers.AddOrUpdate(server_key, found_cache_server, (key, value) => value = found_cache_server);
            }

            handler_type = HandlerType.GetByServerName;
            foreach (var server_info_key in with_result_value.ValueOfResult)
            {
                var with_result_redis_read = await executeRequestHandlerByHandlerType((uint)handler_type
                                                                                     , new REDIS_KEY[] { server_info_key.ToString() });
                if (with_result_redis_read.Result.isFail())
                {
                    var err_msg = $"Failed to executeRequestHandlerByHandlerType !!!, in getAndFillServerInfos() : {with_result_redis_read.Result.toBasicString()}, handlerType:{handler_type} - {toBasicString()}";
                    Log.getLogger().error(err_msg);
                    continue;
                }

                if (with_result_redis_read.isResultOnly())
                {
                    continue;
                }

                var result_value_server_info = with_result_redis_read as ResultValue<ServerInfo>;
                NullReferenceCheckHelper.throwIfNull(result_value_server_info, () => $"result_value_server_info is null !!! - handlerType:{handler_type}");
                if (null == result_value_server_info.ValueOfResult)
                {
                    var err_msg = $"Failed to executeRequestHandlerByHandlerType !!!, in getAndFillServerInfos() : {with_result_redis_read.Result.toBasicString()}, handlerType:{handler_type} - {toBasicString()}";
                    Log.getLogger().error(err_msg);
                    continue;
                }

                result_value.ValueOfResult.Add(result_value_server_info.ValueOfResult);
            }
        }

        return result_value;
    }

    //---------------------------------------------------------------------------------------------
    // handlerParams : SERVER_NAME
    //---------------------------------------------------------------------------------------------
    public async Task<IWithResult> onTrigger_ServerMetricsGetByServerName(object[] handlerParams)
    {
        ConditionValidCheckHelper.throwIfFalseWithCondition( () => handlerParams.Length > 0
                                                           , () => $"Invalid Parameter count !!! : 0 < paramCount:{handlerParams.Length} - {toBasicString()}" );
        var server_name = handlerParams[0] as string;
        ArgumentNullReferenceCheckHelper.throwIfNull(server_name, () => $"server_name is null !!! - {toBasicString()}");

        var handler_type = HandlerType.GetByServerName;
        var to_replace_params = new Dictionary<REDIS_KEY_FORMAT_TYPE, Dictionary<REDIS_KEY_PLACE_HOLDER, REDIS_KEY_REPLACE>>();
        var redis_key = buildRedisKeyByServerInfo(server_name);
        to_replace_params.Add((uint)redis_key.Item1, redis_key.Item2);

        var with_result = await executeRequestHandlerByHandlerType( (uint)handler_type, to_replace_params );
        if (with_result.Result.isFail())
        {
            var err_msg = $"Failed to executeRequestHandlerByHandlerType !!!, in onTrigger_ServerMetricsGetByServerName() : {with_result.Result.toBasicString()}, handlerType:{handler_type} - {toBasicString()}";
            Log.getLogger().error(err_msg);
            return with_result;
        }

        if (with_result.isResultOnly())
        {
            var err_msg = $"isResultOnly() == true, in onTrigger_ServerMetricsGetByServerName(), Not found ServerInfo - handlerType:{handler_type}, {toBasicString()}";
            Log.getLogger().debug(err_msg);
            return with_result;
        }

        var result_value_server_info = with_result as ResultValue<ServerInfo>;
        NullReferenceCheckHelper.throwIfNull(result_value_server_info, () => $"result_value_server_info is null !!! - handlerType:{handler_type}");

        return result_value_server_info;
    }

    //---------------------------------------------------------------------------------------------
    // handlerParams : 체크 대상 WORLD_META_ID 목록
    //---------------------------------------------------------------------------------------------
    public async Task<IWithResult> onTrigger_ServerMetricsExpriredAllRemove(object[] handlerParams)
    {
        ConditionValidCheckHelper.throwIfFalseWithCondition(() => handlerParams.Length == 1
                                                           , () => $"Invalid Parameter count !!! : 1 == paramCount:{handlerParams.Length} - {toBasicString()}");

        var result_value = new ResultValue<List<ServerInfo>>(new Result(), new List<ServerInfo>());

        var server_typies = new List<ServerType>() { ServerType.Login, ServerType.Channel, ServerType.Indun };
        var world_meta_ids = handlerParams[0] as List<WORLD_META_ID>;
        NullReferenceCheckHelper.throwIfNull(world_meta_ids, () => $"world_meta_ids is null !!! - {toBasicString()}");

        var params_for_redis_requests = new List<(HandlerType, Dictionary<REDIS_KEY_FORMAT_TYPE, Dictionary<REDIS_KEY_PLACE_HOLDER, REDIS_KEY_REPLACE>>)>();

        foreach (var server_type in server_typies)
        {
            var handler_type = HandlerType.RemoveByServerKey;
            if (ServerType.Channel == server_type)
            {
                for (var i = 0; i < world_meta_ids.Count; i++)
                {
                    var world_meta_id = (WORLD_META_ID)world_meta_ids[i];                    

                    var redis_key = buildRedisKeyByServerInfo(server_type, world_meta_id);
                    var to_replace_params = new Dictionary<REDIS_KEY_FORMAT_TYPE, Dictionary<REDIS_KEY_PLACE_HOLDER, REDIS_KEY_REPLACE>>();
                    to_replace_params.Add((uint)redis_key.Item1, redis_key.Item2);

                    params_for_redis_requests.Add((handler_type, to_replace_params));
                }
            }
            else
            {
                var redis_key = buildRedisKeyByServerInfo(server_type);
                var to_replace_params = new Dictionary<REDIS_KEY_FORMAT_TYPE, Dictionary<REDIS_KEY_PLACE_HOLDER, REDIS_KEY_REPLACE>>();
                to_replace_params.Add((uint)redis_key.Item1, redis_key.Item2);

                params_for_redis_requests.Add((handler_type, to_replace_params));
            }
        }

        foreach(var param in params_for_redis_requests)
        {
            var handler_type = param.Item1;
            var redis_key = param.Item2;

            var with_result = await executeRequestHandlerByHandlerType( (uint)handler_type, redis_key );
            if (with_result.Result.isFail())
            {
                var err_msg = $"Failed to executeRequestHandlerByHandlerType !!!, in onTrigger_ServerMetricsExpriredAllRemove() : {with_result.Result.toBasicString()} - handlerType:{handler_type}, {toBasicString()}";
                Log.getLogger().error(err_msg);
            }
        }

        return result_value;
    }


    //---------------------------------------------------------------------------------------------
    // handlerParams : 삭제할 SERVER_NAME
    //---------------------------------------------------------------------------------------------
    public async Task<IWithResult> onTrigger_ServerMetricsRemoveByServerName(object[] handlerParams)
    {
        ConditionValidCheckHelper.throwIfFalseWithCondition(() => handlerParams.Length > 0
                                                           , () => $"Invalid Parameter count !!! : 0 < paramCount:{handlerParams.Length} - {toBasicString()}");
        var server_name = handlerParams[0] as string;
        ArgumentNullReferenceCheckHelper.throwIfNull(server_name, () => $"server_name is null !!! - {toBasicString()}");

        var err_msg = string.Empty;

        var handler_type = HandlerType.RemoveByServerName;
        var to_replace_params = new Dictionary<REDIS_KEY_FORMAT_TYPE, Dictionary<REDIS_KEY_PLACE_HOLDER, REDIS_KEY_REPLACE>>();
        var redis_key = buildRedisKeyByServerInfo(server_name);
        to_replace_params.Add((uint)redis_key.Item1, redis_key.Item2);

        var with_result = await executeRequestHandlerByHandlerType( (uint)handler_type, to_replace_params );
        if (with_result.Result.isFail())
        {
            err_msg = $"Failed to executeRequestHandlerByHandlerType !!!, in onTrigger_ServerMetricsRemoveByServerName() : {with_result.Result.toBasicString()}, handlerType:{handler_type} - {toBasicString()}";
            Log.getLogger().error(err_msg);
            return with_result;
        }

        return with_result;
    }

    //---------------------------------------------------------------------------------------------
    // handlerParams : 갱신 서버 정보
    //---------------------------------------------------------------------------------------------
    public async Task<IWithResult> onTrigger_ServerMetricsUpdateToCache(object[] handlerParams)
    {
        ConditionValidCheckHelper.throwIfFalseWithCondition( () => handlerParams.Length == 2
                                                           , () => $"Invalid Parameter count !!! : 2 == paramCount:{handlerParams.Length} - {toBasicString()}");
        var server_name = handlerParams[0] as string;
        ArgumentNullReferenceCheckHelper.throwIfNull(server_name, () => $"server_name is null !!! - {toBasicString()}");
        var server_info = handlerParams[1] as ServerInfo;
        ArgumentNullReferenceCheckHelper.throwIfNull(server_info, () => $"server_info is null !!! - {toBasicString()}");

        var err_msg = string.Empty;

        var handler_type = HandlerType.UpdateByServerName;
        var to_replace_params = new Dictionary<REDIS_KEY_FORMAT_TYPE, Dictionary<REDIS_KEY_PLACE_HOLDER, REDIS_KEY_REPLACE>>();
        var redis_key = buildRedisKeyByServerInfo(server_name);
        to_replace_params.Add((uint)redis_key.Item1, redis_key.Item2);

        var with_result = await executeRequestHandlerByHandlerType((uint)handler_type, to_replace_params, server_info);
        if (with_result.Result.isFail())
        {
            err_msg = $"Failed to executeRequestHandlerByHandlerType !!!, in onTrigger_ServerMetricsUpdateToCache() : {with_result.Result.toBasicString()}, handlerType:{handler_type} - {toBasicString()}";
            Log.getLogger().error(err_msg);
            return with_result;
        }

        return with_result;
    }
}