using System.Threading;
using Muchinfo.MTPClient.Adapter.Abstract;
using Muchinfo.MTPClient.CustomException;
using Muchinfo.MTPClient.Data;
using Muchinfo.MTPClient.Data.Enums;
using Muchinfo.MTPClient.Data.Model;
using Muchinfo.MTPClient.Data.Model.Account;
using Muchinfo.MTPClient.Data.Model.GoodRules;
using Muchinfo.MTPClient.Infrastructure.Cache;
using Muchinfo.MTPClient.Infrastructure.Helpers;
using Muchinfo.MTPClient.Infrastructure.LinkProxy;
using Muchinfo.MTPClient.Infrastructure.Utilities;
using Muchinfo.MTPClient.IService;
using Muchinfo.MTPClient.NetworkCore;
using Muchinfo.MTPClient.Resources;
using Muchinfo.MTPClient.Service.Utilities;
using Muchinfo.PC.Common.Helpers;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Drawing;
using System.Linq;
using Muchinfo.MTPClient.Data.Model.Message;

namespace Muchinfo.MTPClient.Service
{
    public class LoginService : ILoginService
    {
        private readonly AccountAdapter _accountAdapter;

        public LoginService()
        {
            _accountAdapter = LinkManager.Instance.TradeAdapterFactory.CreateAccountAdapter();
        }
        /// <summary>
        /// 通知查询 MTP2.0
        /// </summary>
        /// <param name="loginID">The login identifier.</param>
        /// <param name="LastNoticeId">最后一条通知id</param>
        /// <param name="successAction">The success action.</param>
        /// <param name="errorAction">The error action.</param>
        public void NoticeQuerySearch(ulong loginID, long LastNoticeId, Action<List<NoticeMsg>> successAction, Action<ErrorEntity> errorAction)
        {
            var reqeust = _accountAdapter.ToReqeustNoticeQuery(loginID, LastNoticeId);
            var packgage = new TCPPackage() { Content = reqeust, FunCode = FuncCode.FID_NoticeQueryReq };
            LinkManager.Instance.TradeTcpLinkProxy.SendPackage(packgage, new Action<TCPPackage>((revPackgage) =>
            {
                var responeEntrity = _accountAdapter.ResponeNoticeQuery(revPackgage.Content);
                if (responeEntrity.RetCode == 0)
                {
                    //todo:本地缓存公告，赋值CacheServerLastNoticeId为最大的MSGID；
                    successAction(responeEntrity.Entity);
                }
                else
                {
                    if (errorAction != null)
                    {
                        errorAction(new ErrorEntity()
                        {
                            //RequestFunc = 通知查询 
                            ReturnCode = responeEntrity.RetCode,
                            ReturnDesc = responeEntrity.RetMessage,
                            RequestFunc = "通知查询",
                        });
                    }
                }
            }), new Action<int, string>((errorCode, errorDesc) =>
            {     ////通信错误
                if (errorAction != null)
                {
                    errorAction(new ErrorEntity() { ReturnCode = errorCode, ReturnDesc = errorDesc, RequestFunc = "通知查询" });
                }
            }));
        }
        /// <summary>
        /// 风险协议书查询 MTP2.0
        /// </summary>
        /// <param name="RiskMsgUTime">上次更新配置时间</param>
        public void RiskTipQuerySearch(ulong RiskMsgUTime, Action<RiskTipQueryRspModel, ulong> successAction, Action<ErrorEntity> errorAction)
        {
            var reqeust = _accountAdapter.ToReqeustRiskTipQueryReq(RiskMsgUTime);
            var packgage = new TCPPackage() { Content = reqeust, FunCode = FuncCode.FID_RiskTipQueryReq };
            LinkManager.Instance.TradeTcpLinkProxy.SendPackage(packgage, new Action<TCPPackage>((revPackgage) =>
            {
                var responeEntrity = _accountAdapter.ResponeRiskTipQueryReq(revPackgage.Content);
                if (responeEntrity.RetCode == 0)
                {
                    successAction(responeEntrity.Entity, RiskMsgUTime);
                }
                else
                {
                    if (errorAction != null)
                    {
                        errorAction(new ErrorEntity()
                        {
                            //RequestFunc = 风险协议书查询 
                            ReturnCode = responeEntrity.RetCode,
                            ReturnDesc = responeEntrity.RetMessage,
                            RequestFunc = "风险协议书查询",
                        });
                    }
                }
            }), new Action<int, string>((errorCode, errorDesc) =>
            {     ////通信错误
                if (errorAction != null)
                {
                    errorAction(new ErrorEntity() { ReturnCode = errorCode, ReturnDesc = errorDesc, RequestFunc = "风险协议书查询" });
                }
            }));
        }
        /// <summary>
        /// 市场运行计划查询 MTP2.0
        /// </summary>
        /// <param name="TradeDate">交易日</param>
        public void MarketRunQuerySearch(string TradeDate, Action<MarketRunQueryRspModel> successAction, Action<ErrorEntity> errorAction)
        {
            var reqeust = _accountAdapter.ToReqeustMarketRunQueryReq(TradeDate);
            var packgage = new TCPPackage() { Content = reqeust, FunCode = FuncCode.FID_MarketRunQueryReq };
            LinkManager.Instance.TradeTcpLinkProxy.SendPackage(packgage, new Action<TCPPackage>((revPackgage) =>
            {
                var responeEntrity = _accountAdapter.ResponeMarketRunQueryReq(revPackgage.Content);
                if (responeEntrity.RetCode == 0)
                {
                    successAction(responeEntrity.Entity);
                }
                else
                {
                    if (errorAction != null)
                    {
                        errorAction(new ErrorEntity()
                        {
                            //RequestFunc = 市场运行计划查询 
                            ReturnCode = responeEntrity.RetCode,
                            ReturnDesc = responeEntrity.RetMessage,
                            RequestFunc = "市场运行计划查询",
                        });
                    }
                }
            }), new Action<int, string>((errorCode, errorDesc) =>
            {     ////通信错误
                if (errorAction != null)
                {
                    errorAction(new ErrorEntity() { ReturnCode = errorCode, ReturnDesc = errorDesc, RequestFunc = "市场运行计划查询" });
                }
            }));
        }
        /// <summary>
        /// 市场查询 MTP2.0
        /// </summary>
        /// <param name="MarketsUTime">上次更新配置时间</param>
        public void MarketsQuerySearch(ulong MarketsUTime, Action<List<MarketsInfoModel>, ulong, bool> successAction, Action<ErrorEntity> errorAction)
        {
            var reqeust = _accountAdapter.ToReqeustMarketsQueryReq(MarketsUTime);
            var packgage = new TCPPackage() { Content = reqeust, FunCode = FuncCode.FID_MarketsQueryReq };
            LinkManager.Instance.TradeTcpLinkProxy.SendPackage(packgage, new Action<TCPPackage>((revPackgage) =>
            {
                var responeEntrity = _accountAdapter.ResponeMarketsQueryReq(revPackgage.Content);
                if (responeEntrity.RetCode == 0)
                {
                    ///缓存市场信息
                    CacheManager.LoadMarketInfoList(responeEntrity.Entity);
                    successAction(responeEntrity.Entity, MarketsUTime, true);
                }
                else
                {
                    if (errorAction != null)
                    {
                        errorAction(new ErrorEntity()
                        {
                            //RequestFunc = 市场查询 
                            ReturnCode = responeEntrity.RetCode,
                            ReturnDesc = responeEntrity.RetMessage,
                            RequestFunc = "市场查询",
                        });
                    }
                }
            }), new Action<int, string>((errorCode, errorDesc) =>
            {     ////通信错误
                if (errorAction != null)
                {
                    errorAction(new ErrorEntity() { ReturnCode = errorCode, ReturnDesc = errorDesc, RequestFunc = "市场查询" });
                }
            }));
        }
        /// <summary>
        /// 枚举常量字典查询 MTP2.0
        /// </summary>
        /// <param name="DirctionaryUTime">上次更新配置时间</param>
        public void DictionaryQuerySearch(ulong DictionaryUTime, Action<List<DictionaryInfoModel>, ulong> successAction, Action<ErrorEntity> errorAction)
        {
            var reqeust = _accountAdapter.ToReqeustDictionaryQueryReq(DictionaryUTime);
            var packgage = new TCPPackage() { Content = reqeust, FunCode = FuncCode.FID_DictionaryQueryReq };
            LinkManager.Instance.TradeTcpLinkProxy.SendPackage(packgage, new Action<TCPPackage>((revPackgage) =>
            {
                var responeEntrity = _accountAdapter.ResponeDictionaryQueryReq(revPackgage.Content);
                if (responeEntrity.RetCode == 0)
                {
                    successAction(responeEntrity.Entity, DictionaryUTime);
                }
                else
                {
                    if (errorAction != null)
                    {
                        errorAction(new ErrorEntity()
                        {
                            //RequestFunc = 枚举常量字典查询 
                            ReturnCode = responeEntrity.RetCode,
                            ReturnDesc = responeEntrity.RetMessage,
                            RequestFunc = "枚举常量字典查询",
                        });
                    }
                }
            }), new Action<int, string>((errorCode, errorDesc) =>
            {     ////通信错误
                if (errorAction != null)
                {
                    errorAction(new ErrorEntity() { ReturnCode = errorCode, ReturnDesc = errorDesc, RequestFunc = "枚举常量字典查询" });
                }
            }));
        }
        /// <summary>
        /// 错误码字典查询 MTP2.0
        /// </summary>
        /// <param name="ConfigUTime">上次更新配置时间</param>
        public void ErrorCodeQuerySearch(ulong ErrorcodeUTime, Action<List<ErrorCodeInfoModel>, ulong> successAction, Action<ErrorEntity> errorAction)
        {
            var reqeust = _accountAdapter.ToReqeustErrorCodeQueryReq(ErrorcodeUTime);
            var packgage = new TCPPackage() { Content = reqeust, FunCode = FuncCode.FID_ErrorCodeQueryReq };
            LinkManager.Instance.TradeTcpLinkProxy.SendPackage(packgage, new Action<TCPPackage>((revPackgage) =>
            {
                var responeEntrity = _accountAdapter.ResponeErrorCodeQueryReq(revPackgage.Content);
                if (responeEntrity.RetCode == 0)
                {
                    successAction(responeEntrity.Entity, ErrorcodeUTime);
                }
                else
                {
                    if (errorAction != null)
                    {
                        errorAction(new ErrorEntity()
                        {
                            //RequestFunc = 错误码字典查询 
                            ReturnCode = responeEntrity.RetCode,
                            ReturnDesc = responeEntrity.RetMessage,
                            RequestFunc = "错误码字典查询",
                        });
                    }
                }
            }), new Action<int, string>((errorCode, errorDesc) =>
            {     ////通信错误
                if (errorAction != null)
                {
                    errorAction(new ErrorEntity() { ReturnCode = errorCode, ReturnDesc = errorDesc, RequestFunc = "错误码字典查询" });
                }
            }));
        }

