using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using PTMedicalInsurance.Common;
using PTMedicalInsurance.Business;
using System.Windows.Forms;
using PTMedicalInsurance.Helper;
using Newtonsoft.Json.Linq;
using PTMedicalInsurance.Variables;
using PTMedicalInsurance.Forms;
using System.IO;
using System.Reflection;
using System.Data;
using System.Threading;
using PTMedicalInsurance.Business.Core.SelfServiceMachine.ProcessScheduler;

namespace PTMedicalInsurance
{

    public class InsuBusiness : IInsuBusiness
    {

        //定义相关的变量
        //private Patients patient;
        //private Fees fee;
        //private Settlements settlement;

        //json对象属性
        private JObject joInParam;
        private JArray jaSession ;
        private JArray jaParams;
        private JObject joParam;
        private JObject joInterface;
        private JObject joInsuAdmObj;

        //设置业务实例
        CenterBusiness cBus = new CenterBusiness();
        HisMainBusiness hBus = new HisMainBusiness();
        HisIrisServices hIS = new HisIrisServices();
        MIIrisServices mIS= new MIIrisServices();
        InvokeHelper invoker = new InvokeHelper();
        //
        private string businessType;
        private string operationType;

        public InsuBusiness()
        {
            Global.curEvt.path = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
            ComputerInfo comp = new ComputerInfo();
            Global.curEvt.mac = comp.GetMAC();
            Global.curEvt.ip = comp.GetIP();
            Global.pat.insuplc_admdvs = "";        //如果是NULL中心会报错
        }

        private int parseInparam(string inParam,out string errMsg)
        {
            errMsg = "";
            try
            {
                joInParam = JObject.Parse(inParam);
                jaSession = JArray.Parse(JsonHelper.getDestValue(joInParam, "session"));
                Global.curEvt.jaSession = jaSession;
                jaParams = JArray.Parse(JsonHelper.getDestValue(joInParam, "params"));
                joParam = JObject.FromObject(jaParams[0]);

                if (JsonHelper.getDestValue(joInParam, "insuAdmObj") != "")
                    joInsuAdmObj = JObject.Parse(JsonHelper.getDestValue(joInParam, "insuAdmObj"));
                joInterface = JObject.Parse(JsonHelper.getDestValue(joInParam, "interfaceinfo"));

                businessType = JsonHelper.getDestValue(joInParam, "businessType");
                operationType = JsonHelper.getDestValue(joInParam, "operationType");
                //if ((businessType == "M6") || (businessType == "M6C") || (businessType == "M6Confirm"))
                //{
                //    Environment.CurrentDirectory = @"D:\HttpServerAPI\bin";
                //}
                return 0;
            }
            catch (Exception ex)
            {
                errMsg = "parseInparam 解析入参异常：" + errMsg;
                return -1;
            }
            finally
            {
                Global.writeLog("parseInparam交易结束！" + errMsg) ;
            }

        }
        
        /// <summary>
        /// 签到
        /// </summary>
        /// <param name="InParam"></param>
        /// <returns></returns>
        public string Init(string InParam)
        {
            string errMsg, rtnResult ="";
            JObject joRtn = new JObject();
            try
            {
                if (hBus.initEnvironment(InParam, out errMsg) != 0)
                {   
                    return JsonHelper.setExceptionJson(-100, "initEnvironment 失败", errMsg).ToString();
                }
                else
                {
                    if (mIS.isSigned(ref Global.curEvt.signno) != true)
                    {
                        if (businessType != "BasicData")//如果是打开数据对照界面不调用初始化 
                        {
                            CallResult callResult = new SignInProcess().Process(joRtn);
                            rtnResult = callResult.Data;
                        }
                        else
                        {
                            Global.curEvt.signno = "ABC123";
                            rtnResult = JsonHelper.setIrisReturnValue(0, "初始化成功（医保对照不初始化）！", null).ToString();
                        }
                    }
                    else
                    {
                        rtnResult = JsonHelper.setIrisReturnValue(0, "初始化成功！", null).ToString();
                    }
                    return rtnResult;
                }
            }
            catch (Exception ex)
            {
                rtnResult = JsonHelper.setExceptionJson(-100, "Init 异常", ex.Message).ToString();
                return rtnResult;
            }
            finally
            {
                Global.writeLog("初始化结果：" + rtnResult);
            }
        }

