using BaseOUDAL;
using DocumentFormat.OpenXml.Spreadsheet;
using NPOI.Util;
using System.Data;
using YieldChain.Helpers;
using YLErp.Commons;
using YLErp.DBModels;
using YLErp.DBModels.Enums;
using YLErp.Helpers;
using YLErp.Modules.ClientModule.Constant;
using YLErp.Modules.SwapModule;

namespace YLErp.Modules.ClientModule
{
    /// <summary>
    /// 客户银行卡服务
    /// </summary>
    public partial class ClientBankCardService : ClientBaseService
    {
        public ClientBankCardService(OptUserInfo userInfo) : base(userInfo)
        {

        }

        public ClientBankCardService(ClientBaseService baseService) : base(baseService)
        {
        }

        /// <summary>
        /// 查询bankcard
        /// </summary>
        public SearchListResult<ClientBankCard> SearchList(ClientBankCardReq req)
        {
            var query = DbContext.bankcard.AsNoTracking().AsQueryable().Where(d => d.ApprovalOrder < 1);

            if (!string.IsNullOrEmpty(req.Bank))
            {
                query = query.Where(d => d.Bank.Contains(req.Bank));
            }

            if (!string.IsNullOrEmpty(req.Card))
            {
                query = query.Where(d => d.Card.Contains(req.Card));
            }

            if (req.ValidState == "InValid")
            {
                query = query.Where(d => d.ValidState.Equals(req.ValidState));
            }
            else
            {
                query = query.Where(d => !d.ValidState.Equals("InValid"));
            }

            if (req.ClientId != null)
            {
                query = query.Where(d => d.ClientId == req.ClientId);
            }

            if (!string.IsNullOrEmpty(req.ClientName))
            {
                query = query.Where(d => d.ClientName.Contains(req.ClientName));
            }

            if (req.OptId != null)
            {
                query = query.Where(d => d.OptId == req.OptId);
            }

            if (!string.IsNullOrEmpty(req.OptName))
            {
                query = query.Where(d => d.OptName.Contains(req.OptName));
            }

            if (req.OptDateStart != DateTime.MinValue)
            {
                query = query.Where(d => d.OptDate >= req.OptDateStart);
            }

            if (req.OptDateEnd != DateTime.MinValue)
            {
                var OptDateTemp = req.OptDateEnd.AddDays(1);
                query = query.Where(d => d.OptDate < OptDateTemp);
            }
            if (!string.IsNullOrEmpty(req.State))
            {
                query = query.Where(d => d.State.Contains(req.State));
            }

            if (string.IsNullOrEmpty(req.sidx))
            {
                req.sidx = "id";
                req.sord = "desc";
            }
            var retListResult = query.ToSearchList(req);

            return retListResult;
        }

        /// <summary>
        /// 无效掉银行卡
        /// </summary>
        public ClientBankCard InvalidBankcard(int bankcardId, out Client client, bool isDirectSubApp = false)
        {
            if (bankcardId < 1)
            {
                throw new ServiceException("参数错误");
            }
            return InnerSaveBankCard(new ClientBankCard { id = bankcardId, ValidState = ConsGlobal.InValid }
            , out client, true, new HashSet<string> { nameof(ClientBankCard.ValidState) }, isDirectSubApp);
        }

        /// <summary>
        /// 保存银行卡数据
        /// </summary>
        public ClientBankCard SaveBankCard(ClientBankCard req, out Client client, HashSet<string> updatedPropertyNameSet = null, bool isDirectSubApp = false)
        {
            return InnerSaveBankCard(req, out client, false, updatedPropertyNameSet, isDirectSubApp);
        }

