using Microsoft.AspNetCore.Mvc;
using Newtonsoft.Json;
using System.Diagnostics;
using wms.dto.request;
using wms.dto.response;
using wms.service.IService;
using wms.util.Ext;
using wms.util.Http;

namespace wms.api.Controllers
{
    [Route("api/[controller]/[action]")]
    [ApiController]
    public class BaseController : ControllerBase
    {
        private readonly IHJService _hJService;
        private readonly IPTService _ptService;
        private readonly IFJService _fjService;
        private readonly ISXService _sxService;
        private readonly ICPService _cpService;
        private readonly ILogger<BaseController> _logger;

        public BaseController(IHJService hJService, ILogger<BaseController> logger)
        {
            _hJService = hJService;
            _logger = logger;
        }

        public BaseController(IPTService ptService)
        {
            _ptService = ptService;
        }

        public BaseController(IFJService fjService)
        {
            _fjService = fjService;
        }

        public BaseController(ISXService sxService)
        {
            _sxService = sxService;
        }

        public BaseController(ICPService cpService)
        {
            _cpService = cpService;
        }

        /// <summary>
        /// 发送ESB请求统一出口
        /// </summary>
        /// <param name="reqDto"></param>
        /// <returns></returns>
        internal string WmsServiceExportApi(object strReqBody)
        {
            var res = new SRes();
            //var aa = (new StackTrace()).GetFrame(0).GetMethod().Name;//当前方法名
            var methodName = (new StackTrace()).GetFrame(1).GetMethod().Name;//调用的方法名称
            string methodcode = "";
            if (_ptService != null)
            {
                methodcode = _ptService.GetSysConfigContentByCode(methodName);
            }
            else if (_hJService != null)
            {
                methodcode = _hJService.GetSysConfigContentByCode(methodName);
            }
            else if (_fjService != null)
            {
                methodcode = _fjService.GetSysConfigContentByCode(methodName);
            }

            if (string.IsNullOrEmpty(methodcode))
            {
                return new SRes() { ResCode = 0, ResMsg = "数据表没有配置" }.ToCamelCaseString();
            }
            methodcode = RedisHelper.Get("sys_config" + methodName);
            var reqid = Guid.NewGuid().ToString();
            var req = new EsbReq() { headers = new HeadersReq() { serviceCode = methodcode.Split("|")[0], requestId = reqid, TrackId = reqid } };
            //req.Body = strReqBody;
            string sysname = methodcode.Split("|")[1];
            var apiurl = "";
            if (sysname == "mes")
            {
                apiurl = wms.util.AppSettings.GetConfig("EsbMesPushUrl");
            }
            else
            {
                apiurl = wms.util.AppSettings.GetConfig("EsbErpPushUrl");
            }

            if (methodcode.Split("|")[0].ToString().StartsWith("163D"))
            {
                req.headers.sourceCode = "163D";
            }
            else if (methodcode.Split("|")[0].ToString().StartsWith("163I"))
            {
                req.headers.sourceCode = "163I";
            }
            else if (methodcode.Split("|")[0].ToString().StartsWith("163L"))
            {
                req.headers.sourceCode = "163L";
            }
            else if (methodcode.Split("|")[0].ToString().StartsWith("163K"))
            {
                req.headers.sourceCode = "163K";
            }
            else if (methodcode.Split("|")[0].ToString().StartsWith("163J"))
            {
                req.headers.sourceCode = "163J";
            }

            var strEsbRes = HttpUtil.PostRequest(apiurl, JsonConvert.SerializeObject(strReqBody), 30000, "UTF-8", "application/json", reqid, req.headers.sourceCode, req.headers.serviceCode);
            if (!string.IsNullOrEmpty(strEsbRes))
            {
                //res = JsonConvert.DeserializeObject<SRes>(strEsbRes);
                return strEsbRes;
            }
            else
            {
                res = new SRes() { ResMsg = "MES没有返回任务数据", ResCode = 500, Memo1 = apiurl, Memo2 = req.ToJsonString(), Memo3 = strEsbRes };
            }
            return res.ToCamelCaseString();
        }

