using New_College.IServices;
using New_College.Model.Models;
using New_College.Services.BASE;
using New_College.IRepository.Base;
using New_College.IRepository.UnitOfWork;
using New_College.Model.ViewModels;
using System.Threading.Tasks;
using New_College.Common;
using New_College.IRepository;
using System.Linq;
using YIJIYI.Core.Common.Helper;
using System;
using New_College.Model;
using New_College.Common.Helper;
using Microsoft.Extensions.Logging;
using System.Collections.Generic;
using LinqKit;
using System.IO;
using Microsoft.AspNetCore.Mvc;
using SqlSugar;
using System.Linq.Expressions;
using StackExchange.Redis;
using Ubiety.Dns.Core;

namespace New_College.Services
{
    public class V_OrderInfoServices : BaseServices<V_OrderInfo>, IV_OrderInfoServices
    {
        private readonly IBaseRepository<V_OrderInfo> _dal;
        private readonly IUnitOfWork _unitOfWork;
        private readonly IV_CustomerInfoRepository v_CustomerInfoRepository;
        private readonly IV_VipCardInfoRepository v_VipCardInfoRepository;
        private readonly IV_VipCardTypeRepository v_VipCardTypeRepository;

        private readonly ILogger<V_OrderInfo> logger;

        public int Nums = 10;
        public V_OrderInfoServices(IBaseRepository<V_OrderInfo> dal
            , IUnitOfWork IUnitOfWork
            , IV_CustomerInfoRepository IV_CustomerInfoRepository
            , IV_VipCardInfoRepository IV_VipCardInfoRepository
            , IV_VipCardTypeRepository IV_VipCardTypeRepository
            , ILogger<V_OrderInfo> loggers
            )
        {
            this._dal = dal;
            _unitOfWork = IUnitOfWork;
            v_CustomerInfoRepository = IV_CustomerInfoRepository;
            v_VipCardInfoRepository = IV_VipCardInfoRepository;
            v_VipCardTypeRepository = IV_VipCardTypeRepository;
            logger = loggers;
            base.BaseDal = dal;
        }


        /// <summary>
        /// 扫码支付-Native下单API
        /// </summary>
        /// <param name="viewModel"></param>
        public async Task<MemoryStream> QrCodePay(WeChatPayTransactionsNativeQuery viewModel)
        {
            var orderNo = OrderGenerateHelper.GenerateOrderNo("OT");//outorderNo//系统创建订单逻辑 
                                                                    //  viewModel.Total = 0.09;
            var customer = await v_CustomerInfoRepository.QueryById(viewModel.CustomerId);
            var cardtypeinfo = await v_VipCardTypeRepository.QueryById(viewModel.ProductId);//5 test produtId
            try
            {
                _unitOfWork.BeginTran();
                var createtime = TimeUtil.GetCstDateTime();
                var baseResult = await _dal.Add(new V_OrderInfo
                {
                    //out_trade_no = payNum,
                    //PayType = 2,
                    OrderId = orderNo,
                    CardTypeId = cardtypeinfo.Id,
                    Status = EnumOrderType.payment,
                    CustomerId = customer.Id,
                    Price = cardtypeinfo.Money,
                    PayPrice = cardtypeinfo.Money,
                    Name = cardtypeinfo.Name,
                    CardNo = orderNo,
                    out_trade_no = orderNo,
                    CardId = -1,
                    CreateTime = createtime
                });
                if (baseResult > 0)
                {
                    _unitOfWork.CommitTran();
                    return await WeChatPayV3.QrCodePay(orderNo, cardtypeinfo.Money, cardtypeinfo.Name);
                }
                return QrCodeHelper.GetTextImageStream("无法显示二维码");
            }
            catch (System.Exception)
            {
                _unitOfWork.RollbackTran();
                // response.msg = "订单创建失败";
            }

            return QrCodeHelper.GetTextImageStream("无法显示二维码");
        }