        /// <summary>
        /// 初始化
        /// </summary>
        /// <param name="inParam"></param>
        /// <param name="outParam"></param>
        /// <returns></returns>
        private int init(string inParam, out string outParam)
        {
            string errMsg;
            outParam = "";
            try
            {

                //BS架构调用方式问题，每次调用都需要重新初始化
                JObject joInitRtn = JObject.Parse(Init(inParam));
                if (JsonHelper.parseIrisRtnValue(joInitRtn, out errMsg) != 0)
                {
                    outParam = JsonHelper.setExceptionJson(-100, "init(HIS医保环境初始化)", errMsg).ToString();
                    return -1;
                }
                else
                {
                    return 0;
                }
            }
            catch (Exception ex)
            {
                outParam = JsonHelper.setExceptionJson(-100, "init(HIS医保环境初始化)异常", ex.Message).ToString();
                return -1;
            }
            finally
            {
                Global.writeLog("init交易结束" + outParam);
            }
        }

        /// <summary>
        /// 获取患者信息
        /// </summary>
        /// <param name="InParam"></param>
        /// <returns></returns>
        public string GetPatientInfo(string InParam)
        {
            Global.writeLog("GetPatientInfo入参:" + JsonHelper.Compress(InParam));
            //设置返回值，错误信息
            string rtnResult = "",outParam;
            //BS架构调用方式问题，每次调用都需要重新初始化
            if (init(InParam,out outParam)!= 0)
            {
                rtnResult = outParam;
                return rtnResult;
            }
            JObject joInParam = JObject.Parse(InParam);
            string businessType = JsonHelper.getDestValue(joInParam,"businessType");
            Global.pat.presetIDNO = JsonHelper.getDestValue(joInParam, "params[0].idNo");
            try
            {
               
                switch (businessType)
                {
                    case "M1"://门诊读卡
                    case "Z1"://住院读卡
                        {
                            Global.pat.admID = JsonHelper.getDestValue(joInParam, "params[0].admID");
                            if (!string.IsNullOrEmpty(Global.pat.admID)) {
                                Global.pat.adm_Dr = int.Parse(Global.pat.admID);
                            }
                            
                            //打开读卡窗口，操作员选择读卡类型后进行读卡器读卡，再进行1101获取参保信息
                            PatientService patientService = new PatientService();
                            patientService.readPatientInfo(out outParam);
                            // 同时支持返回错误信息和对象
                            rtnResult = outParam.ParseReturnObject();
                            break;
                        }     
                }
                return rtnResult;
            }
            catch (Exception ex)
            {
                rtnResult = JsonHelper.setIrisReturnValue(-1 , "GetPatientInfo发生异常;" + ex.Message,null).ToString();
                return rtnResult;
            }
            finally
            {
                Global.writeLog("GetPatientInfo出参:" + JsonHelper.Compress(rtnResult));
            }
        }

        /// <summary>
        /// 登记
        /// </summary>
        /// <param name="InParam"></param>
        /// <returns></returns>
        public string Register(string InParam)
        {
            Global.writeLog("Register 入参:" + JsonHelper.Compress(InParam));
            //设置返回值，错误信息
            string errMsg, rtnResult = "", outParam;
            try
            {
                //解析入参
                if (parseInparam(InParam, out errMsg) != 0)
                {
                    rtnResult = JsonHelper.setExceptionJson(-1, "", errMsg).ToString();
                    return rtnResult;
                }
                //BS架构调用方式问题，每次调用都需要重新初始化
                if (init(InParam, out outParam) != 0)
                {
                    rtnResult = outParam;
                    return rtnResult;
                }
                //获取pat
                hBus.GetRegPatInfo(businessType, joInParam, out Global.pat);
                switch (businessType)
                {
                    case "M2"://门诊登记
                        {
                            //string patInfo = "";
                            //errMsg = showPatientInfo(out patInfo, out outParam);
                            //if (!errMsg.Equals("0"))
                            //{
                            //    return errMsg;
                            //}

                            //Global.writeLog("获取到病人信息:" + patInfo);

                            //JObject reg = JObject.Parse(patInfo);

                            //this.OutpatientReg(reg,patInfo);

                            break;
                        }
                    case "M2C"://门诊登记撤销
                        {
                            break;
                        }
                    case "Z0"://住院修改
                        {
                            Global.Set.clearingWay = "1"; //住院
                            rtnResult = new InpatientRegistionProcess().Process(joParam).Data;
                            break;
                            break;
                        }
                    case "Z2"://入院登记
                        {
                            Global.Set.clearingWay = "1"; //住院
                            rtnResult = new InpatientRegistionProcess().Process(joParam).Data;
                            break;
                        }
                    case "Z2C"://入院登记取消
                        {
                            rtnResult = new InpatientRegCancelProcess().Process(joParam).Data;
                            break;

                        }
                    case "Z6"://出院登记
                        {
                            break;
                        }
                    case "Z6C"://出院登记取消
                        {
                            rtnResult = new InpatientExitCancelProcess().Process(joParam).Data;
                            break;
                        }
                    default:
                        {
                            rtnResult = JsonHelper.setExceptionJson(-1, "Register 交易", "传入的业务编码不对！").ToString();
                            return rtnResult;
                        }

                }
            }
            catch (Exception ex)
            {
                rtnResult = JsonHelper.setIrisReturnValue(-1, "Register 发生异常;" + ex.Message, null).ToString();
                return rtnResult;
            }
            finally
            {
                Global.writeLog("Register 出参:" + JsonHelper.Compress(rtnResult));
            }


            return rtnResult;
        }

