using MediatR;
using static Managing.Common.Enums;
using Managing.Application.Abstractions;
using Managing.Core;
using Microsoft.Extensions.Logging;

namespace Managing.Application.ManageBot;

public class LoadBackupBotCommandHandler : IRequestHandler<LoadBackupBotCommand, string>
{
    private readonly IBotService _botService;
    private readonly ILogger<LoadBackupBotCommandHandler> _logger;

    public LoadBackupBotCommandHandler(
        ILogger<LoadBackupBotCommandHandler> logger, IBotService botService)
    {
        _logger = logger;
        _botService = botService;
    }

    public Task<string> Handle(LoadBackupBotCommand request, CancellationToken cancellationToken)
    {
        BotStatus botStatus = BotStatus.Down;
        var backupBots = _botService.GetSavedBots().ToList();
        var activeBots = _botService.GetActiveBots();
        var result = new Dictionary<string, BotStatus>();

        _logger.LogInformation($"Loading {backupBots.Count()}  backup bots");

        foreach (var backupBot in backupBots)
        {
            // Check if bot is existing in cache
            try
            {
                switch (backupBot.BotType)
                {
                    case BotType.SimpleBot:
                        var simpleBot = activeBots.FirstOrDefault(b => b.GetName() == backupBot.Name);
                        if (simpleBot == null)
                        {
                            _logger.LogInformation($"Starting backup bot {backupBot.Name}");
                            _botService.StartBotFromBackup(backupBot);
                            result.Add(simpleBot.GetName(), BotStatus.Backup);
                        }
                        else
                        {
                            result.Add(simpleBot.GetName(), MiscExtensions.ParseEnum<BotStatus>(simpleBot.GetStatus()));
                        }

                        break;
                    case BotType.ScalpingBot:
                    case BotType.FlippingBot:
                        var scalpingBot = activeBots.FirstOrDefault(b => b.GetName() == backupBot.Name);
                        if (scalpingBot == null)
                        {
                            _logger.LogInformation($"Starting backup bot {backupBot.Name}");
                            _botService.StartBotFromBackup(backupBot);
                            var bots = _botService.GetActiveBots();
                            scalpingBot = bots.FirstOrDefault(b => b.GetName() == backupBot.Name);
                            result.Add(scalpingBot.GetName(), BotStatus.Backup);
                        }
                        else
                        {
                            result.Add(scalpingBot.GetName(),
                                MiscExtensions.ParseEnum<BotStatus>(scalpingBot.GetStatus()));
                        }

                        break;
                    default:
                        result.Add(backupBot.Name, BotStatus.Down);
                        break;
                }
            }
            catch (Exception ex)
            {
                _logger.LogError($"Error loading bot {backupBot.Name}", ex.Message);
                _botService.DeleteBotBackup(backupBot.Name);
                result.Add(backupBot.Name, BotStatus.Down);
            }
        }

        _logger.LogInformation("Bot loading completed");
        _logger.LogInformation($"Bots: {result.Select(b => $"{b.Key} - {b.Value}")}");

        return Task.FromResult(botStatus.ToString());
    }
}

public class LoadBackupBotCommand : IRequest<string>
{
}