using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Data;
using CoreFS.CA06;
using DbHelp = Core.StlMes.Client.Sale.DbHelp;
namespace Core.StlMes.Client.Sale.SaleFundMgt.FundBLL.SelFundPactControl
{

    /// <summary>
    /// 外端调用资金系统的入口类
    /// 合同生效扣款:外端构造参数Model.SEL_FUND_CONTROL_PACT，外端判断是否是出口合同
    /// 下车扣款参数见定义
    /// </summary>
    public class SelFundPactControl:FundBaseBLL.FundBaseBLL
    {
         private OpeBase _ob;
         public SelFundPactControl(OpeBase ob)
            : base(ob)
       {
           _ob = ob;
       }
        /// <summary>
        /// 合同生效扣款
        /// </summary>
        /// <param name="pact"></param>
        /// <param name="errMsg"></param>
        public virtual void PayMentForPactToEffect(Model.SEL_FUND_CONTROL_PACT pact, out string errMsg)
        {

            errMsg = "";
            // 是否进行资金控制
            if (!FundVariable.FundConstVariable.isOpenFundControlMode)
                return;

            // 事务点
            DbHelp.DbTransaction transaction = base.GetTransaction();
            try
            {
                
                string secondLevelAccount = "";
                // 获取随机数
                string busiseq = Common.SaleFundCommon.GetBusiSeq();
                Model.SEL_FUND_PACT_ACCOUNT pact01 = null;
                // 参数检查
                if (!Model.SEL_FUND_CONTROL_PACT.IsValid(pact, out errMsg))
                {
                    return;
                }

                // 检查客户账户是否存在，不存在则提示错误，退出
                Model.SEL_FUND_CUST_ACCOUNT acct =
                    base.GetFundCustAccountInstance().GetSelFundCustAccountModelByBalanceAndBuyercode(pact.CUSTCONTROL.BALANCESUBJECT,
                    pact.CUSTCONTROL.BUYERCODE);
                if (acct == null)
                {
                    errMsg = _errMsgNoCustAccount;
                    return;
                }

                // 金额，这里有三个，总金额，货款，运费，如果货款为0，运费不为0，则也不处理
                if (pact.MONEY == 0)
                    return;

                // 检测合同账号和二级账号，顺延创建二级账户和合同账户
                // 创建规则，有则跳过，没有则创建，减少一些不必要的判断

                // 获取其二级账户
                secondLevelAccount = base.GetFundPactAccountRelationInstance().GetHighestPriorRealationByRelName(pact.PRODLINE);
                // 不存在,则取默认
                if (secondLevelAccount.Length == 0)
                {
                    secondLevelAccount = FundVariable.FundConstVariable.defaultSecondLevelAccount;
                }

                Model.SEL_FUND_PACT_ACCOUNT fundpact =
                    base.GetFundPactAccount(pact.CUSTCONTROL.BALANCESUBJECT, pact.CUSTCONTROL.BUYERCODE, secondLevelAccount, pact.PACTNO);
                fundpact.IMPORTOR = "System";

                // 创建二级账户和合同账户
                new FundBLL.FundSecondLevelAccount.FundSecondlevelAccountMgt(this._ob).CreateSecondLevelAccountAndPactAccount(fundpact, out errMsg);

                 pact01 =
                    base.GetFundPactAccountInstance().GetSelFundPactAccountByBalanceAndBuyerCodeAndPactno
                 (pact.CUSTCONTROL.BALANCESUBJECT,pact.CUSTCONTROL.BUYERCODE,pact.PACTNO);
                // 资金不足，退出
                 if (!IsMoneyEnoughForPactEffect(pact01, pact.PAYMONEY, out errMsg))
                {
                    return;
                }
                else
                {
                  // 构造类
                    Model.SEL_FUND_TRANS_PACT act = base.GetSelFundTransPact
                      (pact01.BALANCESUBJECT, pact01.BUYERCODE, pact01.SECONDACCOUNT, pact01.PACTNO, -pact.PAYMONEY);
                    pact.SECONDLEVELACCOUNT = pact01.SECONDACCOUNT;

                    // 明细记录
                    Model.SEL_FUND_PACT_FUNDUSEDETAIL detail = Model.SEL_FUND_PACT_FUNDUSEDETAIL.GetSelFundPactUsedDetail(pact, busiseq, FundVariable.FundConstVariable._transTypePactEffect );
                  
                    // 开始事务
                    transaction.BeginTransaction();
                    // 合同账户扣款
                   // base.GetFundPactAccountInstance().AddFundPactAccountLeaveMoney(act, transaction);

                    // 先将原有的明细记录设置为无效
                    base.GetFundPactUsedDetailInstance().UpdatePactEffectMoneyToUnValid(detail.BALANCESUBJECT,detail.BUYERCODE,detail.SECONDACCOUNT,detail.PACTNO,
                     transaction);
                    // 写明细记录
                     // 排产款显示负数
                    detail.MONEY = -detail.MONEY;
                    detail.ASKPLAN_MONEY = -detail.ASKPLAN_MONEY;
                    detail.TRANS_MONEY = -detail.TRANS_MONEY;
                    base.GetFundPactUsedDetailInstance().Insert(detail, transaction);
                    // 提交
                    transaction.Commit();
                    // 记录明细
                    errMsg = transaction.ErrMsg;
                }
            }
            catch(Exception ex)
            {
                errMsg = ex.Message;
                transaction.RollBack();
            }

        }