        /// <summary>
        /// 终端系统参数查询 MTP2.0
        /// </summary>
        /// <param name="ConfigUTime">配置时间</param>
        public void ConfigQuerySearch(ulong ConfigUTime, Action<List<ConfigInfoModel>, ulong, bool> successAction, Action<ErrorEntity> errorAction)
        {
            var reqeust = _accountAdapter.ToReqeustConfigQueryReq(ConfigUTime);
            var packgage = new TCPPackage() { Content = reqeust, FunCode = FuncCode.FID_ConfigQueryReq };
            LinkManager.Instance.TradeTcpLinkProxy.SendPackage(packgage, new Action<TCPPackage>((revPackgage) =>
            {
                var responeEntrity = _accountAdapter.ResponeConfigQueryReq(revPackgage.Content);
                if (responeEntrity.RetCode == 0)
                {
                    SetApplicationParameters(responeEntrity.Entity);  ////设置系统参数

                    ////设置系统参数 - mtp2.0
                    SystemParamManager.ParamConfigs = responeEntrity.Entity;
                    UserManager.CurrentTradeAccount.RiskRatioCalcMode = SystemParamManager.RiskRatioCalcMode;
                    //更新系统参数浮动盈利是否可用
                    if (UserManager.CurrentTradeAccount.FundsAccounts != null)
                    {
                        foreach (var fundsAccount in UserManager.CurrentTradeAccount.FundsAccounts)
                        {
                            fundsAccount.FloatAvaliabelFlag = SystemParamManager.IsFloatPLAvaliabled;
                        }
                    }
                    successAction(responeEntrity.Entity, ConfigUTime, true);
                }
                else
                {
                    if (errorAction != null)
                    {
                        errorAction(new ErrorEntity()
                        {
                            //RequestFunc = 终端系统参数查询 
                            ReturnCode = responeEntrity.RetCode,
                            ReturnDesc = responeEntrity.RetMessage,
                            RequestFunc = "终端系统参数查询",
                        });
                    }
                }
            }), new Action<int, string>((errorCode, errorDesc) =>
            {     ////通信错误
                if (errorAction != null)
                {
                    errorAction(new ErrorEntity() { ReturnCode = errorCode, ReturnDesc = errorDesc, RequestFunc = "终端系统参数查询" });
                }
            }));
        }