        /// <summary>
        /// 下订单
        /// </summary>
        /// <param name="query"></param>
        /// <returns></returns>
        public async Task<CreateOrderModel> CreateOrder(UniOrderQuery query)
        {
            var response = new CreateOrderModel();
            string OrderNo = OrderGenerateHelper.GenerateOrderNo("ZY");
            try
            {
                _unitOfWork.BeginTran();
                var customer = await v_CustomerInfoRepository.QueryById(query.StudentId);
                var createtime = TimeUtil.GetCstDateTime();
                var baseResult = await _dal.Add(new V_OrderInfo
                {
                    //out_trade_no = payNum,
                    //PayType = 2,
                    OrderId = OrderNo,
                    CardTypeId = query.CardTypeId,
                    Status = EnumOrderType.payment,
                    CustomerId = customer.Id,
                    Price = query.total_fee,
                    PayPrice = query.total_fee,
                    Name = "志愿好帮手VIP购买",
                    //CardNo = code,
                    //CardId = addcard
                    CreateTime = createtime
                });
                if (baseResult > 0)
                {
                    _unitOfWork.CommitTran();
                    response.OrderId = OrderNo;
                    response.Status = EnumOrderType.payment;
                    response.CreateTime = createtime.ToString("yyyy-MM-dd HH:mm:ss");
                }
            }
            catch (System.Exception)
            {
                _unitOfWork.RollbackTran();
                response.msg = "订单创建失败";
                response.success = false;
                return response;
            }
            return response;
        }

        /// <summary>
        /// 订单查询
        /// </summary>
        /// <param name="query"></param>
        /// <returns></returns>
        public async Task<MessageModel<PageModel<OrderInfoQuery>>> GetOrderInfoByPage(SearchOrderQuery query)
        {
            var wheres = PredicateBuilder.New<V_OrderInfo>();
            wheres = wheres.And(x => x.IsDelete == false);
            //根据卡号查询
            if (!string.IsNullOrWhiteSpace(query.CardNo))
                wheres = wheres.And(x => x.CardNo.Contains(query.CardNo));

            //根据支付状态查询

            //  var status = Enum.Parse(typeof(EnumOrderType), query.Status.ToString());// (EnumOrderType)query.Status;
            if (query.Status > -2)
            {
                var status = (EnumOrderType)query.Status;
                wheres = wheres.And(x => x.Status == status);
            }


            //根据支付方式查询
            if (query.PayType > -1)
            {
                var payType = (EnumPayType)query.PayType;
                wheres = wheres.And(x => x.PayType == payType);
            }
            //根据out_trade_no查询
            if (!string.IsNullOrWhiteSpace(query.out_trade_no))
                wheres = wheres.And(x => x.out_trade_no.Contains(query.out_trade_no));


            //根据电话查询
            if (!string.IsNullOrWhiteSpace(query.Phone))
            {
                var CoustomerId = await v_CustomerInfoRepository.Query(x => x.Phone.Contains(query.Phone));
                var ids = CoustomerId.Select(x => x.Id).ToList();
                if (CoustomerId != null)
                    wheres = wheres.And(x => ids.Contains(x.CustomerId));
            }

            //根据卡片类别查询
            if (query.CardTypeId > 0)
                wheres = wheres.And(x => x.CardTypeId == query.CardTypeId);

            var info = await _dal.QueryPage(wheres, query.PageIndex, query.PageSize);
            if (info.data.Count <= 0)
                return new MessageModel<PageModel<OrderInfoQuery>>()
                {
                    success = false,
                    msg = "获取失败"
                };
            var idsCard = info.data.Select(x => x.CardTypeId).ToList();
            var idsCoustomer = info.data.Select(x => x.CustomerId).ToList();
            var listCard = await v_VipCardTypeRepository.Query(x => idsCard.Contains(x.Id) && x.IsDelete == false);
            var listCoustomer = await v_CustomerInfoRepository.Query(x => idsCoustomer.Contains(x.Id) && x.IsDelete == false);
            PageModel<OrderInfoQuery> pageModel = new PageModel<OrderInfoQuery>() { };
            List<OrderInfoQuery> list = new List<OrderInfoQuery>() { };
            foreach (var item in info.data)
            {
                var CardOne = listCard.Where(x => x.Id == item.CardTypeId).FirstOrDefault();
                if (CardOne == null)
                    continue;
                var CoustomerOne = listCoustomer.Where(x => x.Id == item.CustomerId).FirstOrDefault();
                if (CoustomerOne == null)
                    continue;

                list.Add(new OrderInfoQuery()
                {
                    CardId = item.Id,
                    PayPrice = item.PayPrice,
                    Price = item.Price,
                    CardNo = item.CardNo,
                    CardTypeName = CardOne.Name,
                    OrderId = item.OrderId,
                    CustomerName = CoustomerOne.NickName,
                    Name = item.Name,
                    //支付状态
                    StatusName = item.Status.GetDescription(),
                    out_trade_no = item.out_trade_no,
                    //支付方式
                    PayTypeName = item.PayType.GetDescription(),

                    Phone = CoustomerOne.Phone,
                });
            }
            pageModel.data = list;
            pageModel.dataCount = info.dataCount;
            pageModel.page = info.page;
            pageModel.pageCount = info.pageCount;
            pageModel.PageSize = info.PageSize;
            return new MessageModel<PageModel<OrderInfoQuery>>()
            {
                success = true,
                msg = "获取成功",
                response = pageModel
            };
        }