        private FundBLL.FundTransferMgt.FundTransferMgt GetInstanceTrans()
        {
            return new FundBLL.FundTransferMgt.FundTransferMgt(this._ob);
        }

        public Boolean IsAskplanIdExists(string balancesubject, string askPlanid)
        {
            return base.GetFundPactUsedDetailInstance().IsAskplanIdExists(balancesubject,askPlanid);
        }

        /// <summary>
        /// 检查一个车是否有装车冲减
        /// </summary>
        /// <param name="balancesubject"></param>
        /// <param name="askPlanid"></param>
        /// <returns></returns>
        public Boolean IsAskplanIdExistsLoad(string balancesubject, string askPlanid)
        {
            return base.GetFundPactUsedDetailInstance().IsAskplanIdExistsLoad(balancesubject, askPlanid);
        }

        /// <summary>
        /// 检查一个车是否有结算冲减
        /// </summary>
        /// <param name="balancesubject"></param>
        /// <param name="askPlanid"></param>
        /// <returns></returns>
        public Boolean IsAskplanIdExistsInvoince(string balancesubject, string askPlanid)
        {
            return base.GetFundPactUsedDetailInstance().IsAskplanIdExistsInvoince(balancesubject, askPlanid);
        }




        /// <summary>
        /// 判断资金是否足够，主要针对下车等实用剩余资金使用的
        /// </summary>
        /// <param name="pact"></param>
        /// <param name="RequestMoney"></param>
        /// <param name="errMsg"></param>
        /// <returns></returns>
         protected Boolean IsMoneyEnough(Model.SEL_FUND_PACT_ACCOUNT pact,double RequestMoney,out string errMsg)
        {
            errMsg = "";
             // 参数是否有效
            if (!Model.SEL_FUND_PACT_ACCOUNT.IsReasonable(pact, out errMsg))
            {
                return false;
            }

            Model.SEL_FUND_SECONDLEVEL_ACCOUNT pact02 = base.GetFundSecondAccountInstance().GetSelFundSecondAccountBySecondAccount
                   (pact.BALANCESUBJECT, pact.BUYERCODE, pact.SECONDACCOUNT);
            Model.SEL_FUND_CUST_ACCOUNT pact03 = base.GetFundCustAccountInstance().GetSelFundCustAccountModelByBalanceAndBuyercode
                        (pact.BALANCESUBJECT, pact.BUYERCODE);

             // 客户资金不足
            if (pact.LEAVEMONEY < RequestMoney)
            {
                // 检查二级账户资金+合同账户资金是否足够
                if (pact02 == null)
                {
                    errMsg = _errMsgException;
                    return false;
                }
                if (pact02.LEAVEMONEY + pact.LEAVEMONEY < RequestMoney)
                {
                    // 检查三级账户+二级账户+合同账户是否足够

                    if (pact03 == null)
                    {
                        errMsg = _errMsgException;
                        return false;
                    }
                    if (pact03.LEAVEMONEY + pact02.LEAVEMONEY + pact.LEAVEMONEY < RequestMoney)
                    {
                        errMsg = base._errMsgMoneyNotEnough;
                        return false;
                    }
                    else
                    {
                        // 资金足够，先将资金从客户账户转到二级账户，再从二级账户转到合同账户
                        Model.SEL_FUND_TRANS_PACT traspact = base.GetSelFundTransPact
                      (pact.BALANCESUBJECT, pact.BUYERCODE, pact.SECONDACCOUNT, pact.PACTNO, RequestMoney - pact.LEAVEMONEY - pact02.LEAVEMONEY);


                        // 转二级账户
                        this.GetInstanceTrans().TransferMoneyCustToSecondAccount(traspact.FUND_TRANS_SECONDACCOUNT, out errMsg);

                        // 二级转三级
                        traspact =
                        base.GetSelFundTransPact
                      (pact.BALANCESUBJECT, pact.BUYERCODE, pact.SECONDACCOUNT, pact.PACTNO, RequestMoney - pact.LEAVEMONEY);
                        this.GetInstanceTrans().TransferMoneySecondAccountToPact(traspact, out errMsg);
                        return true;
                    }
                }
                else
                { // 资金足够，则先将金额从二级账户转到合同账户
                    Model.SEL_FUND_TRANS_PACT traspact = base.GetSelFundTransPact
                        (pact.BALANCESUBJECT, pact.BUYERCODE, pact.SECONDACCOUNT, pact.PACTNO, RequestMoney - pact.LEAVEMONEY);
                    new FundBLL.FundTransferMgt.FundTransferMgt(this._ob).TransferMoneySecondAccountToPact(traspact, out  errMsg);
                    if (errMsg.Length > 0)
                        return false;
                    return true;

                }

            }
            else
            {
                return true;
            }
        }