        public void DeliveryGoodsQuerySearch(ulong DeliveryGoodsUTime, Action<List<DeliveryGoodsInfoModel>, ulong, bool> successAction, Action<ErrorEntity> errorAction)
        {
            var reqeust = _accountAdapter.ToReqeustDeliveryGoodsReq(DeliveryGoodsUTime);
            var packgage = new TCPPackage() { Content = reqeust, FunCode = FuncCode.FID_DeliveryGoodsQueryReq };
            LinkManager.Instance.TradeTcpLinkProxy.SendPackage(packgage, new Action<TCPPackage>((revPackgage) =>
            {
                var responeEntrity = _accountAdapter.ResponeDeliveryGoodsReq(revPackgage.Content);
                if (responeEntrity.RetCode == 0)
                {
                    successAction(responeEntrity.Entity, DeliveryGoodsUTime, true);
                }
                else
                {
                    if (errorAction != null)
                    {
                        errorAction(new ErrorEntity()
                        {
                            //RequestFunc = 终端系统参数查询 
                            ReturnCode = responeEntrity.RetCode,
                            ReturnDesc = responeEntrity.RetMessage,
                            RequestFunc = "终端交割商品查询",
                        });
                    }
                }
            }), new Action<int, string>((errorCode, errorDesc) =>
            {     ////通信错误
                if (errorAction != null)
                {
                    errorAction(new ErrorEntity() { ReturnCode = errorCode, ReturnDesc = errorDesc, RequestFunc = "终端交割商品查询" });
                }
            }));
        }
        /// <summary>
        /// 商品查询请求 MTP2.0
        /// </summary>
        /// <param name="GoodsUTime">商品更新时间</param>
        public void GoodsInfoSearch(ulong GoodsUTime, List<TradeGoodsFeeRule> midParam, Action<List<QuoteGoods>, ulong, bool, List<TradeGoodsFeeRule>> successAction, Action<ErrorEntity> errorAction)
        {
            var reqeust = _accountAdapter.ToReqeustGoodsQueryReq(GoodsUTime);
            var packgage = new TCPPackage() { Content = reqeust, FunCode = FuncCode.FID_GoodsQueryReq };
            LinkManager.Instance.TradeTcpLinkProxy.SendPackage(packgage, new Action<TCPPackage>((revPackgage) =>
            {
                var responeEntrity = _accountAdapter.ResponeGoodsQueryReq(revPackgage.Content);
                if (responeEntrity.RetCode == 0)
                {

                    CacheManager.LoadGoodsInfoList(responeEntrity.Entity == null ? new List<QuoteGoods>() : responeEntrity.Entity.OrderBy(z => z.GoodsCode).ToList(), GoodsFromScr.Trade);
                    successAction(responeEntrity.Entity, GoodsUTime, true, midParam);
                }
                else
                {
                    if (errorAction != null)
                    {
                        errorAction(new ErrorEntity()
                        {
                            //RequestFunc = 商品查询请求 
                            ReturnCode = responeEntrity.RetCode,
                            ReturnDesc = responeEntrity.RetMessage,
                            RequestFunc = "商品查询请求",
                        });
                    }
                }
            }), new Action<int, string>((errorCode, errorDesc) =>
            {     ////通信错误
                if (errorAction != null)
                {
                    errorAction(new ErrorEntity() { ReturnCode = errorCode, ReturnDesc = errorDesc, RequestFunc = "商品查询请求" });
                }
            }));
        }


        /// <summary>
        /// 获取最后更新时间 MTP2.0
        /// </summary>
        /// <param name="parameterAction">成功回调</param>
        /// <param name="errorAction">失败回应</param>
        public void LastUpdateTimeSearch(Action<LastUpdateTimeModel> successAction, Action<ErrorEntity> errorAction)
        {
            var reqeust = _accountAdapter.ToReqeustLastUpdateTimeReq();
            var packgage = new TCPPackage() { Content = reqeust, FunCode = FuncCode.FID_LastUpdateTimeReq };
            LinkManager.Instance.TradeTcpLinkProxy.SendPackage(packgage, new Action<TCPPackage>((revPackgage) =>
            {
                var responeEntrity = _accountAdapter.ResponeLastUpdateTimeReq(revPackgage.Content);
                if (responeEntrity.RetCode == 0)
                {
                    successAction(responeEntrity.Entity);
                }
                else
                {
                    if (errorAction != null)
                    {
                        errorAction(new ErrorEntity()
                        {
                            //RequestFunc = 获取最后更新时间 
                            ReturnCode = responeEntrity.RetCode,
                            ReturnDesc = responeEntrity.RetMessage,
                            RequestFunc = "获取最后更新时间",
                        });
                    }
                }
            }), new Action<int, string>((errorCode, errorDesc) =>
            {     ////通信错误
                if (errorAction != null)
                {
                    errorAction(new ErrorEntity() { ReturnCode = errorCode, ReturnDesc = errorDesc, RequestFunc = "获取最后更新时间" });
                }
            }));
        }
        /// <summary>
        /// 获取功能菜单
        /// </summary>
        /// <param name="MenuUTime"></param>
        /// <param name="successAction"></param>
        /// <param name="errorAction"></param>
        public void QueryAccountFuncMenu(ulong MenuUTime, List<TradeGoodsFeeRule> GoodsRuleLst, Action<List<SysMenuItem>, ulong, List<TradeGoodsFeeRule>, bool> successAction, Action<ErrorEntity> errorAction)
        {
            var reqeust = _accountAdapter.ToReqeustFuncMenuQueryReq(MenuUTime);
            var packgage = new TCPPackage() { Content = reqeust, FunCode = FuncCode.FID_FuncMenuReq };
            LinkManager.Instance.TradeTcpLinkProxy.SendPackage(packgage, new Action<TCPPackage>((revPackgage) =>
            {
                var responeEntrity = _accountAdapter.ResponeLocalFuncMenu(revPackgage.Content);
                if (responeEntrity.RetCode == 0)
                {
                    successAction(responeEntrity.Entity, MenuUTime, GoodsRuleLst, true);
                }
                else
                {
                    if (errorAction != null)
                    {
                        errorAction(new ErrorEntity()
                        {
                            ReturnCode = responeEntrity.RetCode,
                            ReturnDesc = responeEntrity.RetMessage,
                            RequestFunc = "菜单查询请求",
                        });
                    }
                }
            }), new Action<int, string>((errorCode, errorDesc) =>
            {     ////通信错误
                if (errorAction != null)
                {
                    errorAction(new ErrorEntity() { ReturnCode = errorCode, ReturnDesc = errorDesc, RequestFunc = "菜单查询请求" });
                }
            }));
        }

