using System.Text.Json;
using GeneticSharp;
using Managing.Application.Abstractions.Repositories;
using Managing.Application.Abstractions.Services;
using Managing.Domain.Backtests;
using Managing.Domain.Bots;
using Managing.Domain.MoneyManagements;
using Managing.Domain.Risk;
using Managing.Domain.Scenarios;
using Managing.Domain.Users;
using Microsoft.Extensions.Logging;
using static Managing.Common.Enums;

namespace Managing.Application;

/// <summary>
/// Service implementation for managing genetic algorithm requests
/// </summary>
public class GeneticService : IGeneticService
{
    private readonly IGeneticRepository _geneticRepository;
    private readonly IBacktester _backtester;
    private readonly ILogger<GeneticService> _logger;
    private readonly IMessengerService _messengerService;

    // Predefined parameter ranges for each indicator (matching backtestGenetic.tsx)
    public static readonly Dictionary<string, (double min, double max)> ParameterRanges = new()
    {
        // Trading Parameters only - indicator parameters are now handled by IndicatorParameterRanges
        ["stopLoss"] = (0.2, 50.0), // Minimum 0.2% to cover fees, no upper limit (set to 50% as practical max)
        ["leverage"] = (1.0, 10.0),
        ["cooldownPeriod"] = (5.0, 25.0),
        ["maxLossStreak"] = (0.0, 4.0),
        ["maxPositionTimeHours"] = (0, 48.0)
    };

    // Default indicator values per indicator type (matching CustomScenario.tsx)
    public static readonly Dictionary<IndicatorType, Dictionary<string, double>> DefaultIndicatorValues = new()
    {
        [IndicatorType.RsiDivergence] = new() { ["period"] = 14.0 },
        [IndicatorType.RsiDivergenceConfirm] = new() { ["period"] = 14.0 },
        [IndicatorType.EmaCross] = new() { ["period"] = 14.0 },
        [IndicatorType.EmaTrend] = new() { ["period"] = 14.0 },
        [IndicatorType.StDev] = new() { ["period"] = 14.0 },
        [IndicatorType.ThreeWhiteSoldiers] = new() { ["period"] = 14.0 },
        [IndicatorType.MacdCross] = new()
        {
            ["fastPeriods"] = 12.0,
            ["slowPeriods"] = 26.0,
            ["signalPeriods"] = 9.0
        },
        [IndicatorType.DualEmaCross] = new()
        {
            ["fastPeriods"] = 12.0,
            ["slowPeriods"] = 26.0
        },
        [IndicatorType.SuperTrend] = new()
        {
            ["period"] = 14.0,
            ["multiplier"] = 3.0
        },
        [IndicatorType.SuperTrendCrossEma] = new()
        {
            ["period"] = 14.0,
            ["multiplier"] = 3.0
        },
        [IndicatorType.ChandelierExit] = new()
        {
            ["period"] = 14.0,
            ["multiplier"] = 3.0
        },
        [IndicatorType.StochRsiTrend] = new()
        {
            ["period"] = 14.0,
            ["stochPeriods"] = 14.0,
            ["signalPeriods"] = 9.0,
            ["smoothPeriods"] = 3.0
        },
        [IndicatorType.Stc] = new()
        {
            ["cyclePeriods"] = 10.0,
            ["fastPeriods"] = 12.0,
            ["slowPeriods"] = 26.0
        },
        [IndicatorType.LaggingStc] = new()
        {
            ["cyclePeriods"] = 10.0,
            ["fastPeriods"] = 12.0,
            ["slowPeriods"] = 26.0
        }
    };