        /// <summary>
        /// 装车冲减or结算冲减后，需要填平合同账户的负数问题
        /// 资金如果有负数，体现到客户账户
        /// </summary>
        /// <param name="pact"></param>
        /// <param name="RequestMoney"></param>
        /// <param name="errMsg"></param>
        protected void TransMoneyToPactAfterCredit(Model.SEL_FUND_PACT_ACCOUNT pact, out string errMsg)
        {
            //
            errMsg = "";
            try
            {
              
                if (pact.LEAVEMONEY >= 0)
                    return;
                Model.SEL_FUND_SECONDLEVEL_ACCOUNT pact02 = base.GetFundSecondAccountInstance().GetSelFundSecondAccountBySecondAccount
                     (pact.BALANCESUBJECT, pact.BUYERCODE, pact.SECONDACCOUNT);
                Model.SEL_FUND_CUST_ACCOUNT pact03 = base.GetFundCustAccountInstance().GetSelFundCustAccountModelByBalanceAndBuyercode
                            (pact.BALANCESUBJECT, pact.BUYERCODE);
                if (pact02.LEAVEMONEY + pact.LEAVEMONEY >= 0)
                {
                    Model.SEL_FUND_TRANS_PACT traspact = base.GetSelFundTransPact
                        (pact.BALANCESUBJECT, pact.BUYERCODE, pact.SECONDACCOUNT, pact.PACTNO, 0 - pact.LEAVEMONEY);
                    new FundBLL.FundTransferMgt.FundTransferMgt(this._ob).TransferMoneySecondAccountToPact(traspact, out  errMsg);
                }
                else
                {
                    Model.SEL_FUND_TRANS_PACT traspact = base.GetSelFundTransPact
                  (pact.BALANCESUBJECT, pact.BUYERCODE, pact.SECONDACCOUNT, pact.PACTNO, 0 - pact.LEAVEMONEY - pact02.LEAVEMONEY);

                    // 转二级账户
                    this.GetInstanceTrans().TransferMoneyCustToSecondAccountWithNoLeaveMoneyCheck(traspact.FUND_TRANS_SECONDACCOUNT, out errMsg);

                    // 二级转三级
                    traspact =
                    base.GetSelFundTransPact
                  (pact.BALANCESUBJECT, pact.BUYERCODE, pact.SECONDACCOUNT, pact.PACTNO, 0 - pact.LEAVEMONEY);
                    this.GetInstanceTrans().TransferMoneySecondAccountToPact(traspact, out errMsg);
                }
            }
            catch(Exception ex)
            {
                errMsg = ex.Message;
            }

        }


        /// <summary>
        /// 主要针对合同生效实用，生效比较的是合同总资金，
        /// 生效扣款的过程就是锁定合同资金，而不是实用资金
        /// </summary>
        /// <param name="pact"></param>
        /// <param name="RequestMoney"></param>
        /// <param name="errMsg"></param>
        /// <returns></returns>
        protected Boolean IsMoneyEnoughForPactEffect(Model.SEL_FUND_PACT_ACCOUNT pact, double RequestMoney, out string errMsg)
        {
            errMsg = "";
            // 参数是否有效
            if (!Model.SEL_FUND_PACT_ACCOUNT.IsReasonable(pact, out errMsg))
            {
                return false;
            }

            Model.SEL_FUND_SECONDLEVEL_ACCOUNT pact02 = base.GetFundSecondAccountInstance().GetSelFundSecondAccountBySecondAccount
                   (pact.BALANCESUBJECT, pact.BUYERCODE, pact.SECONDACCOUNT);
            Model.SEL_FUND_CUST_ACCOUNT pact03 = base.GetFundCustAccountInstance().GetSelFundCustAccountModelByBalanceAndBuyercode
                        (pact.BALANCESUBJECT, pact.BUYERCODE);

            // 客户资金不足
            // 合同生效扣款性质类似锁资金，而不是实用资金，
            // 需要用总资金比较
            if (pact.TOTALMONEY < RequestMoney)
            {
                // 检查二级账户资金+合同账户资金是否足够
                if (pact02 == null)
                {
                    errMsg = _errMsgException;
                    return false;
                }
                if (pact02.LEAVEMONEY + pact.TOTALMONEY < RequestMoney)
                {
                    // 检查三级账户+二级账户+合同账户是否足够

                    if (pact03 == null)
                    {
                        errMsg = _errMsgException;
                        return false;
                    }
                    if (pact03.LEAVEMONEY + pact02.LEAVEMONEY + pact.TOTALMONEY < RequestMoney)
                    {
                        errMsg = base._errMsgMoneyNotEnough;
                        return false;
                    }
                    else
                    {
                        // 资金足够，先将资金从客户账户转到二级账户，再从二级账户转到合同账户
                        Model.SEL_FUND_TRANS_PACT traspact = base.GetSelFundTransPact
                      (pact.BALANCESUBJECT, pact.BUYERCODE, pact.SECONDACCOUNT, pact.PACTNO, RequestMoney - pact.TOTALMONEY - pact02.LEAVEMONEY);


                        // 转二级账户
                        this.GetInstanceTrans().TransferMoneyCustToSecondAccount(traspact.FUND_TRANS_SECONDACCOUNT, out errMsg);

                        // 二级转三级
                        traspact =
                        base.GetSelFundTransPact
                      (pact.BALANCESUBJECT, pact.BUYERCODE, pact.SECONDACCOUNT, pact.PACTNO, RequestMoney - pact.TOTALMONEY);
                        this.GetInstanceTrans().TransferMoneySecondAccountToPact(traspact, out errMsg);
                        return true;
                    }
                }
                else
                { // 资金足够，则先将金额从二级账户转到合同账户
                    Model.SEL_FUND_TRANS_PACT traspact = base.GetSelFundTransPact
                        (pact.BALANCESUBJECT, pact.BUYERCODE, pact.SECONDACCOUNT, pact.PACTNO, RequestMoney - pact.TOTALMONEY);
                    new FundBLL.FundTransferMgt.FundTransferMgt(this._ob).TransferMoneySecondAccountToPact(traspact, out  errMsg);
                    if (errMsg.Length > 0)
                        return false;
                    return true;

                }

            }
            else
            {
                return true;
            }
        }