        /// <summary>
        /// 费用上传
        /// </summary>
        /// <param name="InParam"></param>
        /// <returns></returns>
        public string FeeUpload(string InParam)
        {
            Global.writeLog("FeeUpload 入参:" +  JsonHelper.Compress(InParam));
            //设置返回值，错误信息
            string errMsg, rtnResult = "", outParam;
            try
            {
                //解析入参
                if (parseInparam(InParam, out errMsg) != 0)
                {
                    rtnResult = JsonHelper.setExceptionJson(-1, "", errMsg).ToString();
                    return rtnResult;
                }
                
                //BS架构调用方式问题，每次调用都需要重新初始化
                if (init(InParam, out outParam) != 0)
                {
                    rtnResult = outParam;
                    return rtnResult;
                }
                //获取pat
                hBus.GetFeeHisInfo(businessType, joInParam, out Global.pat);
                switch (businessType)
                {
                    case "M3"://门诊费用上传
                        {
                            break;
                        }
                    case "M3C"://门诊费用撤销
                        {

                            break;
                        }
                    case "Z3"://入院费用上传
                        {
                            rtnResult = new InpatientFeeUploadProcess().Process(joParam).Data;
                            break;
                        }
                    case "Z3C"://住院费用上传取消
                        {
                            rtnResult = new InpatientFeeUploadCancelProcess().Process(joParam).Data;
                            break;
                        }

                    default:
                        {
                            rtnResult = JsonHelper.setExceptionJson(-1, "FeeUpload 交易", "传入的业务编码不对！").ToString();
                            return rtnResult;
                        }
                }
                return rtnResult;
            }
            catch (Exception ex)
            {
                rtnResult = JsonHelper.setExceptionJson(-1, "FeeUpload 交易", ex.Message).ToString();
                return rtnResult;
            }
            finally
            {
                Global.writeLog("FeeUpload 出参：" + JsonHelper.Compress(rtnResult));
            }

        }

   
        /// <summary>
        /// 结算
        /// </summary>
        /// <param name="InParam"></param>
        /// <returns></returns>
        public string Settlement(string InParam)
        {
            
            Global.writeLog("Settlement 入参：" + JsonHelper.Compress(InParam));
            //设置返回值，错误信息
            string errMsg, rtnResult = "", outParam;
            try
            {
                //解析入参
                if (parseInparam(InParam, out errMsg) != 0)
                {
                    rtnResult = JsonHelper.setExceptionJson(-1, "", errMsg).ToString();
                    return rtnResult;
                }
                //BS架构调用方式问题，每次调用都需要重新初始化
                if (init(InParam, out outParam) != 0)
                {
                    rtnResult = outParam;
                    return rtnResult; 
                }
                //获取pat
                hBus.GetSettlementHisInfo(businessType, joInParam, out Global.pat);
                switch (businessType)
                {
                    case "M4"://门诊预结算
                        {
                            // 没有做任何处理？是否必须？？？
                            //OutpatientRegistration frmReg = new OutpatientRegistration();
                            //if (frmReg.ShowDialog() == DialogResult.OK)
                            //{
                            //    rtnResult = "调用结束";
                            //}
                            break;
                        }
                    case "M4C"://门诊预结算撤销
                        {
                            break;
                        }
                    case "M5"://门诊结算
                        {
                            Global.Set.clearingWay = "6"; //门诊
                            Business.OPSettlementService opService = new Business.OPSettlementService();
                            rtnResult = opService.Charge(operationType, joInParam);
                            break;
                        }
                    case "M5C"://门诊结算撤销
                        {
                            Business.OPSettlementService opService = new Business.OPSettlementService();
                            rtnResult = opService.DisCharge(joParam);
                            break;
                        }
                    case "M6"://门诊移动支付结算
                        {
                            #region 移动支付
                            MobilePay mp = new MobilePay(InParam, out errMsg);
                            if (errMsg != "")
                            {
                                rtnResult = JsonHelper.setExceptionJson(-1, "Settlement(MobilePay构造)交易", errMsg).ToString();
                                return rtnResult;
                            }
                            if (mp.MobilePaySettlement(out outParam) != 0)
                                rtnResult = JsonHelper.setExceptionJson(-1, "Settlement(MobilePaySettlement)交易", outParam).ToString();
                            else
                                rtnResult = outParam;
                            return rtnResult;
                            #endregion
                        }
                    case "M6C"://门诊移动支付结算撤销
                        {
                            #region 移动支付取消
                            string onlineYBFalg = JsonHelper.getDestValue(joInsuAdmObj, "onlineYBFalg");

                            MobilePay mp = new MobilePay(InParam, out errMsg);
                            if (errMsg != "")
                            {
                                rtnResult = JsonHelper.setExceptionJson(-1, "Settlement(MobilePay构造)交易", errMsg).ToString();
                                return rtnResult;
                            }
                            if (String.IsNullOrEmpty(onlineYBFalg))
                            {
                                mp.MSettl.onlineYBFalg = "N";
                            }
                            else
                            {
                                mp.MSettl.onlineYBFalg = onlineYBFalg;
                            }
    
                            if (mp.MobilePayCancelSettlement(out outParam) != 0)
                                rtnResult = JsonHelper.setExceptionJson(-1, "Settlement(MobilePayCancelSettlement)交易", outParam).ToString();
                            else
                                rtnResult = outParam;
                            return rtnResult;
                            #endregion
                        }
                    case "M6Confirm"://门诊移动支付确认
                        {
                            #region 移动支付确认
                            MobilePay mp = new MobilePay(InParam, out errMsg);
                            if (errMsg != "")
                            {
                                rtnResult = JsonHelper.setExceptionJson(-1, "Settlement 交易", errMsg).ToString();
                                return rtnResult;
                            }
                            if (mp.MobilePayConfirmSettlement(out outParam) != 0)
                                rtnResult = JsonHelper.setExceptionJson(-1, "Settlement 交易", outParam).ToString();
                            else
                                rtnResult = outParam;
                            return rtnResult;
                            #endregion
                        }
                    case "M6Q":
                        {
                            MobilePay mp = new MobilePay(InParam, out errMsg);
                            if (errMsg != "")
                            {
                                rtnResult = JsonHelper.setExceptionJson(-1, "Settlement 交易", errMsg).ToString();
                                return rtnResult;
                            }
                            mp.MobilePayQuery(out outParam);
                            return outParam;
                        }
                    case "M6RE":
                        {
                            MobilePay mp = new MobilePay(InParam, out errMsg);
                            if (errMsg != "")
                            {
                                rtnResult = JsonHelper.setExceptionJson(-1, "Settlement 交易", errMsg).ToString();
                                return rtnResult;
                            }
                            mp.MobilePayReSettlement(out outParam);
                            return outParam;
                        }
                    case "Z4"://住院预结算
                        {
                            #region 预结算
                            Global.pat.RYorCY = "2";
                            JObject joSettle = new JObject();
                            CallResult result = new IPPreSettlementProcess().Process(joParam);
                            if (result.Success)
                            {
                                rtnResult = JsonHelper.setExceptionJson(-1, "结算信息展示", result.Data).ToString();
                            }
                            else
                            {
                                rtnResult = JsonHelper.setIrisReturnValue(0, "预结算成功", null).ToString();
                            }
                            break;
                            #endregion
                        }
                    case "Z4C"://住院预结算撤销
                        {
                            rtnResult = JsonHelper.setExceptionJson(-100, "该接口不支持预结算取消！", null).ToString();
                            return rtnResult;
                        }
                    case "Z5"://住院结算
                        {
                            Global.Set.clearingWay = "1"; //住院
                            Business.IPSettlementService ipService = new Business.IPSettlementService();
                            rtnResult = ipService.Charge(operationType,joParam);
                            break;
                        }
                    case "Z5C"://住院结算撤销
                        {
                            Business.IPSettlementService ipService = new Business.IPSettlementService();
                            rtnResult = ipService.DisCharge(joParam);
                            break;
                        }
                    default:
                        {
                            rtnResult = JsonHelper.setExceptionJson(-1, "Settlement 交易", "传入的业务编码不对！").ToString();
                            return rtnResult;
                        }

                }
                return rtnResult;
            }
            catch (Exception ex)
            {
                rtnResult = JsonHelper.setExceptionJson(-1, "Settlement 交易", ex.Message).ToString();
                return rtnResult;
            }
            finally
            {
                Global.writeLog("Settlement 出参：" + JsonHelper.Compress(rtnResult));
            }


        }