    // Indicator-specific parameter ranges
    public static readonly Dictionary<IndicatorType, Dictionary<string, (double min, double max)>>
        IndicatorParameterRanges = new()
        {
            [IndicatorType.RsiDivergence] = new()
            {
                ["period"] = (6.0, 70.0)
            },
            [IndicatorType.RsiDivergenceConfirm] = new()
            {
                ["period"] = (6.0, 70.0)
            },
            [IndicatorType.EmaCross] = new()
            {
                ["period"] = (10.0, 300.0)
            },
            [IndicatorType.EmaTrend] = new()
            {
                ["period"] = (10.0, 300.0)
            },
            [IndicatorType.StDev] = new()
            {
                ["period"] = (5.0, 50.0)
            },
            [IndicatorType.ThreeWhiteSoldiers] = new()
            {
                ["period"] = (5.0, 50.0)
            },
            [IndicatorType.MacdCross] = new()
            {
                ["fastPeriods"] = (10.0, 70.0),
                ["slowPeriods"] = (20.0, 120.0),
                ["signalPeriods"] = (5.0, 50.0)
            },
            [IndicatorType.DualEmaCross] = new()
            {
                ["fastPeriods"] = (5.0, 300.0),
                ["slowPeriods"] = (5.0, 300.0)
            },
            [IndicatorType.SuperTrend] = new()
            {
                ["period"] = (5.0, 50.0),
                ["multiplier"] = (1.0, 10.0)
            },
            [IndicatorType.SuperTrendCrossEma] = new()
            {
                ["period"] = (5.0, 50.0),
                ["multiplier"] = (1.0, 10.0)
            },
            [IndicatorType.ChandelierExit] = new()
            {
                ["period"] = (5.0, 50.0),
                ["multiplier"] = (1.0, 10.0)
            },
            [IndicatorType.StochRsiTrend] = new()
            {
                ["period"] = (5.0, 50.0),
                ["stochPeriods"] = (5.0, 30.0),
                ["signalPeriods"] = (3.0, 15.0),
                ["smoothPeriods"] = (1.0, 10.0)
            },
            [IndicatorType.Stc] = new()
            {
                ["cyclePeriods"] = (5.0, 50.0),
                ["fastPeriods"] = (5.0, 70.0),
                ["slowPeriods"] = (10.0, 120.0)
            },
            [IndicatorType.LaggingStc] = new()
            {
                ["cyclePeriods"] = (5.0, 30.0),
                ["fastPeriods"] = (5.0, 50.0),
                ["slowPeriods"] = (10.0, 100.0)
            }
        };

    // Indicator type to parameter mapping
    public static readonly Dictionary<IndicatorType, string[]> IndicatorParamMapping = new()
    {
        [IndicatorType.RsiDivergence] = ["period"],
        [IndicatorType.RsiDivergenceConfirm] = ["period"],
        [IndicatorType.EmaCross] = ["period"],
        [IndicatorType.EmaTrend] = ["period"],
        [IndicatorType.StDev] = ["period"],
        [IndicatorType.ThreeWhiteSoldiers] = ["period"],
        [IndicatorType.MacdCross] = ["fastPeriods", "slowPeriods", "signalPeriods"],
        [IndicatorType.DualEmaCross] = ["fastPeriods", "slowPeriods"],
        [IndicatorType.SuperTrend] = ["period", "multiplier"],
        [IndicatorType.SuperTrendCrossEma] = ["period", "multiplier"],
        [IndicatorType.ChandelierExit] = ["period", "multiplier"],
        [IndicatorType.StochRsiTrend] = ["period", "stochPeriods", "signalPeriods", "smoothPeriods"],
        [IndicatorType.Stc] = ["cyclePeriods", "fastPeriods", "slowPeriods"],
        [IndicatorType.LaggingStc] = ["cyclePeriods", "fastPeriods", "slowPeriods"]
    };

    public GeneticService(
        IGeneticRepository geneticRepository,
        IBacktester backtester,
        ILogger<GeneticService> logger,
        IMessengerService messengerService)
    {
        _geneticRepository = geneticRepository;
        _backtester = backtester;
        _logger = logger;
        _messengerService = messengerService;
    }