        private ClientBankCard InnerSaveBankCard(ClientBankCard req, out Client client, bool doInvalid, HashSet<string> updatedPropertyNameSet, bool isDirectSubApp = false)
        {
            ClientBankCard dbmodel;

            var changeStr = string.Empty;

            //新增
            bool isAdd = req.id < 1;

            if (isAdd)
            {
                client = req.ClientId > 0 ? DbContext.client.Find(req.ClientId) : null;

                if (client == null)
                {
                    throw new ServiceException("没有找到客户数据");
                }

                if (DbContext.bankcard.FirstOrDefault(o => o.ApprovalOrder < 1 && o.ApprovalOrder < 1 && o.Bank == req.Bank && o.ClientId == req.ClientId && o.Card == req.Card && o.ValidState != "InValid") != null)
                {
                    throw new ServiceException("一个客户下不能存在多个有效的重复银行卡号");
                }

                DbContext.bankcard.Add(dbmodel = new ClientBankCard());
            }
            else
            {
                dbmodel = DbContext.bankcard.Find(req.id);

                if (dbmodel == null)
                {
                    throw new ServiceException("未找到对应的银行卡信息,请刷新后再试!");
                }

                client = DbContext.client.Find(dbmodel.ClientId);

                if (client == null)
                {
                    throw new ServiceException("没有找到客户数据");
                }

                if (doInvalid && req.ValidState == dbmodel.ValidState)
                {
                    return dbmodel;
                }

                changeStr = DataChangeHelper.GetDataChanges(dbmodel, req).ToJson();
            }
            if (!string.IsNullOrEmpty(req.Card))
            {
                req.Card = req.Card.Replace(" ", "");
            }

            var clientCount = yldb.approvalprocess.Where(x => x.processType == "ClientProcess").Count();

            if (clientCount > 0 && (client.ProcessStatus == "已开户" || client.ProcessStatus == "已休眠") && (dbmodel.ApprovalOrder == 0))
            {
                if (!isAdd)
                {
                    if (!doInvalid)
                    {
                        var update = DbContext.bankcard.Where(x => x.SourceId == req.id)?.FirstOrDefault();
                        if (update != null)
                        {
                            ObjectHelper.MapValues(update, req.Copy(), "id");
                            SetDBModelOpt(update);
                        }
                        else
                        {
                            update = req.Copy();
                            update.id = 0;
                            SetDBModelOpt(update);
                            DbContext.bankcard.Add(update);
                        }
                        update.SourceId = req.id;
                        update.ApprovalOrder = (int)ApprovalOrderEnum.修改;
                    }
                    else
                    {
                        dbmodel.ApprovalOrder = (int)ApprovalOrderEnum.失效;
                    }
                }
                else
                {
                    ObjectHelper.MapValues(dbmodel, req);
                    SetDBModelOpt(dbmodel);
                    dbmodel.ApprovalOrder = (int)ApprovalOrderEnum.新增;
                }
                if (isDirectSubApp)
                {
                    var processlist = yldb.approvalprocess.Where(x => x.processType == "ClientProcess");
                    if (processlist.Count() > 0)
                    {
                        var groupId = UserBLL.GetApprovalProcessGroup(UserId);
                        bool approvalBranch = processlist.Any(x => x.approvalGroupId != 0);//审批流程有分支情况
                        client.ProcessOrderBranch = 0;
                        client.ApprovalOrderId = ProcessTradeLog.审批中;
                        client.ApprovalStatus = "审批中";
                        client.ApprovalOptDate = DateTime.Now;

                        if (approvalBranch)//审批流程有分支情况
                        {
                            //该审批组属于流程的审批组或该审批组不属于流程审批组
                            var tradeProessBranchQuery = processlist.FirstOrDefault(x => (x.approvalGroupId == groupId && x.approvalCondition == 1) || (x.approvalGroupId != groupId && x.approvalCondition == 2));
                            if (tradeProessBranchQuery == null)//都没有情况
                            {
                                throw new ServiceException("当前存在分支开户审批流程，检测到申请人不满足任意一个分支进入条件，无法提交审批，请更换申请人或调整审批组");
                            }
                            client.ApprovalOrderId = tradeProessBranchQuery.order > 1 ? 1 : tradeProessBranchQuery.order + 1;//第一个节点是分支需要跳过审批组那一级
                            client.ProcessOrderBranch = tradeProessBranchQuery.node ?? 1;//审批组分支
                        }

                        var range = DbContext.client_file_audit.Where(x => x.ClientId == req.ClientId).ToList();
                        DbContext.client_file_audit.RemoveRange(range);

                        var clientAuditlog = new ClientAuditLog
                        {
                            ClientId = client.id,
                            OptType = "提交信息变更审批",
                            DataType = "00",
                            OptId = UserId,
                            OptName = UserName,
                            OptDate = DateTime.Now
                        };

                        ///日志记录
                        DbContext.ClientAuditLog.Add(clientAuditlog);
                        DbContext.SaveChanges();
                        client.ApprovalLogId = clientAuditlog.id;
                    }
                }
                DbContext.SaveChanges();

                if (!isAdd)
                {
                    if (!doInvalid)
                    {
                        ObjectHelper.MapValues(dbmodel, req, "ApprovalOrder", "id");
                    }
                    else
                    {
                        dbmodel.ValidState = "InValid";
                    }
                    SetDBModelOpt(dbmodel);
                }

                return dbmodel;
            }
            else if (dbmodel.ApprovalOrder != 0)
            {
                if (!isAdd && !doInvalid)
                {
                    //Todo 当InValid的银行卡做修改时，仍然视为删除操作。。。
                    if (DbContext.bankcard.FirstOrDefault(o => o.ApprovalOrder < 1 && o.Bank == req.Bank && o.ClientId == req.ClientId && o.Card == req.Card && o.ValidState != "InValid" && o.id != req.id) != null)
                    {
                        throw new ServiceException("一个客户下不能存在多个有效的重复银行卡号");
                    }
                }
            }
            else
            {
                if (isAdd)
                {
                    DbContext.ClientAuditLog.Add(new ClientAuditLog
                    {
                        ClientId = req.ClientId ?? 0,
                        OptType = "新建银行卡",
                        Changes = string.Empty,
                        DataType = "00",
                        OptId = UserId,
                        OptName = UserName,
                        OptDate = OptDate
                    });
                }
                else
                {
                    if (!doInvalid)
                    {
                        //Todo 当InValid的银行卡做修改时，仍然视为删除操作。。。
                        if (DbContext.bankcard.FirstOrDefault(o => o.ApprovalOrder < 1 && o.Bank == req.Bank && o.ClientId == req.ClientId && o.Card == req.Card && o.ValidState != "InValid" && o.id != req.id) != null)
                        {
                            throw new ServiceException("一个客户下不能存在多个有效的重复银行卡号");
                        }
                        DbContext.ClientAuditLog.Add(new ClientAuditLog
                        {
                            ClientId = dbmodel.ClientId ?? 0,
                            OptType = "编辑银行卡",
                            Changes = changeStr,
                            DataType = "C02",
                            OptId = UserId,
                            OptName = UserName,
                            OptDate = OptDate
                        });
                    }
                    else
                    {
                        DbContext.ClientAuditLog.Add(new ClientAuditLog
                        {
                            ClientId = dbmodel.ClientId ?? 0,
                            OptType = "删除银行卡",
                            Changes = string.Empty,
                            DataType = "00",
                            OptId = UserId,
                            OptName = UserName,
                            OptDate = OptDate
                        });
                    }
                }
            }

            if (!doInvalid)
            {
                ObjectHelper.MapValues(dbmodel, req);
            }
            else
            {
                dbmodel.ValidState = "InValid";
            }
            SetDBModelOpt(dbmodel);

            DbContext.SaveChanges();
            return dbmodel;
        }

