using DG.Redis;
using Hg.Core.Domain.Dto.OrderRefund;
using Hg.Core.Entity;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Web;
using Zxd.Core.Shared.Dto;

namespace Hg.Core.Domain
{
    internal class CacheDomain : ICacheDomain
    {
        private readonly IMapper _mapper;
        private readonly IRedisManager _redisManager;
        private readonly IBaseRepository<ZxdDbContext> _repository;
        private readonly IHttpClient _httpClient;
        private readonly SystemConfig _systemConfig;
        private readonly IConfiguration _configuration;

        public CacheDomain(IRedisManager redisManager,
            IBaseRepository<ZxdDbContext> repository,
            IMapper mapper,
            IHttpClient httpClient,
            IConfiguration configuration)
        {
            _redisManager = redisManager;
            _repository = repository;
            _mapper = mapper;
            _httpClient = httpClient;
            _configuration = configuration;
            _systemConfig = configuration.GetSection("SystemConfig").Get<SystemConfig>();
        }

        public async Task<List<Bas_CompanyVirtual>> GetCompanyVirtualList()
        {
            if (!await _redisManager.ExistsAsync(CacheKeys.CompanyVirtual))
            {
                var list = await _repository.GetRepository<Bas_CompanyVirtual>().QueryListAsync();
                await _redisManager.SetAsync(CacheKeys.CompanyVirtual, list, TimeSpan.FromHours(2));
                return list;
            }
            else
            {
                var data = await _redisManager.GetListAsync<Bas_CompanyVirtual>(CacheKeys.CompanyVirtual);
                return data;
            }
        }

        private async Task<List<BasParameter>> GetParameterList()
        {
            if (!await _redisManager.ExistsAsync(CacheKeys.ParameterList))
            {
                var list = await _repository.GetRepository<BasParameter>().QueryListAsync();
                await _redisManager.SetAsync(CacheKeys.ParameterList, list, TimeSpan.FromHours(2));
                return list;
            }
            else
            {
                var data = await _redisManager.GetListAsync<BasParameter>(CacheKeys.ParameterList);
                return data;
            }
        }

        public async Task<string> GetValueParameter(string key)
        {
            var list = await GetParameterList();
            return list.FirstOrDefault(x => x.PARAKEY == key)?.PARAVALUE ?? "";
        }

        public async Task<List<DeptmentDto>> GetDeptments()
        {
            var key = $"{CacheKeys.ZxdParameterList}";
            if (!await _redisManager.ExistsAsync(key))
            {
                var response = await _httpClient.GetAsync<ApiResult<List<DeptmentDto>>>($"{_systemConfig.ZxdCoreUrl}/Api/Deptment/Depts");
                if (response.Code == 0)
                {
                    await _redisManager.SetAsync(key, response.Data, TimeSpan.FromHours(2));
                    return response.Data;
                }
            }
            else
            {
                return await _redisManager.GetListAsync<DeptmentDto>(key);
            }
            return new List<DeptmentDto>();
        }

        public async Task<List<HolidayCalendarDto>> RefreshHolidayCalendar(string year)
        {
            var calendar = await _repository.GetRepository<HolidayCalendar>().Query().ToListAsync();
            var holidayCalendar = new List<HolidayCalendar>();
            var url = $"https://timor.tech/api/holiday/year/{year}";
            var result = await _httpClient.GetAsync<HolidayResult>(url);
            if (result.Code == 0)
            {
                foreach(var item in result.Holiday)
                {
                    if (!calendar.Any(x => x.Date == item.Value.Date))
                    {
                        holidayCalendar.Add(new HolidayCalendar
                        {
                            Date = item.Value.Date,
                            Holiday = item.Value.Holiday,
                            Title = item.Value.Name
                        });
                    }
                }
            }
            if (holidayCalendar.Any())
            {
                await _repository.GetRepository<HolidayCalendar>().BatchInsertAsync(holidayCalendar);
                return _mapper.Map<HolidayCalendar, HolidayCalendarDto>(holidayCalendar);
            }
            return new List<HolidayCalendarDto>();
        }

        public async Task<List<HolidayCalendarDto>> GetHolidayCalendar()
        {
            var key = $"{CacheKeys.HolidayCalendar}";
            if (!await _redisManager.ExistsAsync(key))
            {
                var calendar = await _repository.GetRepository<HolidayCalendar>().Query().ToListAsync();
                var holidayCalendar = _mapper.Map<HolidayCalendar, HolidayCalendarDto>(calendar);
                await _redisManager.SetAsync(key, holidayCalendar, TimeSpan.FromDays(1));
                return holidayCalendar;
            }
            return await _redisManager.GetListAsync<HolidayCalendarDto>(key);
        }
        