    public GeneticRequest CreateGeneticRequest(
        User user,
        Ticker ticker,
        Timeframe timeframe,
        DateTime startDate,
        DateTime endDate,
        decimal balance,
        int populationSize,
        int generations,
        double mutationRate,
        GeneticSelectionMethod selectionMethod,
        GeneticCrossoverMethod crossoverMethod,
        GeneticMutationMethod mutationMethod,
        int elitismPercentage,
        double maxTakeProfit,
        List<IndicatorType> eligibleIndicators)
    {
        var id = Guid.NewGuid().ToString();
        var geneticRequest = new GeneticRequest(id)
        {
            Ticker = ticker,
            Timeframe = timeframe,
            StartDate = startDate,
            EndDate = endDate,
            Balance = balance,
            PopulationSize = populationSize,
            Generations = generations,
            MutationRate = mutationRate,
            SelectionMethod = selectionMethod,
            CrossoverMethod = crossoverMethod,
            MutationMethod = mutationMethod,
            ElitismPercentage = elitismPercentage,
            MaxTakeProfit = maxTakeProfit,
            EligibleIndicators = eligibleIndicators,
            Status = GeneticRequestStatus.Pending
        };

        _geneticRepository.InsertGeneticRequestForUser(user, geneticRequest);
        return geneticRequest;
    }

    public IEnumerable<GeneticRequest> GetGeneticRequestsByUser(User user)
    {
        return _geneticRepository.GetGeneticRequestsByUser(user);
    }

    public GeneticRequest GetGeneticRequestByIdForUser(User user, string id)
    {
        return _geneticRepository.GetGeneticRequestByIdForUser(user, id);
    }

    public void UpdateGeneticRequest(GeneticRequest geneticRequest)
    {
        _geneticRepository.UpdateGeneticRequest(geneticRequest);
    }

    public void DeleteGeneticRequestByIdForUser(User user, string id)
    {
        _geneticRepository.DeleteGeneticRequestByIdForUser(user, id);
    }

    public IEnumerable<GeneticRequest> GetPendingGeneticRequests()
    {
        return _geneticRepository.GetPendingGeneticRequests();
    }