        /// <summary>
        /// 登录查询/基本信息【打包】查询 MTP2.0
        /// 【账户信息 资金账户信息 实物持仓列表 持仓头寸列表 商品交易规则和费用规则列表 市场权限列表 菜单权限列表】
        /// </summary>
        /// <param name="accountId">交易账号</param>
        /// <param name="parameterAction">成功回调</param>
        /// <param name="errorAction">失败回应</param>
        public void LoginQuerySearch(ulong loginID, LoginQueryType queryType, Action<AccountBaseInfoModel> successAction, Action<ErrorEntity> errorAction)
        {
            var reqeust = _accountAdapter.ToReqeustLoginQueryReq(loginID, ((int)queryType).ToString());
            var packgage = new TCPPackage() { Content = reqeust, FunCode = FuncCode.FID_LoginQueryReq };
            LinkManager.Instance.TradeTcpLinkProxy.SendPackage(packgage, new Action<TCPPackage>((revPackgage) =>
            {
                var responeEntrity = _accountAdapter.ResponeLoginQueryReq(revPackgage.Content);
                if (responeEntrity.RetCode == 0)
                {

                    if (queryType == LoginQueryType.All || queryType == LoginQueryType.TAAccountList)
                    {
                        if (responeEntrity.Entity.TradeAccount != null)
                        {
                            responeEntrity.Entity.TradeAccount.Token = UserManager.CurrentTradeAccount.Token;
                            responeEntrity.Entity.TradeAccount.AreaId = UserManager.CurrentTradeAccount.AreaId;
                            responeEntrity.Entity.TradeAccount.AccountType = UserManager.CurrentTradeAccount.AccountType;
                            responeEntrity.Entity.TradeAccount.SystemTime = UserManager.CurrentTradeAccount.SystemTime;
                            responeEntrity.Entity.TradeAccount.AccountStatus = UserManager.CurrentTradeAccount.AccountStatus;
                            responeEntrity.Entity.TradeAccount.MemberAreaId = UserManager.CurrentTradeAccount.MemberAreaId;
                            responeEntrity.Entity.TradeAccount.Md5Password = UserManager.CurrentTradeAccount.Md5Password;
                            responeEntrity.Entity.TradeAccount.LoginID = UserManager.CurrentTradeAccount.LoginID;
                            responeEntrity.Entity.TradeAccount.HasUpdatedPwd = UserManager.CurrentTradeAccount.HasUpdatedPwd;
                            responeEntrity.Entity.TradeAccount.PwdWrongCnt = UserManager.CurrentTradeAccount.PwdWrongCnt;
                            responeEntrity.Entity.TradeAccount.LoginLockHourNum = UserManager.CurrentTradeAccount.LoginLockHourNum;
                            responeEntrity.Entity.TradeAccount.RiskRatioCalcMode = UserManager.CurrentTradeAccount.RiskRatioCalcMode;

                            responeEntrity.Entity.TradeAccount.ClientId = UserManager.CurrentTradeAccount.ClientId;
                            responeEntrity.Entity.TradeAccount.ClientSystemInfo =
                                UserManager.CurrentTradeAccount.ClientSystemInfo;

                        }
                        //资金信息单独查询
                        if (responeEntrity.Entity.TAAccountList != null && responeEntrity.Entity.TAAccountList.Any())
                        {
                            responeEntrity.Entity.TradeAccount.FundsAccounts = new ObservableCollection<FundsAccount>(responeEntrity.Entity.TAAccountList.Select(x => x.FundsAccounts).ToList());
                            responeEntrity.Entity.TradeAccount.FundsAccountIds = new List<ulong>(responeEntrity.Entity.TAAccountList.Select(x => x.FundsAccounts.AccountId).ToList());
                            responeEntrity.Entity.TradeAccount.FundsAccountId = responeEntrity.Entity.TradeAccount.FundsAccountIds[0];
                            responeEntrity.Entity.TradeAccount.AccountId = responeEntrity.Entity.TradeAccount.FundsAccountIds[0];

                            //更新所属交易账号
                            foreach (var fundsAccount in responeEntrity.Entity.TradeAccount.FundsAccounts)
                            {
                                fundsAccount.TradeAccount = UserManager.CurrentTradeAccount;

                                //更新系统参数浮动盈利是否可用
                                fundsAccount.FloatAvaliabelFlag = SystemParamManager.IsFloatPLAvaliabled;
                            }
                        }

                    }

                    //缓存登陆后基本信息
                    CacheManager.LoadLoginBaseInfo(responeEntrity.Entity);

                    //更新当前账户信息
                    UserManager.CurrentTradeAccount = responeEntrity.Entity.TradeAccount;

                    successAction(responeEntrity.Entity);
                }
                else
                {
                    if (errorAction != null)
                    {
                        errorAction(new ErrorEntity()
                        {
                            //RequestFunc = 登录查询 
                            ReturnCode = responeEntrity.RetCode,
                            ReturnDesc = responeEntrity.RetMessage,
                            RequestFunc = "登录查询",
                        });
                    }
                }
            }), new Action<int, string>((errorCode, errorDesc) =>
            {     ////通信错误
                
                if (errorAction != null)
                {
                    errorAction(new ErrorEntity() { ReturnCode = errorCode, ReturnDesc = errorDesc, RequestFunc = "登录查询" });
                }
            }));
        }
        //=====================================================MTP2.0 NEW ABOVE===============================================================================
        /// <summary>
        /// 认证账号登录
        /// </summary>
        /// <param name="loginType">登录类型</param>
        /// <param name="loginID">登录账号</param>
        /// <param name="phoneUserName">手机号</param>
        /// <param name="password">The password.</param>
        /// <param name="action">The action.</param>
        /// <param name="errorAction">The error action.</param>
        /// <returns>返回码：0为成功，其它为失败</returns>
        public void TradeAccountLogin(LoginType loginType, ulong loginID, string phoneUserName, string password, Action<TradeAccount> action, Action<ErrorEntity> errorAction)
        {
            var appId = "muchinfo_mtpclient_5.0.1";
            var reqeust = _accountAdapter.ToReqeustLogin((int)loginType, password, loginID, ApplicationParameter.LoginGuid, IPHelper.GetMACAddress(), string.Empty, ApplicationParameter.Version, new byte[128], appId);
            LogInfoHelper.WriteInfo("登陆请求ToString：" + System.Text.Encoding.UTF8.GetString(reqeust) + "Guid.NewGuid():" + Guid.NewGuid());
            var packgage = new TCPPackage() { Content = reqeust, FunCode = FuncCode.FID_LoginReq };

            LinkManager.Instance.TradeTcpLinkProxy.SendPackage(packgage, new Action<TCPPackage>((revPackgage) =>
            {
                var responeEntity = _accountAdapter.ToLocalLoginEntity(revPackgage.Content);
                if (responeEntity.RetCode == 0)
                {
                    responeEntity.Entity.Md5Password = password;
                    responeEntity.Entity.LoginID = loginID;

                    //更新当前账户
                    UserManager.CurrentTradeAccount = responeEntity.Entity;

                    if (action != null)
                    {
                        action(responeEntity.Entity);
                    }
                }
                else
                {
                    if (errorAction != null)
                    {
                        errorAction(new ErrorEntity()
                        {
                            //RequestFunc = string.Format("查询结算信息({0})" Client_Resource.Resources_Service_RequestTradeAccountLogin
                            ReturnCode = responeEntity.RetCode,
                            ReturnDesc = responeEntity.RetMessage,
                            RequestFunc = Client_Resource.LoginService_Login_FuntionName,
                        });
                    }
                }
            }), new Action<int, string>((errorCode, errorDesc) =>
            {
                ////通信错误
                if (errorAction != null)
                {
                    errorAction(new ErrorEntity() { ReturnCode = errorCode, ReturnDesc = errorDesc, RequestFunc = Client_Resource.LoginService_Login_FuntionName });
                }
            }));
        }


