using Hncore.Infrastructure.Common;
using Hncore.Infrastructure.Extension;
using Hncore.Infrastructure.Serializer;
using Hncore.Pass.MsgCenter.Constant;
using Hncore.Pass.MsgCenter.Util;
using Hncore.Wx.Open.Enums;
using System.Net.Http;
using System.Threading.Tasks;

namespace Hncore.Wx.Open
{
    public static class TemplateApi
    {
        private static IHttpClientFactory _HttpClientFactory;

        public static void Init(IHttpClientFactory HttpClientFactory)
        {
            _HttpClientFactory = HttpClientFactory;
        }
        private static HttpClient GetHttpClient()
        {
            return _HttpClientFactory.CreateClient("WxOpen");
        }
        /// <summary>
        /// 开放平台或者公众平台或者小程序发送模板消息
        /// </summary>
        /// <param name="appId">公众号appid</param>
        /// <param name="templateId">模板id</param>
        /// <param name="to">openid ，号分割</param>
        /// <param name="tData">数据</param>     
        /// <returns></returns>       
        public static async Task<SendResult> SendTemplateMessageAsync(string appId, string to, ChannelType chennel, TemplateBaseModel tData)
        {
            var wxAppSecret = WxOpenApi.GetWxAppSecret(appId);
            var access_token = "";
            if (!string.IsNullOrWhiteSpace(wxAppSecret))//公众平台或者小程序直接发送模板消息
            {
                access_token = await WxOpenApi.GetAccessToken(appId, wxAppSecret);
            }
            else//开放平台代公众平台发送模板消息
            {
                access_token = await WxOpenApi.GetAuthorizerAccessToken(appId);
            }

            var tplId =await GetTemplateIdAsync(appId, tData.template_id);

            if (string.IsNullOrWhiteSpace(tplId))
            {
                LogHelper.Error("没有找到对应的模板Id", $"appid={appId},tpl={tData.template_id}");
                return new SendResult()
                {
                    errcode = 10001,
                    errmsg = "没有对应的模板"
                };
            }

            tData.template_id = tplId;
            var userList = to.Split(',');
            foreach (var touser in userList)
            {
                tData.touser = touser;
                var reqData = tData.ToData();
                if (chennel == ChannelType.MP)
                {
                    mp_send(access_token, reqData);
                }
                else if (chennel == ChannelType.MiniApp)
                {
                    miniapp_send(access_token, reqData);
                }
            }
            return new SendResult();
        }

        /// <summary>
        /// 发送小程序订阅消息
        /// </summary>
        /// <param name="appId">小程序appid</param>
        /// <param name="templateId">模板id</param>
        /// <param name="to">openid ，号分割</param>
        /// <param name="tData">数据</param>     
        /// <returns></returns>       
        public static async Task<SendResult> SendSubscribeMessageAsync(string appId, string to, TemplateBaseModel tData)
        {
            var wxAppSecret = WxOpenApi.GetWxAppSecret(appId);

            var access_token = await WxOpenApi.GetAccessToken(appId, wxAppSecret);  

            var userList = to.Split(',');
            foreach (var touser in userList)
            {
                tData.touser = touser;
                var reqData = tData.ToData();
                miniapp_subscribe_send(access_token, reqData);               
            }
            return new SendResult();
        }


        /// <summary>
        /// 根据短模板编号得到对应的模板id
        /// </summary>
        /// <param name="appId"></param>
        /// <param name="short_tpl_id"></param>
        /// <returns></returns>
        public static async Task<string> GetTemplateIdAsync(string appId, string short_tpl_id)
        {           
            if (!short_tpl_id.StartsWith("OPENTM") && !short_tpl_id.StartsWith("TM")&& !short_tpl_id.StartsWith("ETOR"))
            {
                return short_tpl_id;
            }
            var key = string.Format(ConstantConfig.Redis_TempleteId_Key, appId, short_tpl_id);
            var templete_id = await RedisHelper.GetAsync(key);
            if (!string.IsNullOrWhiteSpace(templete_id))
            {
                return templete_id;
            }

            var access_token = await WxOpenApi.GetAuthorizerAccessToken(appId);
            var ret = await get_tpl(access_token, short_tpl_id);
            if (ret.errcode == 0)
            {
                await RedisHelper.SetAsync(key, ret.template_id);
                return ret.template_id;
            }
            return "";
        }