        public async Task<MessageModel<PageModel<OrderInfoQuery>>> GetFrontOrderInfoPage(FrontOrderQuery query)
        {

            if (query.CustomerId <= 0)
            {
                return new MessageModel<PageModel<OrderInfoQuery>>()
                {
                    msg = "customerId is null",

                };
            }
            var payType = query.PayType.HasValue ? (EnumPayType)query.PayType.Value : 0;
            var payStatus = query.Status.HasValue ? (EnumOrderType)query.Status.Value : 0;
            Expression<Func<V_OrderInfo, bool>> wheres = Expressionable.Create<V_OrderInfo>()
                .And(x => x.IsDelete == false)
                .And(x => x.CustomerId == query.CustomerId)
               .AndIF(!string.IsNullOrWhiteSpace(query.CardNo), x => x.CardNo.Contains(query.CardNo))//根据卡号查询
               .And(x => x.Status == payStatus) //根据支付状态查询
               .And(x => x.PayType == payType)
               .AndIF(!string.IsNullOrWhiteSpace(query.out_trade_no), x => x.out_trade_no.Contains(query.out_trade_no))
               .AndIF(query.CardTypeId > 0, x => x.CardTypeId == query.CardTypeId)  //根据卡片类别查询
               .ToExpression();
            var info = await _dal.QueryPage(wheres, query.PageIndex, query.PageSize);
            if (info.data.Count <= 0)
                return new MessageModel<PageModel<OrderInfoQuery>>()
                {
                    success = false,
                    msg = "获取失败"
                };
            var idsCard = info.data.Select(x => x.CardTypeId).ToList();
            var idsCoustomer = info.data.Select(x => x.CustomerId).ToList();
            var listCard = await v_VipCardTypeRepository.Query(x => idsCard.Contains(x.Id) && x.IsDelete == false);
            var listCoustomer = await v_CustomerInfoRepository.Query(x => idsCoustomer.Contains(x.Id) && x.IsDelete == false);
            PageModel<OrderInfoQuery> pageModel = new PageModel<OrderInfoQuery>() { };
            List<OrderInfoQuery> list = new List<OrderInfoQuery>() { };
            foreach (var item in info.data)
            {
                var CardOne = listCard.Where(x => x.Id == item.CardTypeId).FirstOrDefault();
                if (CardOne == null)
                    continue;
                var CoustomerOne = listCoustomer.Where(x => x.Id == item.CustomerId).FirstOrDefault();
                if (CoustomerOne == null)
                    continue;

                list.Add(new OrderInfoQuery()
                {
                    CardId = item.Id,
                    PayPrice = item.PayPrice,
                    Price = item.Price,
                    CardNo = item.CardNo,
                    CardTypeName = CardOne.Name,
                    OrderId = item.OrderId,
                    CustomerName = CoustomerOne.NickName,
                    Name = item.Name,
                    //支付状态
                    StatusName = item.Status.GetDescription(),
                    out_trade_no = item.out_trade_no,
                    //支付方式
                    PayTypeName = item.PayType.GetDescription(),

                    Phone = CoustomerOne.Phone,
                });
            }
            pageModel.data = list;
            pageModel.dataCount = info.dataCount;
            pageModel.page = info.page;
            pageModel.pageCount = info.pageCount;
            pageModel.PageSize = info.PageSize;
            return new MessageModel<PageModel<OrderInfoQuery>>()
            {
                success = true,
                msg = "获取成功",
                response = pageModel
            };
        }