        public void TradeAccountLogout(TradeAccount tradeAccount)
        {
            var reqeust = _accountAdapter.ToReqeustLogOut(tradeAccount.LoginID);
            var packgage = new TCPPackage() { Content = reqeust, FunCode = FuncCode.FID_LogoutReq };
            LinkManager.Instance.TradeTcpLinkProxy.SendPackage(packgage, new Action<TCPPackage>((revPackgage) =>
            {

            }), new Action<int, string>((errorCode, errorDesc) =>
            {

            }));

        }

        public EntityResult<AccountPwds> ModifyPasswords(AccountPwds aPwds)
        {
            throw new NotImplementedException();
        }

        public void UpdateAccountAmount(TradeAccount tradeAccount)
        {
            //todo:
        }

        public void AccountRiskRate(TradeAccount tradeAccount)
        {
            throw new NotImplementedException();
        }

        public void QueryBankRate(string loginCode)
        {
            throw new NotImplementedException();
        }

        public void UpdateTaAccount(TradeAccount tradeAccount)
        {
            throw new NotImplementedException();
        }

        public void SetServerTimeOut(string loginCode)
        {

        }

        /// <summary>
        /// 账号基本信息查询（账号信息，资金信息，交易所信息，市场信息，商品)
        /// </summary>
        /// <param name="accountId">The account identifier.</param>
        /// <param name="successAction">The success action.</param>
        /// <param name="errorAction">The error action.</param>
        public void AccountBaseInfoInit(ulong accountId, Action<AccountInfoEntity> successAction, Action<ErrorEntity> errorAction)
        {
            var reqeust = _accountAdapter.ToReqeustAccountInfo(accountId);
            var packgage = new TCPPackage() { Content = reqeust, FunCode = FuncCode.FID_AccountFundInfoReq };
            LinkManager.Instance.TradeTcpLinkProxy.SendPackage(packgage, new Action<TCPPackage>((revPackgage) =>
            {
                var responeEntrity = _accountAdapter.TolocalAccountInfoEntity(revPackgage.Content);
                if (responeEntrity.RetCode == 0)
                {

                    CacheManager.LoadGoodsBaseInfo(responeEntrity.Entity);
                    if (responeEntrity.Entity.TradeAccount != null)
                    {
                        responeEntrity.Entity.TradeAccount.Token = UserManager.CurrentTradeAccount.Token;
                        responeEntrity.Entity.TradeAccount.AccountStatus = UserManager.CurrentTradeAccount.AccountStatus;
                        responeEntrity.Entity.TradeAccount.MemberAreaId = UserManager.CurrentTradeAccount.MemberAreaId;
                        responeEntrity.Entity.TradeAccount.Md5Password = UserManager.CurrentTradeAccount.Md5Password;
                        responeEntrity.Entity.TradeAccount.LoginID = UserManager.CurrentTradeAccount.LoginID;

                        ////登录的Token
                        UserManager.CurrentTradeAccount = responeEntrity.Entity.TradeAccount;

                    }
                    //资金信息单独查询
                    if (responeEntrity.Entity.FundsAccounts != null && responeEntrity.Entity.FundsAccounts.Any())
                    {
                        foreach (var fundsAccount in responeEntrity.Entity.FundsAccounts)
                        {
                            ////显示账号的状态
                            fundsAccount.TradeAccount = UserManager.CurrentTradeAccount;
                        }
                    }
                    ////刷新商品时解决合约单位不显示问题
                    if (Muchinfo.MTPClient.Infrastructure.Cache.CacheManager.TradeGoodsUnit != null)
                    {
                        foreach (var quoteGoods in CacheManager.CacheGoodsBaseInfos)
                        {
                            quoteGoods.AgreeUnitDisplay = quoteGoods.GoodsParameters.AgreeUnit.ToString() +
                                                          CacheManager.TradeGoodsUnit.Where(
                                                              x =>
                                                                  x.UNITID ==
                                                                  quoteGoods.GoodsParameters.AgreeUnitType)
                                                              .Select(x => x.GOODSUNITNAME)
                                                              .FirstOrDefault();
                        }
                    }
                    UserManager.CurrentTradeAccount.FundsAccounts =
                        new ObservableCollection<FundsAccount>(responeEntrity.Entity.FundsAccounts);
                    successAction(responeEntrity.Entity);



                }
                else
                {
                    if (errorAction != null)
                    {
                        errorAction(new ErrorEntity()
                        {
                            //RequestFunc = 账号基本信息查询 
                            ReturnCode = responeEntrity.RetCode,
                            ReturnDesc = responeEntrity.RetMessage,
                            RequestFunc = Client_Resource.Resources_Service_QueryAccountBaseInfo
                        });
                    }
                }
            }), new Action<int, string>((errorCode, errorDesc) =>
            {     ////通信错误
                if (errorAction != null)
                {
                    errorAction(new ErrorEntity() { ReturnCode = errorCode, ReturnDesc = errorDesc, RequestFunc = Client_Resource.Resources_Service_QueryAccountBaseInfo });
                }
            }));
        }

        /// <summary>
        /// 判断当前Token是否有有效的方法
        /// 内容处理逻辑：
        /// 1、如果当前Token有效，则在方法内部会自动进行静默登录；
        /// 2、如果当前Token已失效，则直接返回失效状态。
        /// </summary>
        /// <param name="action">请求成功回调，将包含Token状态信息</param>
        /// <param name="errorAction">请求失败回调</param>
        public void TokenCheck(Action<int> action, Action<ErrorEntity> errorAction)
        {
            if (null == UserManager.CurrentTradeAccount || null == UserManager.CurrentTradeAccount.Token)
            {
                //if (null != errorAction)
                //    // warning:错误码需要添加
                //    errorAction(new ErrorEntity() { ReturnCode = -1, ReturnDesc = "当前Token为空。" });
                return;
            }
            var timeSpan = ApplicationParameter.ServerTimeNow - ApplicationParameter.BasicDateTime;
            var request = _accountAdapter.ToTokenCheck(UserManager.CurrentTradeAccount.LoginID, UserManager.CurrentTradeAccount.Token, (ulong)timeSpan.TotalMilliseconds);
            var package = new TCPPackage() { Content = request, FunCode = FuncCode.FID_TokenCheckReq };
            LinkManager.Instance.TradeTcpLinkProxy.SendPackage(package, new Action<TCPPackage>((responsePackage) =>
            {
                ResponeEntity<ulong> responeEntity = _accountAdapter.GetTokenStatus(responsePackage.Content);
                if (responeEntity.RetCode == 0)   // Check登录
                {
                    ApplicationParameter.SetSystemTime(responeEntity.Entity); //重新连接设置时间
                    if (action != null)
                    {
                        action(responeEntity.RetCode);
                    }
                }
                else
                {
                    // 服务端返回操作失败
                    if (null != errorAction) errorAction(new ErrorEntity() { ReturnCode = responeEntity.RetCode, ReturnDesc = responeEntity.RetMessage, RequestFunc = Client_Resource.LoginService_CheckedToken_funcName });
                    LogInfoHelper.WriteInfo(string.Format("令牌校检失败,错误代码：{0}({1})", responeEntity.RetCode, responeEntity.RetMessage));
                }
            }), new Action<int, string>((errorCode, errorDesc) =>
            {
                // 发送信息失败
                if (errorAction != null)
                {
                    errorAction(new ErrorEntity() { ReturnCode = errorCode, ReturnDesc = errorDesc, RequestFunc = Client_Resource.LoginService_CheckedToken_funcName });
                }
                LogInfoHelper.WriteInfo(string.Format("令牌校检失败,错误代码：{0}({1})", errorCode, errorDesc));
            }));
        }