        /// <summary>
        /// 辅助交易
        /// </summary>
        /// <param name="InParam"></param>
        /// <returns></returns>
        public string AgentFun(string InParam)
        {
            Global.writeLog("AgentFun 入参:" + JsonHelper.Compress(InParam));
            //设置返回值，错误信息
            string errMsg, rtnResult = "", outParam;
            try
            {
                //解析入参
                if (parseInparam(InParam, out errMsg) != 0)
                {
                    rtnResult = JsonHelper.setExceptionJson(-1, "", errMsg).ToString();
                    return rtnResult;
                }
                
                //BS架构调用方式问题，每次调用都需要重新初始化
                if (init(InParam, out outParam) != 0)
                {
                    Global.writeLog("初始化异常:"+outParam);
                    rtnResult = outParam;
                    // 基础数据没有初始化成功，也可以运行
                    if (!businessType.Equals("BasicData")) {
                        return rtnResult;
                    }
                    
                }
                //获取pat
                hBus.GetAgentFunHisInfo(businessType, joInParam, out Global.pat);
                switch (businessType)
                {
                    case "BasicData"://基础数据维护
                        {
                            BasicData bd = new BasicData();
                            bd.ShowDialog();
                            break;
                        }
                    case "Exception"://异常处理
                        {
                            //显示异常处理界面
                            HandleException frmEX = new HandleException();
                            if (frmEX.ShowDialog() == DialogResult.OK)
                            {

                            }
                            break;
                        }
                    case "CheckAndClearing"://对账清算
                        {
                            Clearing frmEX = new Clearing();
                            if (frmEX.ShowDialog() == DialogResult.OK)
                            {

                            }
                            break;
                        }
                    case "Print"://打印
                        {
                            printFastReport();
                            return JsonHelper.setIrisReturnValue(0, "", null).ToString();
                        }
                    case "PrescribeCirculation"://处方流转
                        {
                            STA sta = new STA();
                            Thread thread = new Thread(sta.PrescribeCirculation);
                            thread.SetApartmentState(ApartmentState.STA); //重点
                            thread.IsBackground = true;
                            thread.Start();
                            thread.Join();
                            break;
                        }
                    case "Log"://日志
                        {
                            MessageBox.Show(businessType);
                            break;
                        }
                    case "RecordUpload"://上传记录
                        {
                            MessageBox.Show(businessType);
                            break;
                        }
                    case "HospitalRegister"://备案
                        {
                            ToRecordChoose Referral = new ToRecordChoose();
                            Referral.ShowDialog();
                            break;
                        }
                    case "ToPutOnRecord"://医保备案相关
                        {
                            STA sta = new STA();
                            Thread thread = new Thread(sta.ToPutOnRecord);
                            thread.SetApartmentState(ApartmentState.STA); //重点
                            thread.IsBackground = true;
                            thread.Start();
                            thread.Join();
                            break;
                        }
                    case "PreAndInProcessAnalysis"://事前分析  诊间只有住院的事前分析
                        {
                            Global.pat.adm_Dr = int.Parse(JsonHelper.getDestValue(joInParam, "params[0].admID"));
                            JObject joResult = new JObject();

                            joResult.Add("result", JObject.Parse(JsonHelper.getDestValue(joParam, "insuData")));
                            //事前分析
                            if (Global.curEvt.ext.isOpenAnalysis)
                            {
                                if (hBus.PreAnalysis("5", joResult.ToString(), out errMsg) != 0)
                                {
                                    MessageBox.Show(errMsg);
                                    break;
                                }
                            }

                            break;
                        }
                    case "HistoryPrescriptionQuery":
                        // 历史处方查询
                        string funNo = JsonHelper.getDestValue(joInParam, "funNO");
                        TradeEnum trade = TradeEnum.DEFAULT.GetByCode(funNo);
                        new OtherQueryProcess(trade).Process(JObject.Parse(InParam));
                        break;
                    case "DualChannelRecord":
                        // 双通道备案
                        DualChannelRecordForm recordForm = new DualChannelRecordForm();
                        recordForm.ShowDialog();
                        break;
                    case "CenterQuery"://中心查询
                        {
                            STA sta = new STA();
                            Thread thread = new Thread(sta.CenterQuery);
                            thread.SetApartmentState(ApartmentState.STA); //重点
                            thread.IsBackground = true;
                            thread.Start();
                            thread.Join();
                            break;
                        }
                    default:
                        {
                            rtnResult = JsonHelper.setExceptionJson(-1, "AgentFun 交易", "传入的业务编码不对！").ToString();
                            break;
                        }
                    case "Test"://测试
                        {
                            STA sta = new STA();
                            Thread thread = new Thread(sta.Test);
                            thread.SetApartmentState(ApartmentState.STA); //重点
                            thread.IsBackground = true;
                            thread.Start();
                            thread.Join();
                            break;
                        }
                }
                return rtnResult;
            }
            catch (Exception ex)
            {
                rtnResult = JsonHelper.setExceptionJson(-1, "AgentFun 交易", ex.Message).ToString();
                return rtnResult;
            }
            finally
            {
                Global.writeLog("AgentFun 出参：" + JsonHelper.Compress(rtnResult));
            }

        }

