using BaseOUDAL;
using Newtonsoft.Json;
using Org.BouncyCastle.Crypto.Tls;
using Org.BouncyCastle.Ocsp;
using System.Data;
using YLErp.Abstract;
using YLErp.Commons;
using YLErp.Helpers;
using YLErp.Model;
using YLErp.Modules.ClientModule;
using YLErp.Modules.SwapModule;

namespace YLErp.Modules.AppModule
{
    public class EtradingRuleService : YLBaseService
    {
        KafkaProduceHelper kafkaProduceHelper;
        public EtradingRuleService(OptUserInfo userInfo) : base(userInfo)
        {
            kafkaProduceHelper = new KafkaProduceHelper();
        }

        public List<string> ImportExcel(Stream streamIn, out int TotalNum, out int SuccessNum)
        {
            int rowIndex = 0;
            List<string> clientNumbers = new List<string>();
            var trans = DbContext.Database.BeginTransaction();
            try
            {
                var ds = Office.ExcelHelper.ReadExcelAsDataSet(streamIn, new[] { 0 }, 1);

                if (ds.Tables.Count < 1 || ds.Tables[0].Rows.Count < 1)
                {
                    throw new ServiceException("读取导入数据失败:数据为空") { Tag = "111" };
                }

                var table = ds.Tables[0];
                var reader = new DataRowReader(table);

                rowIndex = 1;
                TotalNum = table.Rows.Count;
                var tradePositions = new List<EtradingRule>();
                foreach (DataRow row in table.Rows.Cast<DataRow>())
                {
                    rowIndex++;

                    if (row.ItemArray.All(n => string.IsNullOrWhiteSpace(n?.ToString())))
                    {
                        continue;
                    }

                    reader.SetDataRow(row);

                    var rule = MapRule(reader);
                    SaveRule(rule);
                    clientNumbers.Add(rule.ClientNumber_0);
                    DbContext.SaveChanges();
                }
                SuccessNum = TotalNum;
                trans.Commit();
                trans.Dispose();
                return clientNumbers;
            }
            catch (ServiceException se)
            {
                trans.Rollback();
                trans.Dispose();
                if (se.Tag != null) throw;
                throw new ServiceException($"第{rowIndex}行,发生错误:{se.Message}");
            }
            catch (Exception ex)
            {
                trans.Rollback();
                trans.Dispose();
                LogFactory.GetLogger("TRS用簿记账户设置").Error(ex);
                throw new ServiceException($"第{rowIndex}行,发生错误:{ex.Message}", ex);
            }
        }

        private EtradingRule MapRule(DataRowReader reader)
        {
            //资金流向	对客客户编号	对客簿记账户	对客清算机构		对冲Broker	对冲簿记账户	对冲清算机构

            var rule = new EtradingRule();
            //var boundeside = reader.GetString("资金流向", false);
            rule.BoundSide =  BoundSideEnum.南向; //默认南向          
            rule.ClientNumber_0 = reader.GetString("对客客户编号", false);
            if (string.IsNullOrWhiteSpace(rule.ClientNumber_0))
            {
                throw new ServiceException("对客客户编号不能为空");
            }
            rule.AssetAccount_0 = reader.GetString("对客簿记账户", false);
            rule.ClearingAgency_0 = reader.GetString("对客清算机构", false);
            ////rule.ClientNumber_1 = reader.GetString("连接客户编号", false);
            ////rule.AssetAccount_1 = reader.GetString("连接簿记账户", false);
            ////rule.ClearingAgency_1 = reader.GetString("连接清算机构", false);
            //rule.Trader_2 = reader.GetString("交易员编号", false);
            //rule.Broker_2 = reader.GetString("资金账户", false);
            //rule.FundAccount_2 = reader.GetString("资金账户2", false);
            //rule.AssetAccount_2 = reader.GetString("对冲簿记账户", false);
            //rule.ClearingAgency_2 = reader.GetString("对冲清算机构", false);
            return rule;
        }

        public void SaveRule(EtradingRule rule)
        {
            CheckRule(rule);
            DeleteRule(rule.BoundSide, rule.ClientNumber_0);//删除原来的预设
            DbContext.Etrading_Rule.Add(rule);//重新保存
            DbContext.SaveChanges();
        }

        private bool CheckRule(EtradingRule rule)
        {
            var clients = DataCacheProvider.GetClientDataSource().AsQueryable();

            if (!string.IsNullOrEmpty(rule.ClientNumber_0) && !clients.Any(o => o.Number == rule.ClientNumber_0))
            {
                throw new ServiceException("对客端客户不存在");
            }
            if (!string.IsNullOrWhiteSpace(rule.ClientNumber_0))
            {
                var client = clients.FirstOrDefault(o => o.Number == rule.ClientNumber_0);
                rule.BoundSide = client.BoundSide;
            }
            else
            {
                rule.ClientNumber_0 = string.Empty;
            }

            //if (!string.IsNullOrEmpty(rule.ClientNumber_1) && !clients.Any(o => o.Number == rule.ClientNumber_1))
            //{
            //    throw new ServiceException("连接客户编号不存在");
            //}
            var assets = DataCacheProvider.GetAssetUnitDataSource().AsQueryable();
            if (!string.IsNullOrEmpty(rule.AssetAccount_0) && !assets.Any(o => o.Name == rule.AssetAccount_0))
            {
                throw new ServiceException("对客簿记账户不存在");
            }
            //if (!string.IsNullOrEmpty(rule.AssetAccount_1) && !assets.Any(o => o.Name == rule.AssetAccount_1))
            //{
            //    throw new ServiceException("连接簿记账户不存在");
            //}
            return true;
        }

