using Dapper;
using Microsoft.Extensions.DependencyInjection;
using MySqlConnector;
using System.Data;
using Zxd.Core.Domain.Dto.Zxd.Callback;
using Zxd.Core.Domain.Dto.Zxd.Order;
using Zxd.Core.Domain.Dto.Zxd.QwWeiSide;
using Zxd.Entity.UserCenter;
using Zxd.Entity.Zxd.Order;

namespace Zxd.Core.Domain
{
    public class OrderBindDomain : IOrderDomain
    {
        private readonly IBaseRepository<ZxdDbContext> _zxdRepository;
        private readonly IBaseRepository<DncmsbaseDbContext> _cmsRepository;

        private readonly IBaseRepository<UserCenterDbContext> _userCenterRepository;

        private readonly IRedisManager _redisManager;

        private readonly ICacheDomain _cacheDomain;
        private readonly IMapper _mapper;
        private readonly IHttpClient _httpClient;

        private readonly SystemConfig _systemConfig;

        private readonly IDbConnection _dbConnection;

        private readonly PayCallbackConfig _payCallbackConfig;
        private readonly IUserInfoDomain _userInfoDomain;

        public OrderBindDomain(
            IBaseRepository<ZxdDbContext> zxdRepository,
             IBaseRepository<DncmsbaseDbContext> cmsRepository,
            IBaseRepository<UserCenterDbContext> userCenterRepository,
            IRedisManager redisManager,
            ICacheDomain cacheDomain,
            IHttpClient httpClient,
            IConfiguration configuration,
            IUserInfoDomain userInfoDomain,
            IDbConnection dbConnection, IMapper mapper)
        {
            _zxdRepository = zxdRepository;
            _cmsRepository = cmsRepository;
            _userCenterRepository = userCenterRepository;
            _redisManager = redisManager;
            _cacheDomain = cacheDomain;
            _httpClient = httpClient;
            _userInfoDomain = userInfoDomain;
            _mapper = mapper;
            _systemConfig = configuration.GetSection("SystemConfig").Get<SystemConfig>();
            _dbConnection = dbConnection;
            _payCallbackConfig = configuration.GetSection("PayCallbackConfig").Get<PayCallbackConfig>();
        }

        public async Task<PageResult<BindListDto>> GetBindListPageAsync(SearchBindListDto dto)
        {
            var channel = new List<int?>();
            if (!string.IsNullOrEmpty(dto.Channel))
            {
                var parts = dto.Channel.Split(',');
                foreach (var part in parts)
                {
                    if (int.TryParse(part, out var ch))
                    {
                        channel.Add(ch);
                    }
                }
            }
            if (channel.Count == 0)
            {
                return new PageResult<BindListDto>(dto.PageIndex, dto.PageSize, 0, new List<BindListDto>());
            }
            if (!string.IsNullOrEmpty(dto.ResId))
            {
                dto.ResId = await _zxdRepository.GetRepository<RES_CUSTOMER>().Query().Where(x => x.UMID == dto.ResId)
                    .Select(x => x.RESID).FirstOrDefaultAsync();
            }

            var query = _zxdRepository.GetRepository<WX_SZZYORDER_BIND>().Query()
                .Where(x => channel.Contains(x.Channel))
                .If(dto.BindType.HasValue, x => x.Where(x => x.BindType == dto.BindType))
                .If(dto.EId.HasValue, x => x.Where(x => x.EId == dto.EId))
                .If(!string.IsNullOrEmpty(dto.txt_userId), x => x.Where(x => x.EId.GetValueOrDefault().ToString() == dto.txt_userId))
                .If(!string.IsNullOrEmpty(dto.PayType), x => x.Where(x => x.PayType == dto.PayType))
                .If(!string.IsNullOrEmpty(dto.ResId), x => x.Where(x => x.ResId == dto.ResId))
                .If(!string.IsNullOrEmpty(dto.UnionId), x => x.Where(x => x.UnionId == dto.UnionId))
                .If(!string.IsNullOrEmpty(dto.PayNo), x => x.Where(x => x.TradeNo == dto.PayNo));

            var total = await query.CountAsync();
            var data = await query
                .OrderByDescending(x => x.CreateTime)
                .Select(x => new BindListDto
                {
                    Id = x.Id,
                    BindType = x.BindType,
                    PayType = x.PayType,
                    UnionId = x.UnionId,
                    PayNo = x.TradeNo,
                    Amount = x.TotalAmount,
                    ResId = x.ResId,
                    Remark = x.Remark,
                    EId = x.EId,
                    PayTime = x.CreateTime
                })
                .Skip((dto.PageIndex - 1) * dto.PageSize)
                .Take(dto.PageSize)
                .ToListAsync();

            var resids = data.Select(x => x.ResId).ToList();

            var customers = await _zxdRepository.GetRepository<RES_CUSTOMER>().Query().Where(x => resids.Contains(x.RESID)).ToListAsync();

            foreach (var item in data)
            {
                item.ResId = customers.FirstOrDefault(x => x.RESID == item.ResId)?.UMID ?? "";
            }
            return new PageResult<BindListDto>(dto.PageIndex, dto.PageSize, total, data);
        }