        public async Task<DateTime> AddWorkDays(DateTime date, int workDays)
        {
            var calendar = await GetHolidayCalendar();

            for (var i = 1; i <= workDays; i++)
            {
                var day = date.AddDays(i);
                var dayOfWeek = day.DayOfWeek;
                var holidayCalendar = calendar.FirstOrDefault(x => x.Date == day.ToString("yyyy-MM-dd"));
                //判断是否为周末
                if (dayOfWeek == DayOfWeek.Sunday || dayOfWeek == DayOfWeek.Saturday || (holidayCalendar != null && holidayCalendar.Holiday))
                {
                    workDays++;
                }
            }
            return date.AddDays(workDays);
        }

        public async Task<int> GetWorkDays(DateTime now, DateTime date)
        {
            var calendar = await GetHolidayCalendar();
            var hours = (date - now).Hours;
            //var days = int.Parse((date - now).TotalDays.ToString("0"));
            var days = date.Subtract(now).Days;
            days = hours > 0 && days == 0 ? days+1 : days;
            if (days < 1)
            {
                return 0;
            }
            var workDays = 0;
            for (var i = 1; i <= days; i++)
            {
                var day = now.AddDays(i);
                var dayOfWeek = day.DayOfWeek;
                var holidayCalendar = calendar.FirstOrDefault(x => x.Date == day.ToString("yyyy-MM-dd"));
                //判断是否为周末
                if (dayOfWeek != DayOfWeek.Sunday && dayOfWeek != DayOfWeek.Saturday && (holidayCalendar == null || !holidayCalendar.Holiday))
                {
                    workDays++;
                }
            }
            return workDays;
        }

        public async Task<DateTime> AddWorkHours(DateTime date, int workHours)
        {
            var calendar = await GetHolidayCalendar();

            for (var i = 0; i < workHours; i++)
            {
                var day = date.AddHours(i);
                var dayOfWeek = day.DayOfWeek;
                var holidayCalendar = calendar.FirstOrDefault(x => x.Date == day.ToString("yyyy-MM-dd"));
                //判断是否为周末
                if (dayOfWeek == DayOfWeek.Sunday || dayOfWeek == DayOfWeek.Saturday || (holidayCalendar != null && holidayCalendar.Holiday))
                {
                    workHours++;
                }
            }
            return date.AddHours(workHours);
        }

        public async Task<int> GetWorkHours(DateTime now, DateTime date)
        {
            var calendar = await GetHolidayCalendar();
            var hours = int.Parse((date - now).TotalHours.ToString("0"));
            if (hours < 1)
            {
                return 0;
            }
            var workHours = 0;
            for (var i = 0; i < hours; i++)
            {
                var day = now.AddHours(i);
                var dayOfWeek = day.DayOfWeek;
                var holidayCalendar = calendar.FirstOrDefault(x => x.Date == day.ToString("yyyy-MM-dd"));
                //判断是否为周末
                if (dayOfWeek != DayOfWeek.Sunday && dayOfWeek != DayOfWeek.Saturday && (holidayCalendar == null || !holidayCalendar.Holiday))
                {
                    workHours++;
                }
            }
            return workHours;
        }

        /// <summary>
        /// 发送信息
        /// </summary>
        /// <param name="data"></param>
        /// <returns></returns>
        public async Task<bool> SendCrmMessage(dynamic data)
        {
            var url = _systemConfig.GetCrmCoreSendMessage();
            //Log.Information(url);
            string ss = Newtonsoft.Json.JsonConvert.SerializeObject(data);
            //Log.Information(ss);
            var result = await _httpClient.PostAsync2<ApiResult>(url, ss);
            if (result.Code == 0)
            {
                return true;
            }
            else
            {
                return false;
            }
        }