        public string DeleteRule(int id)
        {
            var rule = DbContext.Etrading_Rule.Find(id);
            if (rule != null)
            {
                DbContext.Etrading_Rule.Remove(rule);
                DbContext.SaveChanges();
            }
            return rule.ClientNumber_0;
        }
        public void DeleteRule(BoundSideEnum? BoundSide, string ClientNumber)
        {
            if (BoundSide != null)
            {
                var rule = new EtradingRule();
                if (string.IsNullOrEmpty(ClientNumber))
                {
                    rule = DbContext.Etrading_Rule.FirstOrDefault(o => o.BoundSide == BoundSide && string.IsNullOrEmpty(o.ClientNumber_0));
                }
                else
                {
                    rule = DbContext.Etrading_Rule.FirstOrDefault(o => o.ClientNumber_0 == ClientNumber);
                }

                if (rule != null)
                {
                    DbContext.Etrading_Rule.Remove(rule);
                    DbContext.SaveChanges();
                }
            }
        }
        /// <summary>
        /// 将最新的费率发送到kafka
        /// </summary>
        /// <param name="clientId"></param>
        /// <param name="kafkaProvider"></param>
        public void SendEtradingRuleToKafka(string clientNumber)
        {
            List<Client> clients = new List<Client>();
            using (var con = new ClientDBContext())
            {
                clients = con.client.AsNoTracking().Where(s => s.ProcessStatus == "已开户").ToList();
            }
            if (!string.IsNullOrEmpty(clientNumber))
            {
                var client = clients.FirstOrDefault(o => o.Number == clientNumber);
                if (client!=null)
                {
                    var asset = GetAssetByClient(clientNumber);
                    var account = new EtradeAccountService(UserInfo).GetEtradeAccount(asset)?.balance_account_trade;
                    SendToKafka(client.id, account);
                }
            }
            else
            {
                SendAllEtradingRuleToKafka();
            }
        }
        private string GetAssetByClient(string clientNumber)
        {
           var rule= DbContext.Etrading_Rule.FirstOrDefault(x=>x.ClientNumber_0== clientNumber);
            if (rule==null)
            {
                rule = DbContext.Etrading_Rule.FirstOrDefault(x => string.IsNullOrEmpty(x.ClientNumber_0));
            }
            return rule?.AssetAccount_0;
        }

        public List<string> GetClientNumers(string asset)
        {
            List<string> numbers=new List<string>();
            if (string.IsNullOrEmpty(asset))
            {
                numbers = DbContext.Etrading_Rule.AsNoTracking().Select(s => s.ClientNumber_0).ToList();
                return numbers;
            }
            var rules = DbContext.Etrading_Rule.Where(x => x.AssetAccount_0 == asset|| string.IsNullOrEmpty(x.AssetAccount_0)).AsNoTracking();
            numbers = rules.Select(s => s.ClientNumber_0).ToList();
            return numbers;
        }
        public void SendAllEtradingRuleToKafka()
        {
            var etradingRules = DbContext.Etrading_Rule.AsNoTracking().ToList();
            List<Client> clients = new List<Client>();
            using (var con =new ClientDBContext())
            {
                clients= con.client.AsNoTracking().Where(s => s.ProcessStatus == "已开户").ToList();
            }
            foreach (var client in clients)
            {
                var clientRule = etradingRules.FirstOrDefault(x => x.ClientNumber_0 == client.Number);
                var asset = GetAssetByClient(client.Number);
                var account = new EtradeAccountService(UserInfo).GetEtradeAccount(asset)?.balance_account_trade;
                SendToKafka(client.id, account);
            }
        }
        public void SendToKafka(int clientId, string hedgingAccount)
        {
            EtradingRuleKafkaModel etradingRuleKafkaModel = new EtradingRuleKafkaModel();
            etradingRuleKafkaModel.clientId = clientId;
            etradingRuleKafkaModel.hedgingAccount = hedgingAccount;
            kafkaProduceHelper.Produce(Environment.GetEnvironmentVariable("KafkaConfig_HedgingAccountTopic"), JsonConvert.SerializeObject(etradingRuleKafkaModel));
        }
        public EtradingRule GetEtradingRuleAccont(BoundSideEnum boundSide, string clientNumer)
        {
            var etradingRules = DbContext.Etrading_Rule.AsNoTracking().ToList();
            var etradingRule = etradingRules.FirstOrDefault(x => x.ClientNumber_0 == clientNumer);
            if (etradingRule == null)
            {
                etradingRule = etradingRules.FirstOrDefault(x => string.IsNullOrEmpty(x.ClientNumber_0) && x.BoundSide == boundSide);
            }
            return etradingRule;
        }
    }
}