        public async Task<BindListDto> GetBindDetailAsync(int? id)
        {
            var query = _zxdRepository.GetRepository<WX_SZZYORDER_BIND>().Query()
                .Where(w => w.Id == id);
            var data = await query
                .Select(x => new BindListDto
                {
                    BindType = x.BindType,
                    PayType = x.PayType,
                    UnionId = x.UnionId,
                    PayNo = x.TradeNo,
                    Amount = x.TotalAmount,
                    ResId = x.ResId,
                    Remark = x.Remark,
                    EId = x.EId,
                    PayTime = x.CreateTime
                }).ToListAsync();
            return data.FirstOrDefault();
        }

        public async Task<string> EditBindAsync(SearchBindListDto dto)
        {
            var one = await _zxdRepository.GetRepository<WX_SZZYORDER_BIND>().Query()
                .Where(w => w.Id == dto.Id)
                .FirstOrDefaultAsync();
            if (one == null)
            {
                throw new ApiException("无效的id:" + dto.Id, 1);
            }

            //if (!string.IsNullOrEmpty(one.ResId))
            //{
            //    throw new ApiException("已绑定过，不能再次绑定", 1);
            //}
            var orderCount = await _zxdRepository.GetRepository<WX_SZZYORDERDEPOSIT>().Query()
                .Where(w => w.tradeno == one.TradeNo && w.auditstatus == 1 && w.isdelete == 0)
                .CountAsync();
            if (orderCount > 0)
            {
                throw new ApiException("已绑定过，不能再次绑定", 1);
            }

            one.ResId = dto.ResId;
            one.Remark = dto.Remark;
            one.BindType = 2;
            await _zxdRepository.GetRepository<WX_SZZYORDER_BIND>().UpdateAsync(one);
            await SyncOrderAsync(one, dto.ResId);
            return "修改成功";
        }

        public async Task<string> BindAsync(BindOrderDto dto)
        {
            var channel = default(int?);
            if (int.TryParse(dto.channel, out var channelTemp))
            {
                channel = channelTemp;
            }

            var payTime = default(DateTime?);
            if (!string.IsNullOrEmpty(dto.payTime) && DateTime.TryParse(dto.payTime, out var payTimeTemp))
            {
                payTime = payTimeTemp;
            }

            var one = await _zxdRepository.GetRepository<WX_SZZYORDER_BIND>().Query()
                .Where(w => w.TradeNo == dto.tradeNo)
                .FirstOrDefaultAsync();
            if (one != null)
            {
                //重复推送的只修改订单状态
                one.TradeStatus = dto.tradeStatus;
                await _zxdRepository.GetRepository<WX_SZZYORDER_BIND>().UpdateAsync(one);
            }
            else
            {
                //只处理交易成功的
                if (dto.tradeStatus == 1 && payTime.HasValue)
                {
                    var bindType = 0;
                    var resId = default(string);
                    var users = await GetUserSelectAsync(dto.unionId);
                    if (users.Count == 1)
                    {
                        bindType = 1;
                        resId = users.FirstOrDefault();
                    }

                    one = new WX_SZZYORDER_BIND();
                    one.PayType = dto.payType;
                    one.TradeNo = dto.tradeNo;
                    one.OutTradeNo = dto.outTradeNo;
                    one.UserTradeNo = dto.userTradeNo;
                    one.TotalAmount = 0.01m * dto.totalAmount.GetValueOrDefault();
                    one.TradeStatus = dto.tradeStatus;
                    one.UnionId = dto.unionId;
                    one.EId = dto.eId;
                    one.BindType = bindType;
                    one.ResId = resId ?? "";
                    one.CreateTime = payTime;
                    one.Channel = channel;
                    one.Remark = "";
                    one.IdentityKey = dto.identityKey;
                    await _zxdRepository.GetRepository<WX_SZZYORDER_BIND>().InsertAsync(one);

                    if (!string.IsNullOrEmpty(resId))
                    {
                        await SyncOrderAsync(one, resId);
                    }
                }
            }
            return "绑定成功";
        }