        /// <summary>
        /// 查询交易端的系统参数
        /// </summary>
        /// <param name="parameterAction">成功调用</param>
        /// <param name="errorAction"></param>
        public void SystemClientParamterConfig(Action<List<ParameterConfig>> parameterAction,
            Action<ErrorEntity> errorAction)
        {

            var queryCommonParams = new List<QueryCommonParam>();
            //参数2，PC交易端
            queryCommonParams.Add(new QueryCommonParam() { ParamKey = "type", ParamValue = 2 + string.Empty });

            QueryCommonHelper.QueryCommon(QueryStatement.QueryParamConfig, queryCommonParams, new Action<List<ParameterConfig>>(
                (parameterConfigs) =>
                {

                    //SetApplicationParameters(parameterConfigs);  ////设置系统参数

                    if (parameterAction != null)
                    {
                        parameterAction(parameterConfigs);
                    }

                }), (errorEntity) =>
                {
                    errorEntity.RequestFunc = Client_Resource.Client_ParamterConfig;
                    if (errorAction != null) errorAction(errorEntity);
                });
        }


        /// <summary>
        /// 查询交易端的系统参数
        /// </summary>
        /// <param name="parameterAction">成功调用</param>
        /// <param name="errorAction"></param>
        public void SystemClientParamterConfigByID(string paramid, Action<List<ParameterConfig>> parameterAction,
            Action<ErrorEntity> errorAction)
        {
            var queryCommonParams = new List<QueryCommonParam>();

            queryCommonParams.Add(new QueryCommonParam() { ParamKey = "ParamID", ParamValue = paramid });
            QueryCommonHelper.QueryCommon(QueryStatement.QueryParamConfig, queryCommonParams, new Action<List<ParameterConfig>>(
                (parameterConfigs) =>
                {
                    if (parameterAction != null)
                    {
                        parameterAction(parameterConfigs);
                    }

                }), (errorEntity) =>
                {
                    errorEntity.RequestFunc = Client_Resource.Client_ParamterConfig + paramid;
                    if (errorAction != null) errorAction(errorEntity);
                });
        }

        /// <summary>
        /// 设置程序参数 
        /// </summary>
        /// <param name="parameterConfigs">查询的参数</param>
        private void SetApplicationParameters(List<ConfigInfoModel> parameterConfigs)
        {
            try
            {
                if (parameterConfigs != null && parameterConfigs.Count > 0)
                {
                    Type t = typeof(ApplicationParameter);

                    var properties = t.GetProperties().Where((item) => item.CanWrite);

                    foreach (var propertyInfo in properties)
                    {
                        var parameter =
                            parameterConfigs.Where(u => !string.IsNullOrEmpty(u.ParamName) && u.ParamName.Trim().ToLower().Equals(propertyInfo.Name.Trim().ToLower())).ToList();

                        if (parameter != null && parameter.Count > 0)
                        {
                            var finacingModel = parameter[0];
                            if (propertyInfo.PropertyType == typeof(String))
                            {
                                propertyInfo.SetValue(t, finacingModel.ParamValue, null);
                            }
                            else if (propertyInfo.PropertyType == typeof(Int32))
                            {
                                propertyInfo.SetValue(t, Convert.ToInt32(finacingModel.ParamValue), null);
                            }
                            else if (propertyInfo.PropertyType == typeof(DateTime))
                            {
                                propertyInfo.SetValue(t, Convert.ToDateTime(finacingModel.ParamValue), null);
                            }
                            else if (propertyInfo.PropertyType == typeof(Decimal))
                            {
                                propertyInfo.SetValue(t, Convert.ToDecimal(finacingModel.ParamValue), null);
                            }
                            else if (propertyInfo.PropertyType == typeof(Boolean))
                            {
                                propertyInfo.SetValue(t, Convert.ToBoolean(finacingModel.ParamValue), null);
                            }
                        }
                    }
                }
            }
            catch (Exception ex)
            {

                ////写错误日志
                LogHelper.WriteError(typeof(Exception), ex.ToString());
            }
        }

        /// <summary>
        /// 查询资金信息
        /// </summary>
        /// <param name="successAction"></param>
        /// <param name="errorAction"></param>
        public void QueryTaAccount(ulong accountid, Action<List<FundsAccount>> successAction, Action<ErrorEntity> errorAction)
        {
            List<QueryCommonParam> queryCommonParams = new List<QueryCommonParam>();
            queryCommonParams.Add(new QueryCommonParam() { ParamKey = "accountId", ParamValue = accountid + string.Empty });
            QueryCommonHelper.QueryCommon(QueryStatement.QueryTaAccount, queryCommonParams, new Action<List<FundsAccount>>((fundsAccounts) =>
            {
                foreach (var fundsAccount in fundsAccounts)
                {
                    ////显示账号的状态
                    fundsAccount.TradeAccount = UserManager.CurrentTradeAccount;
                }
                UserManager.CurrentTradeAccount.FundsAccounts = new ObservableCollection<FundsAccount>(fundsAccounts);
                if (successAction != null)
                {
                    successAction(fundsAccounts);
                }

            }), (error) =>
            {
                //RequestFunc = 查询资金信息 
                error.RequestFunc = Client_Resource.Resources_Service_QueryTaAccount;
                if (errorAction != null) errorAction(error);
            });
        }