        internal string WmsServiceExportMq(object strReqBody)
        {
            var res = new SRes();
            //var aa = (new StackTrace()).GetFrame(0).GetMethod().Name;//当前方法名
            var methodName = (new StackTrace()).GetFrame(1).GetMethod().Name;//调用的方法名称
            string methodcode = "";
            if (_ptService != null)
            {
                methodcode = _ptService.GetSysConfigContentByCode(methodName);
            }
            else if (_hJService != null)
            {
                methodcode = _hJService.GetSysConfigContentByCode(methodName);
            }
            else if (_cpService != null)
            {
                methodcode = _cpService.GetSysConfigContentByCode(methodName);
            }
            else if (_fjService != null)
            {
                methodcode = _fjService.GetSysConfigContentByCode(methodName);
            }

            if (string.IsNullOrEmpty(methodcode))
            {
                return new SRes() { ResCode = 0, ResMsg = "数据表没有配置" }.ToCamelCaseString();
            }
            methodcode = RedisHelper.Get("sys_config" + methodName);
            var reqid = Guid.NewGuid().ToString();
            var req = new EsbReq() { headers = new HeadersReq() { serviceCode = methodcode.Split("|")[0], requestId = reqid, TrackId = reqid } };
            //req.Body = strReqBody;
            var apiurl = wms.util.AppSettings.GetConfig("EsbMesPushUrlMq");

            if (methodcode.Split("|")[0].StartsWith("163D"))
            {
                req.headers.sourceCode = "163D";
            }
            else if (methodcode.Split("|")[0].StartsWith("163I"))
            {
                req.headers.sourceCode = "163I";
            }
            else if (methodcode.Split("|")[0].StartsWith("163J"))
            {
                req.headers.sourceCode = "163J";
            }
            else if (methodcode.Split("|")[0].StartsWith("163L"))
            {
                req.headers.sourceCode = "163L";
            }
            else if (methodcode.Split("|")[0].StartsWith("163K"))
            {
                req.headers.sourceCode = "163K";
            }
            var strEsbRes = "";
            try
            {
                //_logger.LogInformation("111111111111");
                strEsbRes = HttpUtil.PostRequest(apiurl, JsonConvert.SerializeObject(strReqBody), 30000, "UTF-8", "application/json", reqid, req.headers.sourceCode, req.headers.serviceCode);
                //_logger.LogInformation(methodName + "POST响应参数" + strEsbRes);
            }
            catch (Exception ex)
            {
                _logger.LogInformation(methodName + "调用异常：" + ex.ToString());
            }

            if (!string.IsNullOrEmpty(strEsbRes))
            {
                //res = JsonConvert.DeserializeObject<SRes>(strEsbRes);
                return strEsbRes;
            }
            else
            {
                res = new SRes() { ResMsg = "MES没有返回任务数据", ResCode = 500, Memo1 = apiurl, Memo2 = req.ToJsonString(), Memo3 = strEsbRes };
            }
            return res.ToCamelCaseString();
        }

        /// <summary>
        /// 并发管控
        /// </summary>
        /// <typeparam name="T">方法请求参数类型</typeparam>
        /// <typeparam name="U">方法响应参数类型</typeparam>
        /// <param name="lockobj">方法锁</param>
        /// <param name="key">并发管控关键key</param>
        /// <param name="equNo">管控设备号</param>
        /// <param name="reqparam">请求参数</param>
        /// <param name="fun">管控方法</param>
        /// <returns></returns>
        public U ConcurrencyReqControl<T, U>(object lockobj, string key, string equNo, BaseRequest reqparam, Func<T, U> fun) where T : BaseRequest where U : SRes, new()
        {
            var res = new U();
            try
            {
                lock (lockobj)
                {
                    //并发管控
                    var sign = RedisHelper.Get(key);
                    if (!string.IsNullOrEmpty(sign) && sign == "1")
                    {
                        //不可通行
                        res.ResCode = 0;
                        res.ResMsg = equNo + "并发重复请求";
                        return res;
                    }
                    //加状态
                    RedisHelper.Set(key, "1");
                }
                var resulttemp = fun((T)reqparam);
                RedisHelper.Set(key, "0");
                return resulttemp;
            }
            catch (Exception ex)
            {
                RedisHelper.Set(key, "0");
                res.ResCode = 500;
                res.ResMsg = ex.Message;
                return res;
            }
            finally
            {
                RedisHelper.Del(key);
            }
        }

        /// <summary>
        /// 并发管控
        /// </summary>
        /// <typeparam name="U">方法响应参数类型</typeparam>
        /// <param name="key">并发管控关键key</param>
        /// <param name="equNo">管控设备号</param>
        /// <param name="reqparam">请求参数</param>
        /// <param name="fun">管控方法</param>
        /// <returns></returns>
        public U ConcurrencyReqControl<U>(string key, string equNo, Func<U> fun) where U : SRes, new()
        {
            var res = new U();
            try
            {
                //并发管控
                var sign = RedisHelper.Get(key);
                if (!string.IsNullOrEmpty(sign) && sign == "1")
                {
                    //不可通行
                    res.ResCode = 0;
                    res.ResMsg = equNo + "并发重复请求";
                    return res;
                }
                //加状态
                RedisHelper.Set(key, "1");
                var resulttemp = fun();
                RedisHelper.Set(key, "0");
                return resulttemp;
            }
            catch (Exception ex)
            {
                RedisHelper.Set(key, "0");
                res.ResCode = 500;
                res.ResMsg = ex.Message;
                return res;
            }
            finally
            {
                RedisHelper.Del(key);
            }
        }
    }
}