    /// <summary>
    /// Runs the genetic algorithm for a specific request
    /// </summary>
    /// <param name="request">The genetic request to process</param>
    /// <param name="cancellationToken">Cancellation token to stop the algorithm</param>
    /// <returns>The genetic algorithm result</returns>
    public async Task<GeneticAlgorithmResult> RunGeneticAlgorithm(GeneticRequest request,
        CancellationToken cancellationToken = default)
    {
        try
        {
            _logger.LogInformation("Starting genetic algorithm for request {RequestId}", request.RequestId);

            // Update status to running
            request.Status = GeneticRequestStatus.Running;
            UpdateGeneticRequest(request);

            // Create or resume chromosome for trading bot configuration
            TradingBotChromosome chromosome;
            Population population;

            if (!string.IsNullOrEmpty(request.BestChromosome) && request.CurrentGeneration > 0)
            {
                // Resume from previous state (best chromosome only)
                chromosome = new TradingBotChromosome(request.EligibleIndicators, request.MaxTakeProfit);
                var savedChromosome = JsonSerializer.Deserialize<double[]>(request.BestChromosome);
                if (savedChromosome != null)
                {
                    chromosome.ReplaceGenes(0, savedChromosome.Select(g => new Gene(g)).ToArray());
                }

                population = new Population(request.PopulationSize, request.PopulationSize, chromosome);
                _logger.LogInformation(
                    "Resuming genetic algorithm for request {RequestId} from generation {Generation} with best chromosome",
                    request.RequestId, request.CurrentGeneration);
            }
            else
            {
                // Start fresh
                chromosome = new TradingBotChromosome(request.EligibleIndicators, request.MaxTakeProfit);
                population = new Population(request.PopulationSize, request.PopulationSize, chromosome);
                _logger.LogInformation("Starting fresh genetic algorithm for request {RequestId}", request.RequestId);
            }

            // Create fitness function first
            var fitness = new TradingBotFitness(_backtester, request);

            // Create genetic algorithm with better configuration
            var ga = new GeneticAlgorithm(
                population,
                fitness,
                GetSelection(request.SelectionMethod),
                GetCrossover(request.CrossoverMethod),
                GetMutation(request.MutationMethod))
            {
                Termination = new GenerationNumberTermination(request.Generations),
                MutationProbability = (float)request.MutationRate,
                CrossoverProbability = 0.7f // Fixed crossover rate as in frontend
            };

            // Set the genetic algorithm reference in the fitness function
            fitness.SetGeneticAlgorithm(ga);

            // Custom termination condition that checks for cancellation
            var originalTermination = ga.Termination;
            ga.Termination = new GenerationNumberTermination(request.Generations);

            // Add cancellation check in the generation event

            // Run the genetic algorithm with periodic checks for cancellation
            var generationCount = 0;
            ga.GenerationRan += (sender, e) =>
            {
                generationCount = ga.GenerationsNumber;

                // Update progress every generation
                var bestFitness = ga.BestChromosome?.Fitness ?? 0;
                request.CurrentGeneration = generationCount;
                request.BestFitnessSoFar = bestFitness;

                if (ga.BestChromosome is TradingBotChromosome bestChromosome)
                {
                    var genes = bestChromosome.GetGenes();
                    var geneValues = genes.Select(g =>
                    {
                        if (g.Value is double doubleValue) return doubleValue;
                        if (g.Value is int intValue) return (double)intValue;
                        return Convert.ToDouble(g.Value.ToString());
                    }).ToArray();
                    request.BestChromosome = JsonSerializer.Serialize(geneValues);
                }

                UpdateGeneticRequest(request);

                // Check for cancellation
                if (cancellationToken.IsCancellationRequested)
                {
                    ga.Stop();
                }
            };

            // Run the genetic algorithm
            ga.Start();

            // Check if the algorithm was cancelled
            if (cancellationToken.IsCancellationRequested)
            {
                _logger.LogInformation("Genetic algorithm cancelled for request {RequestId}", request.RequestId);

                // Update request status to pending so it can be resumed
                request.Status = GeneticRequestStatus.Pending;
                UpdateGeneticRequest(request);

                return new GeneticAlgorithmResult
                {
                    BestFitness = request.BestFitnessSoFar ?? 0,
                    BestIndividual = request.BestIndividual ?? "unknown",
                    ProgressInfo = request.ProgressInfo,
                    CompletedAt = DateTime.UtcNow
                };
            }

            // Get the best chromosome
            var bestChromosome = ga.BestChromosome as TradingBotChromosome;
            var bestFitness = ga.BestChromosome?.Fitness ?? 0;

            _logger.LogInformation("Genetic algorithm completed for request {RequestId}. Best fitness: {Fitness}",
                request.RequestId, bestFitness);

            // Update request with results
            request.Status = GeneticRequestStatus.Completed;
            request.CompletedAt = DateTime.UtcNow;
            request.BestFitness = bestFitness;
            request.BestIndividual = bestChromosome?.ToString() ?? "unknown";
            request.ProgressInfo = JsonSerializer.Serialize(new
            {
                generation = ga.GenerationsNumber,
                best_fitness = bestFitness,
                population_size = request.PopulationSize,
                generations = request.Generations,
                completed_at = DateTime.UtcNow
            });

            UpdateGeneticRequest(request);

            // Send notification about the completed genetic algorithm
            try
            {
                await _messengerService.SendGeneticAlgorithmNotification(request, bestFitness, bestChromosome);
            }
            catch (Exception notificationEx)
            {
                _logger.LogWarning(notificationEx, "Failed to send genetic algorithm notification for request {RequestId}", request.RequestId);
            }

            return new GeneticAlgorithmResult
            {
                BestFitness = bestFitness,
                BestIndividual = bestChromosome?.ToString() ?? "unknown",
                ProgressInfo = request.ProgressInfo,
                CompletedAt = DateTime.UtcNow
            };
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Error running genetic algorithm for request {RequestId}", request.RequestId);

            // Update request with error
            request.Status = GeneticRequestStatus.Failed;
            request.ErrorMessage = ex.Message;
            request.CompletedAt = DateTime.UtcNow;
            UpdateGeneticRequest(request);

            throw;
        }
    }