        /// <summary>
        /// 出库指示扣款
        /// </summary>
        /// <param name="dliv"></param>
        public virtual void PayMentForDeliver(Model.SEL_FUND_CONTROL_DLIV dliv, out string errMsg)
        {
            
            errMsg = "";
            string secondLevelAccount = "";
            // 不需要资金控制
            if (!FundVariable.FundConstVariable.isOpenFundControlMode)
                return;

            string busiseq = Common.SaleFundCommon.GetBusiSeq();
            DbHelp.DbTransaction transaction = base.GetTransaction();

            // 开始事务
            transaction.BeginTransaction();
            Model.SEL_FUND_PACT_ACCOUNT pact01 = null;
            try
            {
                // 参数检查
                if (!Model.SEL_FUND_CONTROL_DLIV.IsValid(dliv,out errMsg))
                {
                    errMsg = _errMsgException;
                    return;
                }

                List<Model.SEL_FUND_CONTROL_PACT> pactlist =
                    dliv.GetSelFundControlPactList();

                // 先删除原有 同号的车，并退出资金
                DeleteDelivPlan(pactlist[0].CUSTCONTROL.BALANCESUBJECT, pactlist[0].CUSTCONTROL.BUYERCODE, dliv.ASKPLAN_ID, out errMsg);
                //if (errMsg.Length > 0)
                //    return;

                // 先检查所有合同资金是否足够
                foreach (Model.SEL_FUND_CONTROL_PACT pact in pactlist)
                {
                    // 参数检查
                    if (!Model.SEL_FUND_CONTROL_PACT.IsValid(pact, out errMsg))
                    {
                        
                        return;
                    }
                    // 检查客户账户是否存在，不存在则提示错误，退出
                    Model.SEL_FUND_CUST_ACCOUNT acct =
                        base.GetFundCustAccountInstance().GetSelFundCustAccountModelByBalanceAndBuyercode(pact.CUSTCONTROL.BALANCESUBJECT,
                        pact.CUSTCONTROL.BUYERCODE);
                    if (acct == null)
                    {
                        errMsg = _errMsgNoCustAccount;
                        return;
                    }
                    // 金额，这里有三个，总金额，货款，运费，如果货款为0，运费不为0，则也不处理
                    if (pact.MONEY == 0)
                        continue;
                    // 检测合同账号和二级账号，顺延创建二级账户和合同账户
                    // 创建规则，有则跳过，没有则创建，减少一些不必要的判断

                    // 获取其二级账户
                    secondLevelAccount = base.GetFundPactAccountRelationInstance().GetHighestPriorRealationByRelName(pact.PRODLINE);
                  
                    // 不存在,则取默认
                    if (secondLevelAccount.Length == 0)
                    {
                        secondLevelAccount = FundVariable.FundConstVariable.defaultSecondLevelAccount;
                    }
                    Model.SEL_FUND_PACT_ACCOUNT fundpact =
                        base.GetFundPactAccount(pact.CUSTCONTROL.BALANCESUBJECT, pact.CUSTCONTROL.BUYERCODE, secondLevelAccount, pact.PACTNO);
                    fundpact.IMPORTOR = "System";

                    // 创建二级账户和合同账户
                    new FundBLL.FundSecondLevelAccount.FundSecondlevelAccountMgt(this._ob).CreateSecondLevelAccountAndPactAccount(fundpact, out errMsg);

                    pact01 =
                       base.GetFundPactAccountInstance().GetSelFundPactAccountByBalanceAndBuyerCodeAndPactno
                    (pact.CUSTCONTROL.BALANCESUBJECT, pact.CUSTCONTROL.BUYERCODE, pact.PACTNO);
                    // 资金不足，退出
                    if (!IsMoneyEnough(pact01, pact.PAYMONEY, out errMsg))
                    {
                        return;
                    }
                }

                // 资金充足情况，写明细
                foreach (Model.SEL_FUND_CONTROL_PACT pact in pactlist)
                {
                    if (pact.PAYMONEY == 0)
                        continue;
                   // transaction.BeginTransaction();
                    // 合同账户信息
                    pact01 =
                    base.GetFundPactAccountInstance().GetSelFundPactAccountByBalanceAndBuyerCodeAndPactno
                 (pact.CUSTCONTROL.BALANCESUBJECT, pact.CUSTCONTROL.BUYERCODE, pact.PACTNO);

                    // 构造类
                    Model.SEL_FUND_TRANS_PACT act = base.GetSelFundTransPact
                      (pact01.BALANCESUBJECT, pact01.BUYERCODE, pact01.SECONDACCOUNT, pact01.PACTNO, -pact.PAYMONEY);
                    pact.SECONDLEVELACCOUNT = pact01.SECONDACCOUNT;

                    // 明细记录
                    Model.SEL_FUND_PACT_FUNDUSEDETAIL detail = Model.SEL_FUND_PACT_FUNDUSEDETAIL.GetSelFundPactUsedDetail(pact, busiseq, FundVariable.FundConstVariable._transTypePactDeliver);
                    detail.ASKPLAN_ID = dliv.ASKPLAN_ID;

                    // 合同账户扣款
                    base.GetFundPactAccountInstance().AddFundPactAccountLeaveMoney(act, transaction);

                    // 先将原有的明细记录设置为无效
                    base.GetFundPactUsedDetailInstance().UpdateDlivMoneyToUnValid(detail.BALANCESUBJECT, detail.BUYERCODE, detail.SECONDACCOUNT, detail.PACTNO,
                     dliv.ASKPLAN_ID, transaction);
                    // 写明细记录
                    base.GetFundPactUsedDetailInstance().Insert(detail, transaction);

                    // 记录明细
                    errMsg = transaction.ErrMsg;
                    transaction.Commit();
                }
             
            }
            catch(Exception ex)
            {
                errMsg = ex.Message;
                transaction.RollBack();
            }

          
         
          
        }