        /// <summary>
        /// 创建客户投诉标签/销售线索
        /// </summary>
        /// <param name="resId">客户ID</param>
        /// <param name="cname">客户姓名</param>
        /// <param name="companyCode">事业部Code</param>
        /// <param name="label">内/外诉标签</param>
        /// <returns></returns>
        public async Task<bool> ComplaintLabel(string resId,string cname,string companyCode,string label)
        {
            try
            {
                ////创建客户标签
                //var request = new
                //{
                //    appid = "com.dongniu",
                //    username = cname,
                //    weight = 50,
                //    labelname = label,
                //    mobile = resId,

                //};
                ////同步数据给坐席                                                                                                                  
                //var host = _systemConfig.DataSyncApiUrl;
                //var syncurl = host + "/api/DataSync";
                //var para = new SYNC_PUSH_DTO()
                //{
                //    bidatatype = "Client_Rfm",
                //    deptcode = companyCode,
                //    jsontext = request.ToJson()
                //};
                //var ret = await _httpClient.PostAsync<retMsg>(syncurl, para);

                //给销售线索添加内外诉标签

                //获取客户关联的电话
                var hgInternalWebApi = await GetValueParameter("Hg_Internal_WebApi");
                var url = $"{hgInternalWebApi}/api/Customer/moblies?resid={resId}";
                var result = await _httpClient.GetAsync<CustomerMobileResult>(url);
                if (result.code == 0 && result.data != null && result.data.Any())
                {
                    //根据关联的电话获取所有销售线索用户名
                    var saleAccountUrl = await GetValueParameter("ISVR_Saleclus_Get");

                    var mobiles = new List<string>();
                    var clientKey = _systemConfig.GetAccessKey("TDORDERSITE");
                    foreach (var item in result.data)
                    {
                        var mobile = SecurityHelper.DecyptData(item.Mobile, clientKey);
                        mobiles.Add(mobile);
                    }

                    var accountParam = new { mobiles = mobiles };
                    var saleAccountResult = await _httpClient.PostAsync<SaleClusResult>(saleAccountUrl, accountParam);
                    if (saleAccountResult.iRet == 0 && saleAccountResult.list.Count > 0)
                    {
                        //根据所有线索用户名设置内外诉标签
                        var saleLabelUrl = await GetValueParameter("ISVR_Saleclus_Complaint");
                        var accessKey = _systemConfig.GetAccessKey("UPWEBSITE");
                        foreach (var item in saleAccountResult.list)
                        {
                            var labelParam = new { appid = "com.dongniu", appuserid = item.appuserid, isInnerComplaint = label == "内诉" ? 20 : 0, isOutComplaint = label == "外诉" ? 20 : 0 };
                            var content = SecurityHelper.EncyptData(labelParam.ToJson(), accessKey);
                            var sign = SecurityHelper.SignData(content, accessKey);

                            //var updateContractStatusUrl = _systemConfig.PostContractStatus(HttpUtility.UrlEncode(content), HttpUtility.UrlEncode(sign), "UPWEBSITE");
                            var saleLabelResult = await _httpClient.PostAsync<SaleClusResult>(saleLabelUrl, new { content = content, sign = sign, clientId = "UPWEBSITE" });
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                Log.Error($"创建客户{label}标签失败。客户ID：{resId}，原因：{ex.Message}");
            }

            return true;
        }

        public async Task<bool> IsWorkDay(DateTime dateTime)
        {
            var result = false;
            var calendar = await GetHolidayCalendar();
            var dayOfWeek = dateTime.DayOfWeek;
            var holidayCalendar = calendar.FirstOrDefault(x => x.Date == dateTime.ToString("yyyy-MM-dd"));
            //判断是否为工作日
            if (holidayCalendar != null)
            {
                if (!holidayCalendar.Holiday)
                    result = true;
            }
            else if(dayOfWeek != DayOfWeek.Sunday && dayOfWeek != DayOfWeek.Saturday)
            {
                result = true;
            }

            return result;
        }


        public class HolidayResult
        {
            public int Code { get; set; }

            public Dictionary<string, HolidayItem> Holiday { get; set; }
        }

        public class HolidayItem
        {
            public bool Holiday { get; set; }

            public string Name { get; set; }

            public string Date { get; set; }
        }

        public async Task<T> GetValueParameter<T>(string key)
        {
            var value = await GetValueParameter(key);
            if (string.IsNullOrEmpty(value))
            {
                return default;
            }
            else
            {
                return JsonHelper.FromJson<T>(value);
            }
        }

        public int? GetAge(string idCard)
        {
            int? result = null;
            try
            {
                if (string.IsNullOrEmpty(idCard))
                    return result;

                if (idCard.Length == 18)
                    result = DateTime.Now.Year - int.Parse(idCard.Substring(6, 4));
                else if (idCard.Length == 15)
                    result = DateTime.Now.Year - int.Parse("19" + idCard.Substring(6, 2));

            }
            catch (Exception ex)
            {
                Log.Error("身份证计算年龄出错:" + idCard);
            }
            return result;
        }
    }
}