        private void printFastReport()
        {
            SettlementChecklist frmSettlList;
            string insuAdmObj = JsonHelper.getDestValue(joInParam, "insuAdmObj");
            if (insuAdmObj == "")
            {
                frmSettlList = new SettlementChecklist();
                frmSettlList.ShowDialog();
            }
            else
            {
                JObject joInsuAdmObj = JObject.Parse(insuAdmObj);
                frmSettlList = new SettlementChecklist(joInsuAdmObj);
                string groupID = JsonHelper.getDestValue((JObject)Global.curEvt.jaSession[0], "groupID");
                DataTable dt = (DataTable)frmSettlList.dgvSettlRecord.DataSource;
                frmSettlList.btnPrint_Click(null, null);
            }
        }

        
        public string PlatformDirectConnect(string InParam)
        {            
            //设置返回值，错误信息
            string errMsg, rtnResult = "", outParam;
            try
            {
                Global.writeLog("PlatformDirectConnect 入参:" + JsonHelper.Compress(InParam));
                //解析入参
                if (parseInparam(InParam, out errMsg) != 0)
                {
                    rtnResult = JsonHelper.setExceptionJson(-1, "", errMsg).ToString();
                    return rtnResult;
                }
                
                Global.businessType = businessType;
                string funNO = JsonHelper.getDestValue(joInParam, "funNO");
                //BS架构调用方式问题，每次调用都需要重新初始化
                if (init(InParam, out outParam) != 0)
                {
                    rtnResult = outParam;
                    return rtnResult;
                }

                Global.pat.insuplc_admdvs = JsonHelper.getDestValue(joInParam, "insuplc_admdvs");

                JObject joRtn = invoker.invokeCenterAgentService(funNO, joParam);
                if (JsonHelper.parseCenterRtnValue(joRtn, out errMsg) != 0)
                {
                    rtnResult = JsonHelper.setExceptionJson(-1, "平台直连错误", errMsg).ToString();
                    return rtnResult;
                }
                else
                {
                    rtnResult = JsonHelper.setIrisReturnValue(0, "", joRtn).ToString();
                    return rtnResult;
                }
            }
            catch (Exception ex)
            {
                rtnResult = JsonHelper.setExceptionJson(-1, "PlatformDirectConnect 交易", ex.Message).ToString();
                return rtnResult;
            }
            finally
            {
                Global.writeLog("PlatformDirectConnect 出参：" + JsonHelper.Compress(rtnResult));
            }
        }

