using Newtonsoft.Json;
using YLErp.Abstract;
using YLErp.BLL.Eod;
using YLErp.Cache;
using YLErp.Modules.ClientModule;
using YLErp.Modules.SwapModule;

namespace YLErp.Web.App
{
    public class ClientBalanceTask : IHostedService, IDisposable
    {
        private readonly IYcLogger _logger;
        private readonly CancellationTokenSource _cts = new CancellationTokenSource();
        private KafkaConsumerHelper _kafkaConsumer;
        private IYLCache _yLCache;
        private IKafkaProduce kafkaProduceHelper;
        private string onRspAccountCapitalTopicTopic = string.Empty;
        public ClientBalanceTask(IKafkaProduce kafkaProduce, IYLCache yLCache)
        {
            _logger = LogFactory.GetLogger("ClientBalanceTask");
            var accountCapitalTopicGroupId = Environment.GetEnvironmentVariable("KafkaConfig_AccountCapitalTopicGroupId");
            var reqAccountCapitalTopic = Environment.GetEnvironmentVariable("KafkaConfig_ReqAccountCapitalTopic");
             onRspAccountCapitalTopicTopic = Environment.GetEnvironmentVariable("KafkaConfig_OnRspAccountCapitalTopic");
            _kafkaConsumer=new KafkaConsumerHelper(accountCapitalTopicGroupId, reqAccountCapitalTopic);
            kafkaProduceHelper = kafkaProduce;
            RealtimePnlCalc.InitCache(yLCache);
            RealtimePnlCalc.InitKafka(kafkaProduceHelper);
        }
        public void Dispose()
        {
            _cts.Dispose();
        }

        public Task StartAsync(CancellationToken cancellationToken)
        {
            _logger.Info("ClientBalanceTask task is starting.");
            Task.Run(() => ExecuteTask(_cts.Token), _cts.Token);
            return Task.CompletedTask;
        }

        public async Task StopAsync(CancellationToken cancellationToken)
        {
            _logger.Info("ClientBalanceTask task is stopping.");
            _cts.Cancel();
            await Task.CompletedTask;
        }
        private void ExecuteTask(CancellationToken cancellationToken)
        {
            while (!cancellationToken.IsCancellationRequested)
            {
                _kafkaConsumer.Subscribe(async msg =>
               {
                   if (!string.IsNullOrEmpty(msg))
                   {
                       ClientBalanceKafkaReq req = JsonConvert.DeserializeObject<ClientBalanceKafkaReq>(msg);
                       //系统交易日
                       var valuedate = valuedateBLL.ValueDate;

                       //获取根据系统时间
                       var lastBalanceDate = EodOperationBase.GetLastSettlementDate(valuedate);
                       var client = DataCacheProvider.GetClientDataSource().GetData(req.clientId);
                       if (client!=null&& client.SwapTradeType==1)
                       {
                           lastBalanceDate = valuedate;
                       }
                       // 执行任务
                       await Task.Run(() =>
                       {
                           Result result = new Result();
                           try
                           {
                               var cbs = new RealTimeClientBanlanceService(new OptUserInfo(0, "实时客户资金服务", OptUserFrom.Service)).GetBanlances(new List<int>() { req.clientId }, lastBalanceDate.AddDays(1), calcDate: valuedateBLL.ValueDate);
                               var cb = cbs.FirstOrDefault();
                               var AvailableMoney = cb.AvailableAmount + cb.FrozenMarginMoney;
                               var obj = new ClientBalanceForTrsResponse
                               {
                                   AvailableAmount = Math.Round(cb.AvailableAmount, 2),
                                   PositionPv = cb.RoundedPositionPv,
                                   PositionPnl = cb.RoundedPositionPnl,
                                   ClientId = req.clientId,
                                   ClientType = cb.ClientType,
                                   Credit = cb.TotalCredit,
                                   AvailableMoney = AvailableMoney
                               };
                               result.success = true;
                               result.obj = obj;
                               if (_yLCache != null)
                               {
                                   _yLCache.StringSet<ClientBalanceForTrsResponse>("ClientBalance:" + cb.ClientId, obj);
                               }
                           }
                           catch (Exception ex)
                           {
                               result.msg = ex.Message;
                               result.success = false;
                           }
                           kafkaProduceHelper.Produce(onRspAccountCapitalTopicTopic,JsonConvert.SerializeObject(result));
                       }, cancellationToken);
                   }
               });

            }

        }
    }
}