        //public async Task<MessageModel<>>

        /// <summary>
        /// 支付订单回调修改状态
        /// </summary>
        /// <param name="orderNo"></param>
        /// <param name="payType"></param>
        /// <returns></returns>
        public async Task<bool> UpdateOrderStatus(string orderNo, EnumPayType payType, string trade_no)
        {
            bool status = false;
            var orderinfo = await _dal.Query(e => e.OrderId == orderNo);
            if (orderinfo.Any())
            {
                var cardtype = await v_VipCardTypeRepository.QueryById(orderinfo.FirstOrDefault().CardTypeId);
                if (cardtype == null)
                    return false;
                var code = RadomHelper.GetGuid();
                try
                {
                    _unitOfWork.BeginTran();
                    var addcard = await v_VipCardInfoRepository.Add(new V_VipCardInfo()
                    {
                        CardTypeId = cardtype.Id,
                        CardTypeName = cardtype.Name,
                        Code = code,
                        IsBind = 1,
                        Money = orderinfo.FirstOrDefault().PayPrice,
                        Day = cardtype.Day,
                        EndTime = DateTime.Now.AddDays(cardtype.Day)
                    });
                    if (addcard > 0)
                    {
                        var model = orderinfo.FirstOrDefault();
                        model.PayType = payType;
                        model.ModifyTime = TimeUtil.GetCstDateTime();
                        model.Status = EnumOrderType.payoff;
                        model.out_trade_no = trade_no;
                        var cc = await _dal.Update(model);
                        if (cc)
                        {
                            var oldorderlist = await _dal.Query(c => c.Id != model.Id && c.CustomerId == model.CustomerId && c.Status == EnumOrderType.payment);
                            oldorderlist.ForEach(async c =>
                            {
                                c.Status = EnumOrderType.Cancel;
                                await _dal.Update(c);
                            });

                            _unitOfWork.CommitTran();
                            status = true;
                        }
                    }
                }
                catch (Exception)
                {
                    _unitOfWork.RollbackTran();
                    return status;
                }
            }
            return status;
        }