    private ISelection GetSelection(GeneticSelectionMethod selectionMethod)
    {
        return selectionMethod switch
        {
            GeneticSelectionMethod.Elite => new EliteSelection(),
            GeneticSelectionMethod.Roulette => new RouletteWheelSelection(),
            GeneticSelectionMethod.StochasticUniversalSampling => new StochasticUniversalSamplingSelection(),
            GeneticSelectionMethod.Tournament => new TournamentSelection(),
            GeneticSelectionMethod.Truncation => new TruncationSelection(),
            _ => new TournamentSelection()
        };
    }

    private ICrossover GetCrossover(GeneticCrossoverMethod crossoverMethod)
    {
        return crossoverMethod switch
        {
            GeneticCrossoverMethod.AlternatingPosition => new AlternatingPositionCrossover(),
            GeneticCrossoverMethod.CutAndSplice => new CutAndSpliceCrossover(),
            GeneticCrossoverMethod.Cycle => new CycleCrossover(),
            GeneticCrossoverMethod.OnePoint => new OnePointCrossover(),
            GeneticCrossoverMethod.OrderBased => new OrderBasedCrossover(),
            GeneticCrossoverMethod.Ordered => new OrderedCrossover(),
            GeneticCrossoverMethod.PartiallyMapped => new PartiallyMappedCrossover(),
            GeneticCrossoverMethod.PositionBased => new PositionBasedCrossover(),
            GeneticCrossoverMethod.ThreeParent => new ThreeParentCrossover(),
            GeneticCrossoverMethod.TwoPoint => new TwoPointCrossover(),
            GeneticCrossoverMethod.Uniform => new UniformCrossover(),
            GeneticCrossoverMethod.VotingRecombination => new VotingRecombinationCrossover(),
            _ => new UniformCrossover()
        };
    }

    private IMutation GetMutation(GeneticMutationMethod mutationMethod)
    {
        return mutationMethod switch
        {
            GeneticMutationMethod.Displacement => new DisplacementMutation(),
            GeneticMutationMethod.FlipBit => new FlipBitMutation(),
            GeneticMutationMethod.Insertion => new InsertionMutation(),
            GeneticMutationMethod.PartialShuffle => new PartialShuffleMutation(),
            GeneticMutationMethod.ReverseSequence => new ReverseSequenceMutation(),
            GeneticMutationMethod.Twors => new TworsMutation(),
            GeneticMutationMethod.Uniform => new UniformMutation(true),
            _ => new UniformMutation(true)
        };
    }
}

/// <summary>
/// Chromosome representing a trading bot configuration with predefined parameter ranges
/// </summary>
public class TradingBotChromosome : ChromosomeBase
{
    private readonly List<IndicatorType> _eligibleIndicators;
    private readonly double _maxTakeProfit;
    private readonly Random _random = new Random();

    // Gene structure:
    // 0-2: Trading parameters (takeProfit, stopLoss, cooldownPeriod, maxLossStreak)
    // 3-6: Indicator selection (up to 4 indicators)
    // 7+: Indicator parameters (period, fastPeriods, etc.)

    public TradingBotChromosome(List<IndicatorType> eligibleIndicators, double maxTakeProfit)
        : base(4 + 1 + 4 +
               eligibleIndicators.Count * 8) // Trading params + loopback + indicator selection + indicator params
    {
        _eligibleIndicators = eligibleIndicators;
        _maxTakeProfit = maxTakeProfit;

        // Initialize all genes
        for (int i = 0; i < Length; i++)
        {
            ReplaceGene(i, GenerateGene(i));
        }
    }

