using System.Text;
using Newtonsoft.Json;
using Google.Protobuf;
using Google.Protobuf.WellKnownTypes;


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


namespace ServerCommon;

public class EchoSystemRequester
{
    private readonly HttpClient m_httpClient;
    private readonly HttpClient? m_slackClient;
    
    private const int DefaultTimeOutMs = 30_000;

    private const string m_get_rollup_by_date_url_base = "/web/v3/rollup/ymd";
    private const string m_get_rollup_by_epoch_url_base = "/web/v3/rollup/seq";
    private const string m_post_calium_event_url = "/web/v3/circ_event";
    private const string m_post_calium_event_time_url = "/web/v3/circ_event_time";
    private const string m_get_acc_volume_url = "/web/v3/converter/acc_volume";

    private readonly string m_server_name;
    private readonly string m_ip_port;

    public EchoSystemRequester(string baseAddress, string? serverName = null, string? ipPort = null, string? errorSlackAddress = null)
    {
        m_server_name = serverName ?? "None" ;
        m_ip_port = ipPort ?? "None";
        
        m_httpClient = new HttpClient
        {
            BaseAddress = new Uri(baseAddress),
            Timeout = TimeSpan.FromMilliseconds(DefaultTimeOutMs)
        };

        if (!string.IsNullOrEmpty(errorSlackAddress))
        {
            m_slackClient = new HttpClient
            {
                BaseAddress = new Uri(errorSlackAddress),
                Timeout = TimeSpan.FromMilliseconds(DefaultTimeOutMs)
            };   
        }
    }

    public async Task<Result> checkWeb3Connection()
    {
        var res = await getConverterSyncData();
        if (res.result.isFail() && res.response == null) return res.result;

        return new Result();
    }
    
    public async Task<(Result result, CaliumRollUpResponse? response)> getDailyRollUpData(int epoch)
    {
        var result = new Result();
        
        if (epoch <= 0)
        {
            var err_msg = $"fail to get daily roll up data !!! : epoch is zero - {epoch}";
            result.setFail(ServerErrorCode.FailToSendEchoSystem, err_msg);
            Log.getLogger().error(result.toBasicString());
            return (result, null);
        }
        
        var url_path = $"{m_get_rollup_by_epoch_url_base}/{epoch}";
        return await getDailyRollUpData(url_path);
    }

    public async Task<(Result result, CaliumRollUpResponse? response)> getDailyRollUpData(DateTime epochDate)
    {
        var url_path = $"{m_get_rollup_by_date_url_base}/{epochDate:yyyyMMdd}";
        return await getDailyRollUpData(url_path);
    }

    public async Task<(Result result, ConverterSyncResponse? response)> getConverterSyncData()
    {
        var request = EchoSystemHelper.makeRequestMessage(EchoSystemMethod.Get, m_get_acc_volume_url);
        
        Log.getLogger().debug($"EchoSystemRequester Request: url[{request.RequestUri}]");
        var response = await sendHttpRequest<ConverterSyncResponse>(request);
        
        return response;
    }

    public async Task<(Result result, CaliumEventResponse? response)> postCaliumEvent(CaliumEventRequest data)
    {
        var request = EchoSystemHelper.makeRequestMessage(EchoSystemMethod.Post, m_post_calium_event_time_url);
        data.m_event_time = DateTimeHelper.Current.toStringWithUtcIso8601();
        
        var body = JsonConvert.SerializeObject(data);
        request.Content = new StringContent(body, Encoding.UTF8, "application/json");

        Log.getLogger().debug($"EchoSystemRequester Request: url[{request.RequestUri}] - content[{body}");
        var response = await sendHttpRequest<CaliumEventResponse>(request);
        
        return response;
    }
    