        /// <summary>
        /// 装车冲减
        /// </summary>
        /// <param name="balncesubject"></param>
        /// <param name="buyercode"></param>
        /// <param name="askPlanid"></param>
        /// <param name="errMsg"></param>
        public virtual void PayMentForLoad(string balncesubject,string buyercode,string askPlanid,string carNo, List<Model.SEL_FUND_CONTROL_PACT_DLIV> listPactDliv, out string errMsg)
        {
            // 检查是否有结算冲减的数据，如果有，则不允许冲减

            List<Model.SEL_FUND_PACT_FUNDUSEDETAIL> listInvoince =
                base.GetFundPactUsedDetailInstance().GetSelFundPctUsedInvoiceByBalanceAndBuyercodeAndAskplanId(balncesubject, buyercode, askPlanid);
            if (listInvoince != null && listInvoince.Count > 0)
            {
                errMsg = "存在结算信息，不允许装车冲减";
                return;
            }

            // 删除下车，包括退款
           DeleteDelivPlan(balncesubject, buyercode, askPlanid, out errMsg);
            // 删除装车，包括退款
           DeleteDelivLoad(balncesubject, buyercode, askPlanid, out errMsg);

           DlivCredit(balncesubject, buyercode, askPlanid, carNo, listPactDliv, FundVariable.FundConstVariable._transTypePactLoad, out errMsg);

            // 检查客户账户是否有负数，如果有，且其子账户有资金，则需要填平客户账户
           // 是否需要由开关FundVariable.FundConstVariable.isUpdateCustAccountLeavemoneyToGreaterThanZero 决定
           UpdateCustAccountLeaveMoneyToGreaterThanZero(balncesubject,buyercode);

           this.DeleteAskplanIdLoadCredit(balncesubject, buyercode, askPlanid);

          

         
           
        }

        /// <summary>
        /// 结算冲减
        /// </summary>
        /// <param name="balncesubject"></param>
        /// <param name="buyercode"></param>
        /// <param name="askPlanid"></param>
        /// <param name="errMsg"></param>
        public virtual void PayMentForInvoice(string balncesubject, string buyercode, string askPlanid, string carNo, List<Model.SEL_FUND_CONTROL_PACT_DLIV> listPactDliv, out string errMsg)
        {

            // 删除下车，包括退款
            DeleteDelivPlan(balncesubject, buyercode, askPlanid, out errMsg);
            // 删除装车，包括退款
            DeleteDelivLoad(balncesubject, buyercode, askPlanid, out errMsg);
            // 删除结算数据
            DeleteDelivInvoice(balncesubject, buyercode, askPlanid, out errMsg);
            DlivCredit(balncesubject, buyercode, askPlanid, carNo, listPactDliv, FundVariable.FundConstVariable._transTypePactInvoice, out errMsg);

            // 检查客户账户是否有负数，如果有，且其子账户有资金，则需要填平客户账户
            // 是否需要由开关FundVariable.FundConstVariable.isUpdateCustAccountLeavemoneyToGreaterThanZero 决定
            UpdateCustAccountLeaveMoneyToGreaterThanZero(balncesubject, buyercode);

            DeleteAskplanIdInvoiceCredit(balncesubject, buyercode, askPlanid);
           
        }