    public override Gene GenerateGene(int geneIndex)
    {
        if (geneIndex < 4)
        {
            // Trading parameters
            return geneIndex switch
            {
                0 => new Gene(GetRandomInRange((0.9, _maxTakeProfit))), // Take profit (0.9% to max TP)
                1 => new Gene(GetRandomInRange(GeneticService.ParameterRanges["stopLoss"])), // Stop loss
                2 => new Gene(GetRandomIntInRange(GeneticService.ParameterRanges["cooldownPeriod"])), // Cooldown period
                3 => new Gene(GetRandomIntInRange(GeneticService.ParameterRanges["maxLossStreak"])), // Max loss streak
                _ => new Gene(0)
            };
        }
        else if (geneIndex == 4)
        {
            // LoopbackPeriod gene (always between 5 and 20)
            return new Gene(GetRandomIntInRange((5, 20)));
        }
        else if (geneIndex < 9)
        {
            // Indicator selection (0 = not selected, 1 = selected)
            return new Gene(_random.Next(2));
        }
        else
        {
            // Indicator parameters
            var indicatorIndex = (geneIndex - 9) / 8;
            var paramIndex = (geneIndex - 9) % 8;

            if (indicatorIndex < _eligibleIndicators.Count)
            {
                var indicator = _eligibleIndicators[indicatorIndex];
                var paramName = GetParameterName(paramIndex);

                if (paramName != null && GeneticService.IndicatorParamMapping.ContainsKey(indicator))
                {
                    var requiredParams = GeneticService.IndicatorParamMapping[indicator];
                    if (requiredParams.Contains(paramName))
                    {
                        // Use indicator-specific ranges only
                        if (GeneticService.IndicatorParameterRanges.ContainsKey(indicator) &&
                            GeneticService.IndicatorParameterRanges[indicator].ContainsKey(paramName))
                        {
                            var indicatorRange = GeneticService.IndicatorParameterRanges[indicator][paramName];

                            // 70% chance to use default value, 30% chance to use random value within indicator-specific range
                            if (_random.NextDouble() < 0.7)
                            {
                                var defaultValues = GeneticService.DefaultIndicatorValues[indicator];
                                return new Gene(defaultValues[paramName]);
                            }
                            else
                            {
                                return new Gene(GetRandomInRange(indicatorRange));
                            }
                        }
                        else
                        {
                            // If no indicator-specific range is found, use default value only
                            var defaultValues = GeneticService.DefaultIndicatorValues[indicator];
                            return new Gene(defaultValues[paramName]);
                        }
                    }
                }
            }

            return new Gene(0);
        }
    }

    public override IChromosome CreateNew()
    {
        return new TradingBotChromosome(_eligibleIndicators, _maxTakeProfit);
    }

    public override IChromosome Clone()
    {
        var clone = new TradingBotChromosome(_eligibleIndicators, _maxTakeProfit);
        clone.ReplaceGenes(0, GetGenes());
        return clone;
    }

    public List<GeneticIndicator> GetSelectedIndicators()
    {
        var selected = new List<GeneticIndicator>();
        var genes = GetGenes();

        for (int i = 0; i < 4; i++) // Check first 4 indicator slots
        {
            if (genes[5 + i].Value.ToString() == "1" && i < _eligibleIndicators.Count)
            {
                var indicator = new GeneticIndicator
                {
                    Type = _eligibleIndicators[i]
                };

                // Add parameters for this indicator
                var baseIndex = 9 + i * 8;
                var paramName = GetParameterName(0); // period
                if (paramName != null && HasParameter(_eligibleIndicators[i], paramName))
                {
                    indicator.Period = Convert.ToInt32(genes[baseIndex].Value);
                }

                paramName = GetParameterName(1); // fastPeriods
                if (paramName != null && HasParameter(_eligibleIndicators[i], paramName))
                {
                    indicator.FastPeriods = Convert.ToInt32(genes[baseIndex + 1].Value);
                }

                paramName = GetParameterName(2); // slowPeriods
                if (paramName != null && HasParameter(_eligibleIndicators[i], paramName))
                {
                    indicator.SlowPeriods = Convert.ToInt32(genes[baseIndex + 2].Value);
                }

                paramName = GetParameterName(3); // signalPeriods
                if (paramName != null && HasParameter(_eligibleIndicators[i], paramName))
                {
                    indicator.SignalPeriods = Convert.ToInt32(genes[baseIndex + 3].Value);
                }

                paramName = GetParameterName(4); // multiplier
                if (paramName != null && HasParameter(_eligibleIndicators[i], paramName))
                {
                    indicator.Multiplier = Convert.ToDouble(genes[baseIndex + 4].Value);
                }

                paramName = GetParameterName(5); // stochPeriods
                if (paramName != null && HasParameter(_eligibleIndicators[i], paramName))
                {
                    indicator.StochPeriods = Convert.ToInt32(genes[baseIndex + 5].Value);
                }

                paramName = GetParameterName(6); // smoothPeriods
                if (paramName != null && HasParameter(_eligibleIndicators[i], paramName))
                {
                    indicator.SmoothPeriods = Convert.ToInt32(genes[baseIndex + 6].Value);
                }

                paramName = GetParameterName(7); // cyclePeriods
                if (paramName != null && HasParameter(_eligibleIndicators[i], paramName))
                {
                    indicator.CyclePeriods = Convert.ToInt32(genes[baseIndex + 7].Value);
                }

                selected.Add(indicator);
            }
        }

        return selected;
    }