        private async Task SyncOrderAsync(WX_SZZYORDER_BIND dto, string resId)
        {
            var url = await _cacheDomain.GetValueParameter("Core_ZxdService_OrderDeposit");
            if (string.IsNullOrEmpty(url))
            {
                url = _payCallbackConfig.PushUrl;
            }
            var clientid = "UPWEBSITE";

            var paytypename = "";
            var paytype = 0;
            switch (dto.PayType)
            {
                case "alipay":
                    {
                        paytypename = "支付宝";
                        paytype = 1;
                        break;
                    }
                case "wechat":
                    {
                        paytypename = "微信支付";
                        paytype = 5;
                        break;
                    }
            }
            var param = new OrderDepositDto
            {
                source = "zxd",
                channel = dto.Channel,
                companycode = null,
                creator = null,
                creatorname = null,
                deptcode = null,
                id = 0,
                isuse = 0,
                orderid = null,
                paydate = dto.CreateTime,
                payname = "在线支付",
                payno = dto.TradeNo,
                payprice = dto.TotalAmount.GetValueOrDefault(),
                paytype = paytype,
                paytypename = paytypename,
                remark = $"{dto.PayType},付款流水号:{dto.TradeNo}",
                resid = resId,
                tradeno = dto.TradeNo,
                identityKey = dto.IdentityKey
            };
            var response = await _httpClient.PostSecurityAsync<retMsg>(url, param, new { }, clientid, _systemConfig.GetAccessKey(clientid));
            if (!response.result)
            {
                throw new ApiException(JsonSerializer.Serialize(response), 3);
            }
        }

        public async Task<List<string?>> GetUserSelectAsync(string unionId)
        {
            var data = new List<string?>();
            if (string.IsNullOrEmpty(unionId))
            {
                return data;
            }

            var sql = "select Customerid from userinfo where unionId=@unionId limit 1";
            var customerid = await _dbConnection.ExecuteScalarAsync<int?>(sql, new { unionId });
            if (customerid.HasValue)
            {
                sql = "select Distinct(Resid) from userinfo where Customerid=@customerid";
                var resIds = await _dbConnection.QueryAsync<string>(sql, new { customerid });
                if (resIds != null && resIds.Any())
                {
                    data.AddRange(resIds.Where(w => !string.IsNullOrEmpty(w)));
                }
            }

            return data;
        }

        public async Task<string> GetUserItemAsync(string? resId)
        {
            if (string.IsNullOrEmpty(resId))
            {
                throw new ApiException("resId必填", 1);
            }

            var sql = "select count(1) from userinfo where Resid=@resId";
            var count = await _dbConnection.ExecuteScalarAsync<long?>(sql, new { resId });
            if (count.GetValueOrDefault() == 0)
            {
                throw new ApiException("无效的resId:" + resId, 1);
            }
            return "获取成功";
        }

        public async Task<bool> OrderChange(OrderChangeDto dto)
        {
            try
            {
                Log.Information($"接收【OrderChange】到数据{dto.ToJson()}");
                var orderLog = _mapper.Map<OrderChangeDto, Wx_Szzyorder_log>(dto);
                await _cmsRepository.GetRepository<Wx_Szzyorder_log>().InsertAsync(orderLog);
                var obj = new ResPassTimeDto
                {
                    ResId = dto.RESID
                };
                return await initResPassTime(obj);
            }
            catch (Exception ex)
            {
                Log.Error($"插入【OrderChange】日志失败{ex.Message}");
                return false;
            }
        }