        /// <summary>
        /// 检查一个客户账户资金是否为负数，如果是，则检查其下面账户是否有剩余资金大于0
        /// 如果有，则需要先填充客户账户
        /// </summary>
        /// <param name="balancesubject"></param>
        /// <param name="buyercode"></param>
        public void UpdateCustAccountLeaveMoneyToGreaterThanZero(string balancesubject,string buyercode)
        {
            if (!FundVariable.FundConstVariable.isUpdateCustAccountLeavemoneyToGreaterThanZero)
                return;
            Model.SEL_FUND_CUST_ACCOUNT acct =
                base.GetFundCustAccountInstance().GetSelFundCustAccountModelByBalanceAndBuyercode(balancesubject,buyercode);
            if (acct == null)
                return;
            if (acct.LEAVEMONEY >= 0)
                return;
            List<Model.SEL_FUND_SECONDLEVEL_ACCOUNT> list
            = base.GetFundSecondAccountInstance().GetSelFundSecondAccountByBalanceSubjectAndBuyercode(balancesubject, buyercode);
            if (list == null || list.Count == 0)
                return;
            string errMsg = "";
            Model.SEL_FUND_TRANS_SECONDACCOUNT sectransact = null;

            // 总共需要填平的资金
            double totalMoney = -acct.LEAVEMONEY;
           // 每个二级账户去找，直到资金足够填充客户的剩余资金
            foreach (Model.SEL_FUND_SECONDLEVEL_ACCOUNT secacct in list)
            {
                if (totalMoney == 0)
                    break;
                // 二级账户资金足够填充，则从二级账户扣
                if (secacct.LEAVEMONEY + acct.LEAVEMONEY >= 0)
                {
                    sectransact = GetTransSecondAct(GetTransCust(balancesubject, buyercode, -acct.LEAVEMONEY), secacct.SECONDACCOUNT, -acct.LEAVEMONEY);
                    this.GetInstanceTrans().TransferMoneySecondAccountToCust(sectransact,out errMsg);
                    break;
                }                
                else
                {
                    // 二级账户有剩余资金，先将其剩余资金转到客户账户
                    if (secacct.LEAVEMONEY > 0)
                    {
                        sectransact = GetTransSecondAct(GetTransCust(balancesubject, buyercode, secacct.LEAVEMONEY), secacct.SECONDACCOUNT, secacct.LEAVEMONEY);
                        this.GetInstanceTrans().TransferMoneySecondAccountToCust(sectransact, out errMsg);
                        totalMoney = totalMoney - secacct.LEAVEMONEY;
                    }
                    List<Model.SEL_FUND_PACT_ACCOUNT> pactList = base.GetFundPactAccountInstance()
                    .GetSelFundPactAccountByBalanceAndSecAccount(balancesubject, buyercode, secacct.SECONDACCOUNT);
                    foreach (Model.SEL_FUND_PACT_ACCOUNT pactact in pactList)
                    {
                        if (totalMoney == 0)
                            break;

                        if (pactact.LEAVEMONEY <= 0)
                            continue;
                        Model.SEL_FUND_TRANS_PACT transpact = null;
                        if (pactact.LEAVEMONEY <= totalMoney)
                        {
                              transpact =
                                this.GetTransPact(GetTransSecondAct(GetTransCust(balancesubject, buyercode, pactact.LEAVEMONEY), secacct.SECONDACCOUNT, pactact.LEAVEMONEY),
                                pactact.PACTNO, pactact.LEAVEMONEY);
                              totalMoney = totalMoney - pactact.LEAVEMONEY;
                        }
                        else
                        {
                            transpact =
                                this.GetTransPact(GetTransSecondAct(GetTransCust(balancesubject, buyercode, totalMoney), secacct.SECONDACCOUNT, totalMoney),
                                pactact.PACTNO,  totalMoney);
                            totalMoney = 0;
                        }
                        // 转二级
                        this.GetInstanceTrans().TransferMoneyPactToSecondAccount(transpact, out errMsg);
                        // 转客户
                        this.GetInstanceTrans().TransferMoneySecondAccountToCust(transpact.FUND_TRANS_SECONDACCOUNT, out errMsg);
                    }
                }
                
            }
 
        }

        /// <summary>
        ///
        /// </summary>
        /// <param name="balancesubject"></param>
        /// <param name="buyercode"></param>
        /// <param name="money"></param>
        /// <returns></returns>
        private Model.SEL_FUND_TRANS_CUST GetTransCust(string balancesubject,string buyercode,double money)
        {
            return new Model.SEL_FUND_TRANS_CUST(balancesubject, buyercode, money, "System", Util.DateTimeUtil.GetSystemDate());
        }

        private Model.SEL_FUND_TRANS_SECONDACCOUNT GetTransSecondAct(Model.SEL_FUND_TRANS_CUST cust, string secondact, double money)
        {
            return new Model.SEL_FUND_TRANS_SECONDACCOUNT(cust, secondact, money);
        }

        private Model.SEL_FUND_TRANS_PACT GetTransPact(Model.SEL_FUND_TRANS_SECONDACCOUNT secact,string pactno,double money)
        {
            Model.SEL_FUND_TRANS_PACT pact = new Model.SEL_FUND_TRANS_PACT();
            pact.FUND_TRANS_SECONDACCOUNT = secact;
            pact.PACTNO = pactno;
            pact.TRANS_MONEY = money;
            return pact;
        }