    public TradingBotConfig GetTradingBotConfig(GeneticRequest request)
    {
        var genes = GetGenes();
        var selectedIndicators = GetSelectedIndicators();

        // Ensure we have at least one indicator
        if (!selectedIndicators.Any())
        {
            selectedIndicators.Add(new GeneticIndicator { Type = _eligibleIndicators[0] });
        }

        // Get take profit from chromosome (gene 0)
        var takeProfit = Convert.ToDouble(genes[0].Value);

        // Calculate stop loss based on 1.1:1 risk-reward ratio (gene 1)
        var stopLoss = Convert.ToDouble(genes[1].Value);

        // Ensure minimum 1.1:1 risk-reward ratio and minimum 0.2% to cover fees
        var minStopLossForRR = takeProfit / 1.1;
        var minStopLossForFees = 0.2; // Minimum 0.2% to cover trading fees
        var minStopLoss = Math.Max(minStopLossForRR, minStopLossForFees);
        var maxStopLoss = takeProfit - 0.1; // Ensure SL is less than TP with some buffer

        // Adjust stop loss if it doesn't meet the constraints
        if (stopLoss > maxStopLoss || stopLoss < minStopLoss)
        {
            stopLoss = GetRandomInRange((minStopLoss, maxStopLoss));
        }

        // Get loopback period from gene 4
        var loopbackPeriod = Convert.ToInt32(genes[4].Value);

        // Build scenario using selected indicators
        var scenario = new Scenario($"Genetic_{request.RequestId}_Scenario", loopbackPeriod);

        foreach (var geneticIndicator in selectedIndicators)
        {
            var indicator = ScenarioHelpers.BuildIndicator(
                type: geneticIndicator.Type,
                name: $"Genetic_{geneticIndicator.Type}_{Guid.NewGuid():N}",
                period: geneticIndicator.Period,
                fastPeriods: geneticIndicator.FastPeriods,
                slowPeriods: geneticIndicator.SlowPeriods,
                signalPeriods: geneticIndicator.SignalPeriods,
                multiplier: geneticIndicator.Multiplier,
                stochPeriods: geneticIndicator.StochPeriods,
                smoothPeriods: geneticIndicator.SmoothPeriods,
                cyclePeriods: geneticIndicator.CyclePeriods
            );

            scenario.AddIndicator(indicator);
        }

        var mm = new MoneyManagement
        {
            Name = $"Genetic_{request.RequestId}_MM",
            Timeframe = request.Timeframe,
            StopLoss = Convert.ToDecimal(stopLoss),
            TakeProfit = Convert.ToDecimal(takeProfit),
            Leverage = 1.0m
        };
        mm.FormatPercentage();

        return new TradingBotConfig
        {
            Name = $"Genetic_{request.RequestId}",
            AccountName = "Oda-embedded",
            Ticker = request.Ticker,
            Timeframe = request.Timeframe,
            BotTradingBalance = request.Balance,
            IsForBacktest = true,
            IsForWatchingOnly = false,
            CooldownPeriod = Convert.ToInt32(genes[2].Value),
            MaxLossStreak = Convert.ToInt32(genes[3].Value),
            FlipPosition = false,
            FlipOnlyWhenInProfit = true,
            CloseEarlyWhenProfitable = true,
            MaxPositionTimeHours = 0, // Always 0 to prevent early position cutting
            UseSynthApi = false,
            UseForPositionSizing = false,
            UseForSignalFiltering = false,
            UseForDynamicStopLoss = false,
            Scenario = scenario,
            MoneyManagement = mm,
            RiskManagement = new RiskManagement
            {
                RiskTolerance = RiskToleranceLevel.Moderate
            }
        };
    }

