#region imports
    using System;
    using System.Collections;
    using System.Collections.Generic;
    using System.Linq;
    using System.Globalization;
    using System.Drawing;
    using QuantConnect;
    using QuantConnect.Algorithm.Framework;
    using QuantConnect.Algorithm.Framework.Selection;
    using QuantConnect.Algorithm.Framework.Alphas;
    using QuantConnect.Algorithm.Framework.Portfolio;
    using QuantConnect.Algorithm.Framework.Portfolio.SignalExports;
    using QuantConnect.Algorithm.Framework.Execution;
    using QuantConnect.Algorithm.Framework.Risk;
    using QuantConnect.Algorithm.Selection;
    using QuantConnect.Api;
    using QuantConnect.Parameters;
    using QuantConnect.Benchmarks;
    using QuantConnect.Brokerages;
    using QuantConnect.Commands;
    using QuantConnect.Configuration;
    using QuantConnect.Util;
    using QuantConnect.Interfaces;
    using QuantConnect.Algorithm;
    using QuantConnect.Indicators;
    using QuantConnect.Data;
    using QuantConnect.Data.Auxiliary;
    using QuantConnect.Data.Consolidators;
    using QuantConnect.Data.Custom;
    using QuantConnect.Data.Custom.IconicTypes;
    using QuantConnect.DataSource;
    using QuantConnect.Data.Fundamental;
    using QuantConnect.Data.Market;
    using QuantConnect.Data.Shortable;
    using QuantConnect.Data.UniverseSelection;
    using QuantConnect.Notifications;
    using QuantConnect.Orders;
    using QuantConnect.Orders.Fees;
    using QuantConnect.Orders.Fills;
    using QuantConnect.Orders.OptionExercise;
    using QuantConnect.Orders.Slippage;
    using QuantConnect.Orders.TimeInForces;
    using QuantConnect.Python;
    using QuantConnect.Scheduling;
    using QuantConnect.Securities;
    using QuantConnect.Securities.Equity;
    using QuantConnect.Securities.Future;
    using QuantConnect.Securities.Option;
    using QuantConnect.Securities.Positions;
    using QuantConnect.Securities.Forex;
    using QuantConnect.Securities.Crypto;
    using QuantConnect.Securities.CryptoFuture;
    using QuantConnect.Securities.IndexOption;
    using QuantConnect.Securities.Interfaces;
    using QuantConnect.Securities.Volatility;
    using QuantConnect.Storage;
    using QuantConnect.Statistics;
    using QCAlgorithmFramework = QuantConnect.Algorithm.QCAlgorithm;
    using QCAlgorithmFrameworkBridge = QuantConnect.Algorithm.QCAlgorithm;
    using Calendar = QuantConnect.Data.Consolidators.Calendar;
#endregion
namespace QuantConnect.Algorithm.CSharp
{
    public class Test : QCAlgorithm
    {
        private const decimal _gapThreshold = 5m;
        private const decimal _minRDV = 2m;
        private const int _volumeLookback = 30;

        private readonly Dictionary<Symbol, decimal> _previousCloses = new Dictionary<Symbol, decimal>();
        private readonly Dictionary<Symbol, RelativeDailyVolume> _rdvIndicators = new Dictionary<Symbol, RelativeDailyVolume>();
        private readonly List<Symbol> _gapUpSymbols = new List<Symbol>();

        public override void Initialize()
        {
            SetStartDate(2025, 2, 13);
            SetCash(100000);

            UniverseSettings.ExtendedMarketHours = true;
            UniverseSettings.Resolution = Resolution.Minute;
            UniverseSettings.Leverage = 1.0m;

            AddUniverse(CoarseSelectionFilter);

            var openTicker = AddEquity("SPY").Symbol;

            Schedule.On(DateRules.EveryDay(),
                TimeRules.BeforeMarketOpen(openTicker, 15, true),
                CheckPreMarketGaps
            );

            Schedule.On(DateRules.EveryDay(),
                TimeRules.AfterMarketOpen(openTicker, 0),
                ExecuteTrades
            );

            Schedule.On(DateRules.EveryDay(),
                TimeRules.BeforeMarketClose(openTicker, 0),
                LiquidateAllPositions
            );
        }

        private IEnumerable<Symbol> CoarseSelectionFilter(IEnumerable<CoarseFundamental> coarse)
        {
            return coarse
                .Where(x => x.HasFundamentalData && x.Price > 5 && x.Price < 100 && x.DollarVolume > 1000000)
                .OrderByDescending(x => x.DollarVolume)
                .Take(2000)
                .Select(x => x.Symbol);
        }

        public override void OnSecuritiesChanged(SecurityChanges changes)
        {
            foreach (var security in changes.AddedSecurities)
            {
                // Initialize built-in RelativeDailyVolume indicator
                var rdv = new RelativeDailyVolume(_volumeLookback);
                _rdvIndicators[security.Symbol] = rdv;

                // Register indicator to automatically update with data
                RegisterIndicator(security.Symbol, rdv, Resolution.Daily);

                // Warm-up indicator with historical data
                var history = History<TradeBar>(security.Symbol, _volumeLookback + 1, Resolution.Daily);
                foreach (var bar in history)
                {
                    rdv.Update(bar);
                }

                // Get previous regular session close
                var dailyHistory = History(security.Symbol, 1, Resolution.Daily)
                    .Where(b => b.EndTime.TimeOfDay == TimeSpan.Zero);

                if (dailyHistory.Any())
                {
                    _previousCloses[security.Symbol] = dailyHistory.Last().Close;
                }
            }

            foreach (var security in changes.RemovedSecurities)
            {
                _rdvIndicators.Remove(security.Symbol);
                _previousCloses.Remove(security.Symbol);
            }
        }

        private void CheckPreMarketGaps()
        {
            _gapUpSymbols.Clear();

            foreach (var kvp in _previousCloses)
            {
                var symbol = kvp.Key;
                var security = Securities[symbol];

                // Get latest pre-market price
                var bar = security.GetLastData();
                if (bar == null || bar.EndTime < Time.AddMinutes(-5)) continue;

                var currentPrice = bar.Price;
                var previousClose = kvp.Value;

                if (previousClose == 0 || currentPrice == 0) continue;

                // Calculate gap percentage
                var gapPercentage = ((currentPrice - previousClose) / previousClose) * 100;

                // Get RDV value
                var rdv = _rdvIndicators[symbol];
                if (!rdv.IsReady) continue;

                if (gapPercentage >= _gapThreshold && rdv.Current.Value >= _minRDV)
                {
                    _gapUpSymbols.Add(symbol);
                    Log($"Qualified: {symbol} | Gap: {gapPercentage:N2}% | RDV: {rdv.Current.Value:N2}");
                }
            }
        }

        private void ExecuteTrades()
        {
            if (_gapUpSymbols.Count == 0) return;

            var weight = 0.9m / _gapUpSymbols.Count;
            foreach (var symbol in _gapUpSymbols)
            {
                if (_rdvIndicators[symbol].Current.Value < _minRDV)
                {
                    // Final volume check at market open
                    continue;
                }

                var quantity = CalculateOrderQuantity(symbol, weight);
                MarketOrder(symbol, quantity);
            }
        }

        private void LiquidateAllPositions()
        {
            Liquidate();
            _gapUpSymbols.Clear();
        }

        public override void OnData(Slice data)
        {
            // Built-in indicators update automatically via RegisterIndicator
            // No need for manual updates here
        }
    }
}