        /// <summary>
        /// 冲减共用方法
        /// </summary>
        /// <param name="balncesubject"></param>
        /// <param name="buyercode"></param>
        /// <param name="askPlanid"></param>
        /// <param name="carNo"></param>
        /// <param name="listPactDliv"></param>
        /// <param name="errMsg"></param>
        private void DlivCredit(string balncesubject, string buyercode, string askPlanid, string carNo, List<Model.SEL_FUND_CONTROL_PACT_DLIV> listPactDliv, string transType,out string errMsg)
        {
            errMsg = "";
            Model.SEL_FUND_CONTROL_PACT pact = null;
            Model.SEL_FUND_PACT_ACCOUNT pact01 = null;
            // 构造类
            Model.SEL_FUND_TRANS_PACT act = null;

            DbHelp.DbTransaction transaction = base.GetTransaction();
            transaction.BeginTransaction();
            try
            {
                foreach (Model.SEL_FUND_CONTROL_PACT_DLIV dliv in listPactDliv)
                {
                    pact01 =
                   base.GetFundPactAccountInstance().GetSelFundPactAccountByBalanceAndBuyerCodeAndPactno
                   (balncesubject, buyercode, dliv.PACTNO);
                    Model.SEL_FUND_CONTROL_CUST cust = new Model.SEL_FUND_CONTROL_CUST
                    (balncesubject, buyercode, "System", Util.DateTimeUtil.GetSystemDate());

                    // 合同账户扣款
                    pact = new Model.SEL_FUND_CONTROL_PACT
                  (cust, pact01.SECONDACCOUNT, dliv.PACTNO, dliv.PRODLINE, dliv.WEIGHT, dliv.MONEY, dliv.TRANSMONEY);
                    // 合同账户扣款
                    act = base.GetSelFundTransPact(balncesubject, buyercode, pact01.SECONDACCOUNT, dliv.PACTNO, -dliv.MONEY - dliv.TRANSMONEY);
                    Model.SEL_FUND_PACT_FUNDUSEDETAIL detail = Model.SEL_FUND_PACT_FUNDUSEDETAIL.GetSelFundPactUsedDetail
                    (pact, Common.SaleFundCommon.GetBusiSeq(), transType);
                    detail.ASKPLAN_ID = askPlanid;
                    base.GetFundPactAccountInstance().AddFundPactAccountLeaveMoney(act, transaction);

                    base.GetFundPactUsedDetailInstance().Insert(detail, transaction);
                 
                }

                transaction.Commit();

                foreach (Model.SEL_FUND_CONTROL_PACT_DLIV dliv in listPactDliv)
                {
                    try
                    {
                        TransMoneyToPactAfterCredit(base.GetFundPactAccountInstance().GetSelFundPactAccountByBalanceAndBuyerCodeAndPactno
                       (balncesubject, buyercode, dliv.PACTNO), out errMsg);
                    }
                    catch
                    { 
                    }
                }

            }

                
            catch (Exception ex)
            {
                errMsg = ex.Message;
                transaction.RollBack();
            }
        }

       /// <summary>
       /// 删除一个出库指示，带事务，用在下车时用
       /// </summary>
       /// <param name="balanceSubject"></param>
       /// <param name="buyercode"></param>
       /// <param name="askPlan_id"></param>
       /// <param name="transaction"></param>
        public virtual void DeleteDelivPlan(string balanceSubject, string buyercode, string askPlan_id, DbHelp.DbTransaction transaction)
        {
            try
            {
                List<Model.SEL_FUND_PACT_FUNDUSEDETAIL> detal
                = base.GetFundPactUsedDetailInstance().GetSelFundPctUsedDelivByBalanceAndBuyercodeAndAskplanId(balanceSubject, buyercode, askPlan_id);
                if (detal == null)
                    return;
                if (detal.Count == 0)
                    return;
                Model.SEL_FUND_TRANS_PACT act = null;
                foreach (Model.SEL_FUND_PACT_FUNDUSEDETAIL detail in detal)
                {
                     act = base.GetSelFundTransPact
                   (detail.BALANCESUBJECT, detail.BUYERCODE, detail.SECONDACCOUNT, detail.PACTNO, detail.MONEY);
                     // 退钱到合同账户
                     base.GetFundPactAccountInstance().AddFundPactAccountLeaveMoney(act, transaction);
                     // 先将原有的明细记录设置为无效
                     base.GetFundPactUsedDetailInstance().UpdateDlivMoneyToUnValid(detail.BALANCESUBJECT, detail.BUYERCODE, detail.SECONDACCOUNT, detail.PACTNO,
                     detail.ASKPLAN_ID, transaction);
 
                }
            }
            catch(Exception ex)
            {
                transaction.ErrMsg = ex.Message;
                transaction.RollBack ();
            }

        }

      

        /// <summary>
        /// 删除一个出库指示，不带事务，在界面做删除操作时使用
        /// </summary>
        /// <param name="balanceSubject">结算单位</param>
        /// <param name="buyercode">客户编码</param>
        /// <param name="askPlan_id">计划单号</param>
        /// <param name="errMsg"></param>
        public virtual void DeleteDelivPlan(string balanceSubject, string buyercode, string askPlan_id,out string errMsg)
        {
            DbHelp.DbTransaction transaction = base.GetTransaction();
            errMsg = "";
            try
            {
                transaction.BeginTransaction();
                List<Model.SEL_FUND_PACT_FUNDUSEDETAIL> detal
                = base.GetFundPactUsedDetailInstance().GetSelFundPctUsedDelivByBalanceAndBuyercodeAndAskplanId(balanceSubject, buyercode, askPlan_id);
                if (detal == null)
                    return;
                if (detal.Count == 0)
                    return;
                Model.SEL_FUND_TRANS_PACT act = null;
                foreach (Model.SEL_FUND_PACT_FUNDUSEDETAIL detail in detal)
                {
                    act = base.GetSelFundTransPact
                  (detail.BALANCESUBJECT, detail.BUYERCODE, detail.SECONDACCOUNT, detail.PACTNO, detail.MONEY);

                    // 退钱到合同账户
                    base.GetFundPactAccountInstance().AddFundPactAccountLeaveMoney(act, out errMsg);
                    // 先将原有的明细记录设置为无效
                    base.GetFundPactUsedDetailInstance().UpdateDlivMoneyToUnValid(detail.BALANCESUBJECT, detail.BUYERCODE, detail.SECONDACCOUNT, detail.PACTNO,
                    detail.ASKPLAN_ID, out errMsg);

                }
                transaction.Commit();
            }
            catch(Exception ex)
            {
                errMsg = ex.Message;
                transaction.RollBack();
            }

        }


