using Managing.Application.Abstractions;
using Managing.Application.Abstractions.Services;
using Managing.Application.Bots;
using Managing.Common;
using Managing.Core;
using Managing.Domain.Bots;
using Managing.Domain.MoneyManagements;
using Managing.Domain.Workflows;
using Microsoft.Extensions.Logging;
using Newtonsoft.Json;

namespace Managing.Application.ManageBot
{
    public class BotService : IBotService
    {
        private readonly IBotRepository _botRepository;
        private readonly ITaskCache _taskCache;
        private readonly IExchangeService _exchangeService;
        private readonly IMessengerService _messengerService;
        private readonly IAccountService _accountService;
        private readonly ILogger<TradingBot> _tradingBotLogger;
        private readonly ITradingService _tradingService;


        public BotService(IBotRepository botRepository, ITaskCache taskCache, IExchangeService exchangeService,
            IMessengerService messengerService, IAccountService accountService, ILogger<TradingBot> tradingBotLogger,
            ITradingService tradingService)
        {
            _botRepository = botRepository;
            _taskCache = taskCache;
            _exchangeService = exchangeService;
            _messengerService = messengerService;
            _accountService = accountService;
            _tradingBotLogger = tradingBotLogger;
            _tradingService = tradingService;
        }

        public async void SaveBotBackup(BotBackup botBackup)
        {
            await _botRepository.InsertBotAsync(botBackup);
        }

        public BotBackup GetBotBackup(string name)
        {
            return _botRepository.GetBots().FirstOrDefault(b => b.Name == name);
        }

        public void SaveBotBackup(string name, Enums.BotType botType, string data)
        {
            var backup = GetBotBackup(name);

            if (backup != null)
            {
                backup.Data = data;
                _botRepository.UpdateBackupBot(backup);
                return;
            }

            var botBackup = new BotBackup
            {
                Name = name,
                BotType = botType,
                Data = data
            };

            _botRepository.InsertBotAsync(botBackup);
        }

        public void AddSimpleBotToCache(IBot bot)
        {
            _taskCache.AddOrGetExisting(bot.GetName(), () => Task.FromResult(bot));
        }

        public void AddTradingBotToCache(ITradingBot bot)
        {
            _taskCache.AddOrGetExisting(bot.GetName(), () => Task.FromResult(bot));
        }

        public List<ITradingBot> GetActiveBots()
        {
            var cachedTask = _taskCache.GetCache<AsyncLazy<ITradingBot>>();
            return cachedTask.Select(item => item.Value.Result).ToList();
        }

        public IEnumerable<BotBackup> GetSavedBots()
        {
            return _botRepository.GetBots();
        }

        public void StartBotFromBackup(BotBackup backupBot)
        {
            switch (backupBot.BotType)
            {
                case Enums.BotType.SimpleBot:
                    Func<Task<IBot>> simpleBot = () =>
                        Task.FromResult(CreateSimpleBot(backupBot.Name, null));
                    var bot1 = _taskCache.AddOrGetExisting(backupBot.Name, simpleBot).Result;
                    bot1.LoadBackup(backupBot);
                    bot1.Start();
                    break;
                case Enums.BotType.ScalpingBot:
                    var data = JsonConvert.DeserializeObject<TradingBotBackup>(backupBot.Data);
                    Func<Task<ITradingBot>> scalpingBot = () => Task.FromResult(CreateScalpingBot(
                        data.AccountName,
                        data.MoneyManagement,
                        data.Name,
                        data.Ticker,
                        data.Scenario,
                        data.Timeframe,
                        data.IsForWatchingOnly));
                    var bot2 = _taskCache.AddOrGetExisting(backupBot.Name, scalpingBot).Result;
                    bot2.LoadBackup(backupBot);
                    bot2.Start();
                    break;
                case Enums.BotType.FlippingBot:
                    var dataFlippingBot = JsonConvert.DeserializeObject<TradingBotBackup>(backupBot.Data);
                    Func<Task<ITradingBot>> flippingBot = () => Task.FromResult(CreateFlippingBot(
                        dataFlippingBot.AccountName,
                        dataFlippingBot.MoneyManagement,
                        dataFlippingBot.Name,
                        dataFlippingBot.Ticker,
                        dataFlippingBot.Scenario,
                        dataFlippingBot.Timeframe,
                        dataFlippingBot.IsForWatchingOnly));
                    var bot3 = _taskCache.AddOrGetExisting(backupBot.Name, flippingBot).Result;
                    bot3.LoadBackup(backupBot);
                    bot3.Start();
                    break;
            }

            ;
        }

        public IBot CreateSimpleBot(string botName, Workflow workflow)
        {
            return new SimpleBot(botName, _tradingBotLogger, workflow, this);
        }

        public ITradingBot CreateScalpingBot(string accountName, MoneyManagement moneyManagement, string name,
            Enums.Ticker ticker, string scenario, Enums.Timeframe interval, bool isForWatchingOnly)
        {
            return new ScalpingBot(
                accountName,
                moneyManagement,
                name,
                scenario,
                _exchangeService,
                ticker,
                _tradingService,
                _tradingBotLogger,
                interval,
                _accountService,
                _messengerService,
                this,
                isForWatchingOnly: isForWatchingOnly);
        }

        public ITradingBot CreateBacktestScalpingBot(string accountName, MoneyManagement moneyManagement,
            Enums.Ticker ticker, string scenario, Enums.Timeframe interval, bool isForWatchingOnly)
        {
            return new ScalpingBot(
                accountName,
                moneyManagement,
                "BacktestBot",
                scenario,
                _exchangeService,
                ticker,
                _tradingService,
                _tradingBotLogger,
                interval,
                _accountService,
                _messengerService,
                this,
                true,
                isForWatchingOnly);
        }

        public ITradingBot CreateFlippingBot(string accountName, MoneyManagement moneyManagement, string name,
            Enums.Ticker ticker, string scenario, Enums.Timeframe interval, bool isForWatchingOnly)
        {
            return new FlippingBot(
                accountName,
                moneyManagement,
                name,
                scenario,
                _exchangeService,
                ticker,
                _tradingService,
                _tradingBotLogger,
                interval,
                _accountService,
                _messengerService,
                this,
                isForWatchingOnly: isForWatchingOnly);
        }

        public ITradingBot CreateBacktestFlippingBot(string accountName, MoneyManagement moneyManagement,
            Enums.Ticker ticker, string scenario, Enums.Timeframe interval, bool isForWatchingOnly)
        {
            return new FlippingBot(
                accountName,
                moneyManagement,
                "BacktestBot",
                scenario,
                _exchangeService,
                ticker,
                _tradingService,
                _tradingBotLogger,
                interval,
                _accountService,
                _messengerService,
                this,
                true,
                isForWatchingOnly);
        }
    }
}