    private double GetRandomInRange((double min, double max) range)
    {
        return _random.NextDouble() * (range.max - range.min) + range.min;
    }

    private int GetRandomIntInRange((double min, double max) range)
    {
        return _random.Next((int)range.min, (int)range.max + 1);
    }

    private string? GetParameterName(int index)
    {
        return index switch
        {
            0 => "period",
            1 => "fastPeriods",
            2 => "slowPeriods",
            3 => "signalPeriods",
            4 => "multiplier",
            5 => "stochPeriods",
            6 => "smoothPeriods",
            7 => "cyclePeriods",
            _ => null
        };
    }

    private bool HasParameter(IndicatorType indicator, string paramName)
    {
        return GeneticService.IndicatorParamMapping.ContainsKey(indicator) &&
               GeneticService.IndicatorParamMapping[indicator].Contains(paramName);
    }
}

/// <summary>
/// Genetic indicator with parameters
/// </summary>
public class GeneticIndicator
{
    public IndicatorType Type { get; set; }
    public int? Period { get; set; }
    public int? FastPeriods { get; set; }
    public int? SlowPeriods { get; set; }
    public int? SignalPeriods { get; set; }
    public double? Multiplier { get; set; }
    public int? StochPeriods { get; set; }
    public int? SmoothPeriods { get; set; }
    public int? CyclePeriods { get; set; }
}

/// <summary>
/// Multi-objective fitness function for trading bot optimization
/// </summary>
public class TradingBotFitness : IFitness
{
    private readonly IBacktester _backtester;
    private readonly GeneticRequest _request;
    private GeneticAlgorithm _geneticAlgorithm;

    public TradingBotFitness(IBacktester backtester, GeneticRequest request)
    {
        _backtester = backtester;
        _request = request;
    }

    public void SetGeneticAlgorithm(GeneticAlgorithm geneticAlgorithm)
    {
        _geneticAlgorithm = geneticAlgorithm;
    }

    public double Evaluate(IChromosome chromosome)
    {
        try
        {
            var tradingBotChromosome = chromosome as TradingBotChromosome;
            if (tradingBotChromosome == null)
                return 0;

            var config = tradingBotChromosome.GetTradingBotConfig(_request);

            // Get current generation number (default to 0 if not available)
            var currentGeneration = _geneticAlgorithm?.GenerationsNumber ?? 0;

            // Run backtest
            var backtest = _backtester.RunTradingBotBacktest(
                config,
                _request.StartDate,
                _request.EndDate,
                _request.User,
                true,
                false, // Don't include candles
                _request.RequestId,
                new
                {
                    generation = currentGeneration
                }
            ).Result;

            // Calculate multi-objective fitness based on backtest results
            var fitness = CalculateFitness(backtest, config);

            return fitness;
        }
        catch (Exception)
        {
            // Return low fitness for failed backtests
            return 0.1;
        }
    }

    private double CalculateFitness(Backtest backtest, TradingBotConfig config)
    {
        if (backtest == null || backtest.Statistics == null)
            return 0.1;

        // Use the comprehensive backtest score directly as fitness
        // The BacktestScorer already includes all important metrics with proper weighting
        return backtest.Score;
    }
}