        public async Task<bool> initResPassTime(ResPassTimeDto dto)
        {
            var consumers = KafkaClient.GetConsumers();
            Log.Information($"consumers: {consumers.ToJson()}");
            var obj = new ResPassTimeDto
            {
                ResId = dto.ResId
            };
            await KafkaClient.SendMessage(consumers.FirstOrDefault(n => n.Topic == "ResPassTime"), obj);
            return true;
        }

        public async Task<List<SideOrderModel>> GetOrderListByEid(SearchSideOrderDto dto)
        {
            var userInfoList = await _userInfoDomain.GetUserInfos(null, dto.AppId, dto.AppUserId, "", "");
            var resids = userInfoList.Where(n => !string.IsNullOrWhiteSpace(n.Resid)).Select(n => n.Resid).Distinct().ToList();
            var dataList = await _zxdRepository.GetRepository<WX_SZZYORDER>().Query().Where(n => resids.Contains(n.RESID) && n.eid == dto.Eid).OrderByDescending(n => n.CTIME).ToListAsync();
            List<SideOrderModel> res = new List<SideOrderModel>();
            foreach (var item in dataList)
            {
                SideOrderModel side = new SideOrderModel
                {
                    OrderId = item.ORDERID,
                    SzzyOrderId = item.SZZYORDERID.ToString(),
                    ProductName = item.SUBPRODUCTNAME,
                    ProductCode = item.PRODUCTCODE,
                    Opendays = item.OPENDAYS,
                    Giftdays = item.giftdays.HasValue ? item.giftdays.Value : item.giftdays2.HasValue ? (item.giftdays.Value + item.giftdays2.Value) : 0,
                    Ctime = item.CTIME,
                    Otime = item.OTIME,
                    OrderStatus = item.ORDERSTATUS,
                    OrderStatusName = item.ORDERSTATUSNAME,
                };
                res.Add(side);
            }
            return res;
        }

        /// <summary>
        /// 导入赠送订单预览
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        public async Task<List<ImportGiftOrderViewModel>> ImportHandGiftPreview(List<ImportGiftOrderDto> dto)
        {
            List<ImportGiftOrderViewModel> res = new List<ImportGiftOrderViewModel>();
            var orderids = dto.Select(n => Convert.ToDecimal(n.OrderId)).ToList();
            var dataList = await _zxdRepository.GetRepository<WX_SZZYORDER>().Query().Where(n => orderids.Contains(n.ORDERID)).ToListAsync();
            var productCode = dto.Select(n => n.ProductCode).Distinct().ToList();
            var proList = await _zxdRepository.GetRepository<WxSzzySubproduct>().Query().Where(n => productCode.Contains(n.productcode)).ToListAsync();
            foreach (var item in dto)
            {
                ImportGiftOrderViewModel model = new ImportGiftOrderViewModel
                {
                    OrderId = item.OrderId,
                    Day = Convert.ToInt32(item.Day),
                    ProductCode = item.ProductCode
                };
                var orderid = Convert.ToDecimal(item.OrderId);
                var order = dataList.FirstOrDefault(n => n.ORDERID == orderid);
                if (order == null)
                {
                    model.Msg += "找不到订单;";
                }
                else
                {
                    model.Channel = order.CHANNEL;
                    model.Umid = order.UMID;
                    model.Name = order.CNAME;
                    model.UserName = order.SOFTUSERNAME;
                }
                if (model.Day <= 0)
                {
                    model.Msg += "赠送天数不能小于0;";
                }
                var product = proList.FirstOrDefault(n => n.productcode == model.ProductCode);
                if (product == null)
                {
                    model.Msg += "找不到对应的产品;";
                }
                else
                {
                    model.ProductName = product.subproductname;
                }
                if (!model.ProductCode.Contains("_MFTY"))
                {
                    model.Msg += "只能赠送免费产品;";
                }
                res.Add(model);
            }

            return res;
        }
    }
}