        /// <summary>
        /// 支付成功后操作
        /// </summary>
        /// <param name="query"></param>
        /// <returns></returns>
        public async Task<MessageModel<string>> PaySuccess(V_OrderInfo query)
        {
            //生成一个卡号
            //修改订单状态
            try
            {
                var cardinfo = (await v_VipCardInfoRepository.QuerySql("SELECT Code FROM `V_VipCardInfo` where IsDelete=0")).Select(x => x.Code).ToList();

                var code = GetNumbers(cardinfo, Nums);

                if (string.IsNullOrWhiteSpace(code))
                {
                    logger.LogWarning("用户Id" + query.CustomerId + "的用户，支付成功，卡号生成失败，请联系客服");
                    return new MessageModel<string>() { success = false, msg = "支付成功，卡号生成失败，请联系客服" };
                }

                var cardtype = await v_VipCardTypeRepository.QueryById(query.CardTypeId);
                if (cardtype == null)
                {
                    logger.LogWarning("用户Id" + query.CustomerId + "的用户，支付成功，卡类型有误，请联系客服");
                    return new MessageModel<string>() { success = false, msg = "支付成功，卡类型有误，请联系客服" };
                }

                _unitOfWork.BeginTran();
                var cardadd = await v_VipCardInfoRepository.Add(new V_VipCardInfo()
                {
                    CardTypeId = cardtype.Id,
                    CardTypeName = cardtype.Name,
                    Code = code,
                    IsBind = 1,
                    Money = query.PayPrice,
                    Day = cardtype.Day,
                    EndTime = DateTime.Now.AddDays(cardtype.Day)
                });
                if (cardadd > 0)
                {
                    query.Status = EnumOrderType.payoff;
                    query.CardNo = code;
                    query.CardId = cardadd;
                    var updateorder = await _dal.Update(query);
                    if (updateorder)
                    {
                        //修改用户信息
                        var customerinfo = await v_CustomerInfoRepository.QueryById(query.CustomerId);
                        if (customerinfo == null)
                        {
                            _unitOfWork.RollbackTran();
                            logger.LogWarning("用户Id" + query.CustomerId + "的用户，支付成功，会员卡创建成功，用户信息不存在");
                            return new MessageModel<string>() { success = false, msg = "支付成功，会员卡创建成功，用户信息不存在" };
                        }
                        customerinfo.IsVIP = true;
                        customerinfo.VipCode = code;
                        var updateinfo = await v_CustomerInfoRepository.Update(customerinfo);
                        if (updateinfo)
                        {
                            _unitOfWork.CommitTran();
                            return new MessageModel<string>() { success = true, msg = "成功" };
                        }
                        else
                        {
                            logger.LogWarning("用户Id" + query.CustomerId + "的用户，支付成功，会员卡创建成功，用户信息修改失败");
                            _unitOfWork.RollbackTran();
                            return new MessageModel<string>() { success = false, msg = "支付成功，会员卡创建成功，用户信息修改失败" };
                        }
                    }
                    logger.LogWarning("用户Id" + query.CustomerId + "的用户，支付成功，订单修改失败，请联系客服");
                    return new MessageModel<string>() { success = false, msg = "支付成功，订单修改失败，请联系客服" };
                }
                logger.LogWarning("用户Id" + query.CustomerId + "的用户，支付成功，订单修改失败，请联系客服");
                return new MessageModel<string>() { success = false, msg = "支付成功，会员卡创建失败，请联系客服" };
            }
            catch (Exception)
            {
                _unitOfWork.RollbackTran();
                logger.LogWarning("用户Id" + query.CustomerId + "的用户，支付成功，订单修改失败，请联系客服");
                return new MessageModel<string>() { success = false, msg = "支付成功，订单修改失败，请联系客服" };
            }
        }

        /// <summary>
        /// 生成卡号 失败直接继续生成
        /// </summary>
        /// <param name="cardinfo"></param>
        /// <param name="Nums"></param>
        /// <returns></returns>
        public string GetNumbers(List<string> cardinfo, int Nums)
        {
            var code = "";
            for (int i = 0; i < 100; i++)
            {
                var newcode = GenerateCardNumberHelper.GenerateCardNumber("888", Nums);
                cardinfo.Add(newcode);
                var isUnique = cardinfo.GroupBy(x => x).All(g => g.Count() == 1);
                if (isUnique)
                {
                    code = newcode;
                    break;
                }
                else
                {
                    Nums += 1;
                    GetNumbers(cardinfo, Nums);
                }
            }
            return code;
        }




    }
}