    private async Task sendEchoSystemSlackMessage(HttpRequestMessage request, string errMsg)
    {
        if (null == m_slackClient) return;

        var title = getEchoSystemType(request.RequestUri!.ToString());

        var slack_msg_builder = new EchoSystemSlackMessageBuilder(title, m_server_name, m_ip_port);
        slack_msg_builder.appendValue("URI", $"{m_httpClient.BaseAddress}{request.RequestUri}");
        if (null != request.Content)
        {
            slack_msg_builder.appendValue("Param", await request.Content.ReadAsStringAsync(), true);
        }
        slack_msg_builder.appendValue("ERROR", errMsg, true);

        var req = EchoSystemHelper.makeRequestMessage(EchoSystemMethod.Post, "");
        var content = slack_msg_builder.build();
        req.Content = new StringContent(content);

        try
        {
            Log.getLogger().debug($"EchoSystemRequester Slack Message Request: url[{m_slackClient.BaseAddress}] - content[{content}");
            var res = await m_slackClient.SendAsync(req);

            var res_content = await res.Content.ReadAsStringAsync();
            Log.getLogger().debug($"EchoSystemRequester Slack Message Response: url[{m_slackClient.BaseAddress}] - content[{res_content}");
        }
        catch (Exception e)
        {
            var err_msg = $"EchoSystemRequester Slack Message Exception!!: {e}";
            Log.getLogger().error(err_msg);
        }
    }

    private static string getEchoSystemType(string uri)
    {
        return uri switch
        {
            m_get_rollup_by_epoch_url_base or m_get_rollup_by_date_url_base => "롤업 데이터 조회",
            m_post_calium_event_url => "유통량 적재",
            m_get_acc_volume_url => "롤업 동기화 조회",
            _ => string.Empty
        };
    }

    private async Task<(Result result, CaliumRollUpResponse? response)> getDailyRollUpData(string urlPath)
    {
        var request = EchoSystemHelper.makeRequestMessage(EchoSystemMethod.Get, urlPath);
        
        Log.getLogger().debug($"EchoSystemRequester Request: url[{request.RequestUri}]");
        var response = await sendHttpRequest<CaliumRollUpResponse>(request);

        return response;
    }

    private async Task<(Result, TResponse?)> sendHttpRequest<TResponse>(HttpRequestMessage request) where TResponse : EchoSystemBaseResponse
    {
        var result = new Result();

        try
        {
            var response = await m_httpClient.SendAsync(request, new CancellationToken());
            if (response.IsSuccessStatusCode == false)
            {
                var err_msg = $"failed to get {nameof(TResponse)} data !!! : response error[{response.StatusCode}]";
                result.setFail(ServerErrorCode.FailToGetEchoSystemHttpError, err_msg);
                Log.getLogger().error(result.toBasicString());

                await sendEchoSystemSlackMessage(request, err_msg);
                return (result, null);
            }

            var content = await response.Content.ReadAsStringAsync();
            Log.getLogger().debug($"EchoSystemRequester Response: url[{request.RequestUri}] - content[{content}]");

            var msg = JsonConvert.DeserializeObject<TResponse>(content);
            if (null == msg)
            {
                var err_msg = $"failed to get {nameof(TResponse)} data !!! - response message is null !!!";
                result.setFail(ServerErrorCode.FailToGetEchoSystemMessageNull, err_msg);
                Log.getLogger().error(result.toBasicString());

                await sendEchoSystemSlackMessage(request, err_msg);
                return (result, null);
            }

            var check_response = checkEchoSystemResponse<TResponse>(msg);
            return (check_response, msg);
        }
        catch (Exception e)
        {
            var err_msg = $"failed to get EchoSystemRequester response !!! : exception - {e}";
            result.setFail(ServerErrorCode.FailToGetEchoSystemException, err_msg);
            Log.getLogger().error(result.toBasicString());
            
            await sendEchoSystemSlackMessage(request, e.ToString());
            return (result, null);
        }   
    }
    
    private Result checkEchoSystemResponse<T>(EchoSystemBaseResponse response)
    {
        var result = new Result();
        
        if (false == response.m_success || !string.IsNullOrEmpty(response.m_code))
        {
            var err_msg = $"response is failed !!! : {nameof(T)} - {response.m_code ?? string.Empty}";
            result.setFail(ServerErrorCode.GetFailEchoSystemResponse, err_msg);
            Log.getLogger().error(result.toBasicString());
        }
        
        return result;
    }
}