        /// <summary>
        /// 修改账号相关密码
        /// </summary>
        /// <param name="pwds">密码对象</param>
        /// <param name="successAction">成功回应</param>
        /// <param name="errorAction">失败回应</param>
        public void ModifyPasswords(AccountPwds pwds, Action<bool> successAction, Action<ErrorEntity> errorAction)
        {
            var reqeust = _accountAdapter.ToReqeustModifyPwds(pwds);
            var packgage = new TCPPackage() { Content = reqeust, FunCode = FuncCode.FID_ModifyPwdReq };
            LinkManager.Instance.TradeTcpLinkProxy.SendPackage(packgage, new Action<TCPPackage>((revPackgage) =>
            {
                var responeEntrity = _accountAdapter.ResponeModifyPWDEntity(revPackgage.Content);
                if (responeEntrity.RetCode == 0)
                {
                    successAction(true);
                }
                else
                {
                    if (errorAction != null)
                    {
                        errorAction(new ErrorEntity()
                        {
                            //RequestFunc = 修改账号相关密码 
                            ReturnCode = responeEntrity.RetCode,
                            ReturnDesc = responeEntrity.RetMessage,
                            RequestFunc = Client_Resource.Resources_Service_ModifyPasswords,
                        });
                    }
                }
            }), new Action<int, string>((errorCode, errorDesc) =>
            {     ////通信错误
                if (errorAction != null)
                {
                    errorAction(new ErrorEntity() { ReturnCode = errorCode, ReturnDesc = errorDesc, RequestFunc = Client_Resource.Resources_Service_ModifyPasswords });
                }
            }));
        }


        /// <summary>
        /// 查询交易端配置的菜单
        /// </summary>
        /// <param name="loginCode">登录账号</param>
        /// <param name="successAction">成功回调</param>
        /// <param name="errorAction">失败回应</param>
        public void QueryAccountFuncMenu(string loginCode, Action<List<SysMenuItem>> successAction, Action<ErrorEntity> errorAction)
        {
            return;

            //var reqeust = _accountAdapter.ToReqeustFuncMenu(loginCode);
            //var packgage = new TCPPackage() { Content = reqeust, FunCode = FuncCode.FID_QueryAccountFuncMenuReq };
            //LinkManager.Instance.TradeTcpLinkProxy.SendPackage(packgage, new Action<TCPPackage>((revPackgage) =>
            //{
            //    var responeEntrity = _accountAdapter.ResponeLocalFuncMenu(revPackgage.Content);
            //    if (responeEntrity.RetCode == 0)
            //    {
            //        successAction(responeEntrity.Entity);
            //    }
            //    else
            //    {
            //        if (errorAction != null)
            //        {
            //            errorAction(new ErrorEntity()
            //            {
            //                //RequestFunc = 查询交易端配置的菜单 
            //                ReturnCode = responeEntrity.RetCode,
            //                ReturnDesc = responeEntrity.RetMessage,
            //                RequestFunc = Client_Resource.Resources_Service_QueryAccountFuncMenu,
            //            });
            //        }
            //    }
            //}), new Action<int, string>((errorCode, errorDesc) =>
            //{     ////通信错误
            //    if (errorAction != null)
            //    {
            //        errorAction(new ErrorEntity() { ReturnCode = errorCode, ReturnDesc = errorDesc, RequestFunc = Client_Resource.Resources_Service_QueryAccountFuncMenu });
            //    }
            //}));
        }

        /// <summary>
        /// 查询交易端交易费用
        /// </summary>
        /// <param name="accountId"></param>
        /// <param name="successAction"></param>
        /// <param name="errorAction"></param>
        public void QueryAccountTradeFee(uint accountId, Action<System.Collections.Generic.List<Data.Model.GoodRules.TradeGoodsFeeRule>> successAction, Action<ErrorEntity> errorAction)
        {
            return;

            //var reqeust = _accountAdapter.ToReqeustTradeFeeRules(accountId);
            //var packgage = new TCPPackage() { Content = reqeust, FunCode = FuncCode.FID_QueryAccountGoodsTypeReq };
            //LinkManager.Instance.TradeTcpLinkProxy.SendPackage(packgage, new Action<TCPPackage>((revPackgage) =>
            //{
            //    var responeEntrity = _accountAdapter.ResoneLocalGoodsFeeRules(revPackgage.Content);
            //    if (responeEntrity.RetCode == 0)
            //    {
            //        successAction(responeEntrity.Entity);
            //        ///更新商品涨跌停价
            //    }
            //    else
            //    {
            //        if (errorAction != null)
            //        {
            //            errorAction(new ErrorEntity()
            //            {
            //                //RequestFunc = 查询交易端交易费用 
            //                ReturnCode = responeEntrity.RetCode,
            //                ReturnDesc = responeEntrity.RetMessage,
            //                RequestFunc = Client_Resource.Resources_Service_QueryAccountTradeFee,
            //            });
            //        }
            //    }
            //}), new Action<int, string>((errorCode, errorDesc) =>
            //{     ////通信错误
            //    if (errorAction != null)
            //    {
            //        errorAction(new ErrorEntity() { ReturnCode = errorCode, ReturnDesc = errorDesc, RequestFunc = Client_Resource.Resources_Service_QueryAccountTradeFee });
            //    }
            //}));
        }

        /// <summary>
        /// 查询交易商品费用及规则参数
        /// </summary>
        /// <param name="accountId"></param>
        /// <param name="successAction"></param>
        /// <param name="errorAction"></param>
        public void QueryAccountGoodsParams(ulong accountId, Action<Dictionary<int, TradeGoodsFeeRule>> successAction, Action<ErrorEntity> errorAction)
        {
            var queryCommonParams = new List<QueryCommonParam>();

            queryCommonParams.Add(new QueryCommonParam() { ParamKey = "accountId", ParamValue = accountId + string.Empty });
            QueryCommonHelper.QueryCommon(QueryStatement.QueryAccountGoodsParams, queryCommonParams, new Action<List<GoodsFeeType>>((feeTypes) =>
            {
                var goodsFeeRules = new Dictionary<int, TradeGoodsFeeRule>();
                foreach (var goodsFeeType in feeTypes)
                {
                    if (!goodsFeeRules.ContainsKey(goodsFeeType.GoodsId))
                    {
                        var goodsFee = new TradeGoodsFeeRule();
                        goodsFeeRules[goodsFeeType.GoodsId] = goodsFee;
                    }
                    switch (goodsFeeType.KeyType)
                    {
                        case FeeRuleType.GoodsFee:
                            goodsFeeRules[goodsFeeType.GoodsId].GoodsFees[goodsFeeType.FeeTypeId] = goodsFeeType;
                            break;
                        case FeeRuleType.GoodsRule:
                            goodsFeeRules[goodsFeeType.GoodsId].GoodsRules[goodsFeeType.FeeTypeId] = goodsFeeType;
                            break;
                        case FeeRuleType.PersonalFee:
                            goodsFeeRules[goodsFeeType.GoodsId].AccountGoodsFees[goodsFeeType.FeeTypeId] = goodsFeeType;
                            break;
                        case FeeRuleType.PersonalRule:
                            goodsFeeRules[goodsFeeType.GoodsId].AccountGoodsRules[goodsFeeType.FeeTypeId] = goodsFeeType;
                            break;
                        case FeeRuleType.GoodsRaiseFall:
                            //goodsFeeRules[goodsFeeType.GoodsId].RaisePrice = goodsFeeType.FeeMode;
                            //goodsFeeRules[goodsFeeType.GoodsId].FallPrice = goodsFeeType.FeeValue;
                            //var goods = CacheManager.CacheGoodsBaseInfos.FirstOrDefault(
                            //    (item) => item.GoodsId == goodsFeeType.GoodsId);
                            //if (goods != null)
                            //{
                            //goods.RaisesPrice = goodsFeeType.FeeMode;    //涨停价
                            //goods.FallsPrice = goodsFeeType.FeeValue;     //跌停价
                            //  goods.IssueTotal = goodsFeeType.FeeTypeId;    //对应发售商品发行总量
                            //}
                            break;
                        case FeeRuleType.QuoteValidStatus:
                            //goodsFeeRules[goodsFeeType.GoodsId].RaisePrice = goodsFeeType.FeeMode;
                            //goodsFeeRules[goodsFeeType.GoodsId].FallPrice = goodsFeeType.FeeValue;
                            //var goods = CacheManager.CacheGoodsBaseInfos.FirstOrDefault(
                            //    (item) => item.GoodsId == goodsFeeType.GoodsId && goodsFeeType.Trademode==eTradeMode.TRADEMODE_BIDDINGMARKETMAKE);

                            //if (goods != null)
                            //{
                            //    //goods.RaisesPrice = goodsFeeType.FeeMode;    //涨停价
                            //    //goods.FallsPrice = goodsFeeType.FeeValue;     //跌停价
                            //    goods.IsQuoteValid = goodsFeeType.FeeValue==1;    //外部行情是否有效
                            //}
                            break;
                        default:
                            break;
                    }

                }
                CacheManager.TradeGoodsFeeRules = goodsFeeRules;

                if (successAction != null)
                {
                    successAction(goodsFeeRules);
                }
            }), (error) =>
            {
                //RequestFunc = 查询交易商品费用及规则参数 
                error.RequestFunc = Client_Resource.Resources_Service_QueryAccountGoodsParams;
                if (errorAction != null) errorAction(error);
            });
        }