        /// <summary>
        /// 导出银行卡数据到EXCEL文件
        /// </summary>
        public byte[] ExportBankCardsToExcel(IEnumerable<int> clientIds)
        {
            var ret = DbContext.bankcard.AsNoTracking().AsQueryable().Where(o => o.ApprovalOrder < 1 && clientIds.Contains(o.ClientId ?? 0)).OrderBy(o => o.ClientName).ToList();

            var dc = new List<ExcelHelper.DataColumnModel>
            {


                new ExcelHelper.DataColumnModel("客户名称", "ClientId", (cv, obj) =>
                {
                    var id = (int?)cv ?? 0;
                    return DbContext.client.Where(o => o.id == id).FirstOrDefault().Name;
                }),
                new ExcelHelper.DataColumnModel("开户行", "Bank"),
                new ExcelHelper.DataColumnModel("账号", "Card",typeof(string)),
                new ExcelHelper.DataColumnModel("户名", "ClientName"),
                new ExcelHelper.DataColumnModel("大额行号", "Payment",typeof(string)),
                //new ExcelHelper.DataColumnModel("用途", "Use"),
                new ExcelHelper.DataColumnModel("是否有效", "ValidState", (cv, obj) =>
                {
                     if (cv == "InValid")
                     {
                         return "无效";
                     }
                     return "有效";
                 }),
                new ExcelHelper.DataColumnModel("客户备注", "Comments")
            };
            new ExcelHelper().ListToExcel<ClientBankCard>(dc.ToArray(), ret, "客户银行卡信息", true, out var buffer);
            return buffer;
        }