        /// <summary>
        /// 删除装车数据并退款
        /// </summary>
        /// <param name="balanceSubject"></param>
        /// <param name="buyercode"></param>
        /// <param name="askPlan_id"></param>
        /// <param name="transaction"></param>
        public virtual void DeleteDelivLoad(string balanceSubject, string buyercode, string askPlan_id, out string errMsg)
        {
            DbHelp.DbTransaction transaction = base.GetTransaction();
            errMsg = "";
            try
            {
                
                transaction.BeginTransaction();
                List<Model.SEL_FUND_PACT_FUNDUSEDETAIL> detal
                = base.GetFundPactUsedDetailInstance().GetSelFundPctUsedLoadByBalanceAndBuyercodeAndAskplanId(balanceSubject, buyercode, askPlan_id);
                if (detal == null)
                    return;
                if (detal.Count == 0)
                    return;
                Model.SEL_FUND_TRANS_PACT act = null;
                foreach (Model.SEL_FUND_PACT_FUNDUSEDETAIL detail in detal)
                {
                    act = base.GetSelFundTransPact
                  (detail.BALANCESUBJECT, detail.BUYERCODE, detail.SECONDACCOUNT, detail.PACTNO, detail.MONEY);
                    // 退钱到合同账户
                    base.GetFundPactAccountInstance().AddFundPactAccountLeaveMoney(act, out errMsg);
                    // 先将原有的明细记录设置为无效
                    base.GetFundPactUsedDetailInstance().UpdateLoadMoneyToUnValid(detail.BALANCESUBJECT, detail.BUYERCODE, detail.SECONDACCOUNT, detail.PACTNO,
                    detail.ASKPLAN_ID, out errMsg);
                }
                transaction.Commit();
               
            }
            catch (Exception ex)
            {
                transaction.ErrMsg = ex.Message;
                transaction.RollBack();
            }

        }

        /// <summary>
        /// 删除结算数据并退款
        /// </summary>
        /// <param name="balanceSubject"></param>
        /// <param name="buyercode"></param>
        /// <param name="askPlan_id"></param>
        /// <param name="errMsg"></param>
        public virtual void DeleteDelivInvoice(string balanceSubject, string buyercode, string askPlan_id, out string errMsg)
        {
            DbHelp.DbTransaction  transaction = base.GetTransaction();
            errMsg = "";
            try
            {

                transaction.BeginTransaction();
                List<Model.SEL_FUND_PACT_FUNDUSEDETAIL> detal
                = base.GetFundPactUsedDetailInstance().GetSelFundPctUsedInvoiceByBalanceAndBuyercodeAndAskplanId(balanceSubject, buyercode, askPlan_id);
                if (detal == null)
                    return;
                if (detal.Count == 0)
                    return;
                Model.SEL_FUND_TRANS_PACT act = null;
                foreach (Model.SEL_FUND_PACT_FUNDUSEDETAIL detail in detal)
                {
                    act = base.GetSelFundTransPact
                  (detail.BALANCESUBJECT, detail.BUYERCODE, detail.SECONDACCOUNT, detail.PACTNO, detail.MONEY);

                    // 退钱到合同账户
                    base.GetFundPactAccountInstance().AddFundPactAccountLeaveMoney(act, transaction);
                    // 先将原有的明细记录设置为无效
                    base.GetFundPactUsedDetailInstance().UpdateInvoiceMoneyToUnValid(detail.BALANCESUBJECT, detail.BUYERCODE, detail.SECONDACCOUNT, detail.PACTNO,
                    detail.ASKPLAN_ID, transaction);
                }
                transaction.Commit();

            }
            catch (Exception ex)
            {
                transaction.ErrMsg = ex.Message;
                transaction.RollBack();
            }

        }

        /// <summary>
        /// 结算冲减时，删除无效数据，真删除
        /// </summary>
        /// <param name="balanceSubject"></param>
        /// <param name="buyercode"></param>
        /// <param name="askPlan_id"></param>
        private void DeleteAskplanIdInvoiceCredit(string balanceSubject, string buyercode, string askPlan_id)
        {
            string errMsg = "";
            try
            {
                base.GetFundPactUsedDetailInstance().DeleteUnValidDelivAskPlanId(balanceSubject, buyercode, askPlan_id, out errMsg);
                base.GetFundPactUsedDetailInstance().DeleteUnValidLoadAskPlanId(balanceSubject, buyercode, askPlan_id, out errMsg);
                base.GetFundPactUsedDetailInstance().DeleteUnValidInvoinceAskPlanId(balanceSubject, buyercode, askPlan_id, out errMsg);
            }
            catch
            { 
            }
        }

        /// <summary>
        /// 装车冲减时，删除已经假删除的数据
        /// </summary>
        /// <param name="balanceSubject"></param>
        /// <param name="buyercode"></param>
        /// <param name="askPlan_id"></param>
        private void DeleteAskplanIdLoadCredit(string balanceSubject, string buyercode, string askPlan_id)
        {
            string errMsg = "";
            try
            {
                base.GetFundPactUsedDetailInstance().DeleteUnValidDelivAskPlanId(balanceSubject, buyercode, askPlan_id, out errMsg);
                base.GetFundPactUsedDetailInstance().DeleteUnValidLoadAskPlanId(balanceSubject, buyercode, askPlan_id, out errMsg);
            }
            catch
            {
            }
        }


        private string _errMsgNoCustAccount = "客户账户未创建，请先创建客户的资金账户";
        private string _errMsgException = "异常错误";
      
      
    }
}