        public void QueryOutMoneyThresholdRatio(ulong accountId, Action<List<OutMoneyThresholdRatio>> successAction,
            Action<ErrorEntity> errorAction)
        {
            var queryCommonParams = new List<QueryCommonParam>();

            queryCommonParams.Add(new QueryCommonParam() { ParamKey = "accountId", ParamValue = accountId + string.Empty });
            QueryCommonHelper.QueryCommon(QueryStatement.SearchOutMoneyThresholdRatio, queryCommonParams,
                new Action<List<OutMoneyThresholdRatio>>(
                    (ratios) =>
                    {
                        successAction(ratios);
                    }), (error) =>
                    {
                        error.RequestFunc = Client_Resource.Resources_Service_QueryAccountGoodsParams;
                        if (errorAction != null) errorAction(error);
                    });
        }


        public void SystemRateComfrim(ulong accountId, ComfrimType comfrim, Action<bool> successAction, Action<ErrorEntity> errorAction)
        {
            return;

            //var reqeust = _accountAdapter.ToReqeustRiskChecked(accountId,(uint) comfrim);
            //var packgage = new TCPPackage() { Content = reqeust, FunCode = FuncCode.FID_RiskCheckNotifyReq };
            //LinkManager.Instance.TradeTcpLinkProxy.SendPackage(packgage, new Action<TCPPackage>((revPackgage) =>
            //{
            //    var responeEntrity = _accountAdapter.ResponeRiskChecked(revPackgage.Content);
            //    if (responeEntrity.RetCode == 0)
            //    {
            //        successAction(true);
            //    }
            //    else
            //    {
            //        if (errorAction != null)
            //        {
            //            errorAction(new ErrorEntity()
            //            {
            //                ReturnCode = responeEntrity.RetCode,
            //                ReturnDesc = responeEntrity.RetMessage,
            //            });
            //        }
            //    }
            //}), new Action<int, string>((errorCode, errorDesc) =>
            //{     ////通信错误
            //    if (errorAction != null)
            //    {
            //        errorAction(new ErrorEntity() { ReturnCode = errorCode, ReturnDesc = errorDesc,  });
            //    }
            //}));
        }

        /// <summary>
        /// 查询外部交易所信息
        /// </summary>
        /// <param name="successAction"></param>
        /// <param name="errorAction"></param>
        public void QueryExternalExchange(Action<List<ExternalExchangeModel>> successAction, Action<ErrorEntity> errorAction)
        {
            var reqeust = _accountAdapter.ToExternalExchangeReq();
            var packgage = new TCPPackage() { Content = reqeust, FunCode = FuncCode.FID_ExternalExchangeReq };
            LinkManager.Instance.TradeTcpLinkProxy.SendPackage(packgage, new Action<TCPPackage>((revPackgage) =>
            {
                var responeEntrity = _accountAdapter.ResponseExternalExchange(revPackgage.Content);
                if (responeEntrity.RetCode == 0)
                {
                    successAction(responeEntrity.Entity);
                }
                else
                {
                    if (errorAction != null)
                    {
                        errorAction(new ErrorEntity()
                        {
                            ReturnCode = responeEntrity.RetCode,
                            ReturnDesc = responeEntrity.RetMessage,
                            RequestFunc = "ExternalExchangeReq",
                        });
                    }
                }
            }), new Action<int, string>((errorCode, errorDesc) =>
            {     ////通信错误
                if (errorAction != null)
                {
                    errorAction(new ErrorEntity() { ReturnCode = errorCode, ReturnDesc = errorDesc, RequestFunc = "ExternalExchangeReq" });
                }
            }));
        }


        /// <summary>
        /// 查询商品组
        /// </summary>
        /// <param name="successAction"></param>
        /// <param name="errorAction"></param>
        public void QueryGoodsGroup(Action<List<GoodsGroup>> successAction, Action<ErrorEntity> errorAction)
        {
            var reqeust = _accountAdapter.ToGoodsGroupReq();
            var packgage = new TCPPackage() { Content = reqeust, FunCode = FuncCode.FID_GoodsGroupReq };
            LinkManager.Instance.TradeTcpLinkProxy.SendPackage(packgage, new Action<TCPPackage>((revPackgage) =>
            {
                var responeEntrity = _accountAdapter.ResponseGoodsGroup(revPackgage.Content);
                if (responeEntrity.RetCode == 0)
                {
                    CacheManager.LoadGoodsGroupList(responeEntrity.Entity);
                    if (successAction != null) successAction(responeEntrity.Entity);
                }
                else
                {
                    if (errorAction != null)
                    {
                        errorAction(new ErrorEntity()
                        {
                            ReturnCode = responeEntrity.RetCode,
                            ReturnDesc = responeEntrity.RetMessage,
                            RequestFunc = "GoodsGroupReq",
                        });
                    }
                }
            }), new Action<int, string>((errorCode, errorDesc) =>
            {     ////通信错误
                if (errorAction != null)
                {
                    errorAction(new ErrorEntity() { ReturnCode = errorCode, ReturnDesc = errorDesc, RequestFunc = "GoodsGroupReq" });
                }
            }));
        }
    }
}