        public static async Task<SendResult> mp_send(string access_token, object reqData)
        {
            if (string.IsNullOrWhiteSpace(access_token))
            {
                return new SendResult()
                {
                    errcode = 1000,
                    errmsg = "access_token 不存在"
                };
            }
            string urlFormat = $"cgi-bin/message/template/send?access_token={access_token}";
            LogHelper.Debug("mp_send_req", reqData.ToJson());
            var respJson = await GetHttpClient().PostAsJsonGetString(urlFormat, reqData);
            var response = respJson.FromJsonToOrDefault<SendResult>();
            if (response.errcode > 0)
            {
                LogHelper.Error("mp_send_respJson", respJson);
                return response;
            }
            return response;
        }
        public static async Task<SendResult> miniapp_send(string access_token, object reqData)
        {
            if (string.IsNullOrWhiteSpace(access_token))
            {
                return new SendResult()
                {
                    errcode = 1000,
                    errmsg = "access_token 不存在"
                };
            }
            string urlFormat = $"cgi-bin/message/wxopen/template/send?access_token={access_token}";
            LogHelper.Debug("mp_send_req", reqData.ToJson());
            var respJson = await GetHttpClient().PostAsJsonGetString(urlFormat, reqData);
            var response = respJson.FromJsonToOrDefault<SendResult>();
            if (response.errcode > 0)
            {
                LogHelper.Error("miniapp_send_respJson", respJson);
                return response;
            }
            return response;
        }

        //小程序订阅消息
        public static async Task<SendResult> miniapp_subscribe_send(string access_token, object reqData)
        {
            if (string.IsNullOrWhiteSpace(access_token))
            {
                return new SendResult()
                {
                    errcode = 1000,
                    errmsg = "access_token 不存在"
                };
            }
            string urlFormat = $"cgi-bin/message/subscribe/send?access_token={access_token}";
            LogHelper.Debug("miniapp_subscribe_send", reqData.ToJson());
            var respJson = await GetHttpClient().PostAsJsonGetString(urlFormat, reqData);
            var response = respJson.FromJsonToOrDefault<SendResult>();
            if (response.errcode > 0)
            {
                LogHelper.Error("miniapp_subscribe_send", respJson);
                return response;
            }
            return response;
        }


        public static async Task<SendResult> uniform_send(string access_token, object reqData)
        {
            if (string.IsNullOrWhiteSpace(access_token))
            {
                return new SendResult()
                {
                    errcode = 1000,
                    errmsg = "access_token 不存在"
                };
            }

            string urlFormat = $"cgi-bin/message/wxopen/template/uniform_send?access_token={access_token}";
            LogHelper.Debug("SendTemplateMessageAsync_Req", reqData.ToJson());
            var respJson = await GetHttpClient().PostAsJsonGetString(urlFormat, reqData);
            var response = respJson.FromJsonToOrDefault<SendResult>();
            if (response.errcode > 0)
            {
                LogHelper.Debug("SendTemplateMessageAsync_respJson", respJson);
                return response;
            }
            return new SendResult();
        }

        public static async Task<GetTemplateResponse> get_tpl(string access_token, string short_tpl_id)
        {
            if (string.IsNullOrWhiteSpace(access_token))
            {
                return new GetTemplateResponse()
                {
                    errcode = 1000,
                    errmsg = "access_token 不存在"
                };
            }
            var reqData = new
            {
                template_id_short = short_tpl_id
            };
            string urlFormat = $"cgi-bin/template/api_add_template?access_token={access_token}";
            LogHelper.Debug("get_tpl", reqData.ToJson());
            var respJson = await GetHttpClient().PostAsJsonGetString(urlFormat, reqData);
            var response = respJson.FromJsonToOrDefault<GetTemplateResponse>();
            if (response.errcode > 0)
            {
                LogHelper.Error("get_tpl_respJson", respJson);
                return response;
            }
            return response;
        }       

        private static async Task<GetTempleteListResponse> get_tpl_list(string access_token)
        {
            if (string.IsNullOrWhiteSpace(access_token))
            {
                return new GetTempleteListResponse()
                {
                    errcode = 1000,
                    errmsg = "access_token 不存在"
                };
            }           
            string urlFormat = $"cgi-bin/template/get_all_private_template?access_token={access_token}";         
            var respJson = await GetHttpClient().GetStringAsync(urlFormat);
            var response = respJson.FromJsonToOrDefault<GetTempleteListResponse>();
            if (response.errcode > 0)
            {
                LogHelper.Error("get_tpl_respJson", respJson);
                return response;
            }
            return response;
        }
    }
}