        /// <summary>
        /// 自助机
        /// </summary>
        /// <param name="InParam"></param>
        /// <returns></returns>
        public string SelfServiceMachine(string InParam)
        {
            Global.writeLog("SelfServiceMachine 入参：" + JsonHelper.Compress(InParam));
            //设置返回值，错误信息
            string errMsg, rtnResult = "", outParam;
            try
            {
                //解析入参
                if (parseInparam(InParam, out errMsg) != 0)
                {
                    rtnResult = JsonHelper.setExceptionJson(-1, "parseInparam", errMsg).ToString();
                    return rtnResult;
                }
                //获取pat
                hBus.GetSelfServiceMachineInfo(businessType, joInParam, out Global.pat);
                //BS架构调用方式问题，每次调用都需要重新初始化
                if (init(InParam, out errMsg) != 0)
                //if (hBus.InitA(InParam, out errMsg) != 0)
                {
                    rtnResult = JsonHelper.setExceptionJson(-1, "InitA", errMsg).ToString(); ;
                    return rtnResult;
                }
                else
                {
                    //joInParam.Add("patInfo", errMsg);
                    Global.writeLog($"InitA初始化成功！");
                }


                switch (businessType)
                {
                    case "GetPatientInfo"://读取患者信息，该节点无需重定向
                        {
                            Business.Core.SelfServiceMachine.PatientService patientService = new Business.Core.SelfServiceMachine.PatientService();
                            rtnResult = patientService.GetPatientInfo();
                            break;
                        }
                    case "OPReg"://门诊挂号
                        {
                            #region 链条式任务调度者
                            OPRegService service = new OPRegService();
                            rtnResult = service.Charge(operationType, joInParam);
                            break;
                            #endregion
                        }
                    case "OPSettl"://门诊结算
                        {
                            Business.Core.SelfServiceMachine.ProcessScheduler.OPSettlementService service = new Business.Core.SelfServiceMachine.ProcessScheduler.OPSettlementService();
                            rtnResult = service.Charge(operationType, joInParam);
                            break;
                        }
                    case "IPInReg"://入院登记
                        {
                            IPAdmRegService service = new IPAdmRegService();
                            rtnResult = service.Register(operationType, joInParam);
                            break;
                        }
                    case "IPInRegCancel"://入院登记
                        {
                            IPAdmRegService service = new IPAdmRegService();
                            rtnResult = service.CancelRegister(operationType, joInParam);
                            break;
                        }
                    case "IPOutReg"://出院登记
                        {
                            break;
                        }
                    case "IPUpoload"://住院费用上传
                        {
                            break;
                        }
                    case "IPPreSettl"://住院结算
                        {
                            break;
                        }
                    case "IPSettl"://住院结算
                        {
                            PTMedicalInsurance.Business.Core.SelfServiceMachine.ProcessScheduler.IPSettlementService service = new PTMedicalInsurance.Business.Core.SelfServiceMachine.ProcessScheduler.IPSettlementService();
                            rtnResult = service.Charge(joInParam);
                            return rtnResult;
                        }
                    case "DischargeAudit"://费用核查
                        {
                            DischargeAuditService service = new DischargeAuditService();
                            rtnResult = service.Audit(joInParam);
                            return rtnResult;
                        }
                    default:
                        {
                            rtnResult = JsonHelper.setExceptionJson(-1, "SelfServiceMachine 交易", "传入的业务编码不对！").ToString();
                            return rtnResult;
                        }

                }
                return rtnResult;
            }
            catch (Exception ex)
            {
                rtnResult = JsonHelper.setExceptionJson(-1, "SelfServiceMachine 交易", ex.Message).ToString();
                return rtnResult;
            }
            finally
            {
                Global.writeLog("SelfServiceMachine 出参：" + JsonHelper.Compress(rtnResult));
            }
        }

    }
}