        /// <summary>
        /// 设置银行卡状态 当客户被销户或者休眠时
        /// </summary>
        /// <param name="clientId"></param>
        /// <param name="dbContext"></param>
        /// <returns></returns>
        public bool SetBankCardValidStateWhenClientDisable(int clientId, ClientDBContext dbContext = null)
        {
            dbContext ??= DbContext;
            var cards = dbContext.bankcard.Where(p => p.ApprovalOrder < 1 && p.ClientId == clientId && !"InValid".Equals(p.ValidState)).ToList();
            if (cards != null && cards.Count > 0)
            {
                cards.ForEach(p =>
                {
                    p.PreValidState = p.ValidState;
                    p.ValidState = "InValid";
                    SetDBModelOpt(p);
                });
                dbContext.SaveChanges();
            }
            return true;
        }

        /// <summary>
        /// 设置银行卡状态 当客户被解除休眠或者重新提交开户
        /// </summary>
        /// <param name="clientId"></param>
        /// <param name="dbContext"></param>
        /// <returns></returns>
        public bool SetBankCardValidStateWhenClientReEnable(int clientId, ClientDBContext dbContext = null)
        {
            dbContext ??= DbContext;
            var cards = dbContext.bankcard.Where(p => p.ApprovalOrder < 1 && p.ClientId == clientId && !string.IsNullOrEmpty(p.PreValidState)).ToList();
            if (cards != null && cards.Count > 0)
            {
                cards.ForEach(p =>
                {
                    p.ValidState = p.PreValidState;
                    p.PreValidState = "";
                    SetDBModelOpt(p);
                });
                dbContext.SaveChanges();
            }
            return true;
        }

        /// <summary>
        /// 根据银行卡号获取信息
        /// </summary>
        /// <param name="bankCode"></param>
        /// <returns></returns>
        public ClientBankCard GetBankCardByBankCode(string bankCode)
        {
            return DbContext.bankcard.Where(x => x.Card == bankCode).FirstOrDefault();
        }
    }

    /// <summary>
    /// 客户银行卡查询请求
    /// </summary>
    public class ClientBankCardReq : BaseSearchReq
    {
        /// <summary>
        /// 银行
        /// </summary> 
        public string Bank { get; set; }

        /// <summary>
        /// 卡号
        /// </summary> 
        public string Card { get; set; }

        /// <summary>
        /// 是否有效_validstate
        /// </summary> 
        public string ValidState { get; set; }

        /// <summary>
        /// 客户信息
        /// </summary> 
        public int? ClientId { get; set; }


        /// <summary>
        /// 客户名称
        /// </summary> 
        public string ClientName { get; set; }


        /// <summary>
        /// 操作者_optid
        /// </summary> 
        public int? OptId { get; set; }


        /// <summary>
        /// 操作者_optname
        /// </summary> 
        public string OptName { get; set; }


        /// <summary>
        /// 操作日期_createdate
        /// </summary> 
        public DateTime? OptDate { get; set; }

        public DateTime OptDateStart { get; set; }

        public DateTime OptDateEnd { get; set; }

        /// <summary>
        /// 状态
        /// </summary> 
        public string State { get; set; }

        public string Comments { get; set; }
    }
}