#region imports

using System;
using System.Linq;
using QuantConnect.Brokerages;
using QuantConnect.Data;
using QuantConnect.Data.Market;
using QuantConnect.Orders;
using QuantConnect.Securities;
using QuantConnect.Securities.Future;
using QuantConnect.Securities.FutureOption;
using QuantConnect.Securities.Option;
using QCAlgorithmFramework = QuantConnect.Algorithm.QCAlgorithm;
using QCAlgorithmFrameworkBridge = QuantConnect.Algorithm.QCAlgorithm;

#endregion

namespace QuantConnect.Algorithm.CSharp
{
    public class LogFuturesOptionsAlgorithm : QCAlgorithm
    {
        Future future;

        public override void Initialize()
        {
            SetStartDate(2023, 6, 25);
            SetEndDate(2023, 6, 27);
            SetCash(500000);

            future = AddFuture(Futures.Indices.SP500EMini, Resolution.Minute, Market.CME, extendedMarketHours: true);
            future.SetFilter(0, 90);
            AddFutureOption(future.Symbol, universe => universe.Strikes(-1, 1));

            var _futureContractSymbol = 
                QuantConnect.Symbol.CreateFuture(Futures.Indices.SP500EMini, Market.CME, new DateTime(2023, 9, 15));

            var _optionContractSymbol = QuantConnect.Symbol.CreateOption(_futureContractSymbol,
                Market.CME, OptionStyle.American, OptionRight.Call, 4400, new DateTime(2023, 6, 28));

            var optionContractSymbols = OptionChainProvider.GetOptionContractList(_futureContractSymbol, Time).ToList();
            foreach (var symbol in optionContractSymbols.DistinctBy(s=>s.ID.Date)) Log(symbol.ID.Date.ToShortDateString());
            
            var expiry = optionContractSymbols.Select(symbol => symbol.ID.Date).Min();
            var filteredSymbols = optionContractSymbols.Where(symbol =>
                symbol.ID.Date == expiry && symbol.ID.OptionRight == OptionRight.Call);
            _optionContractSymbol = filteredSymbols.OrderByDescending(symbol => symbol.ID.StrikePrice).Last();

            var option = AddFutureOptionContract(_optionContractSymbol, Resolution.Minute, extendedMarketHours: true);
            option.PriceModel = OptionPriceModels.BjerksundStensland();
        }


        public override void OnData(Slice slice)
        {
            LogFuturesOptions(slice);
        }

        private void LogFuturesOptions(Slice slice)
        {
            LogOptionChains(slice);

            foreach (var kvp in slice.FuturesChains)
            {
                var continuousContractSymbol = kvp.Key;
                var futuresChain = kvp.Value;

                Log(continuousContractSymbol + " " + futuresChain.Contracts.First().Key);

                // Select a Future Contract and create its canonical FOP Symbol
                var futuresContract = futuresChain.First();
                var canonicalFOPSymbol = QuantConnect.Symbol.CreateCanonicalOption(futuresContract.Symbol);

                if (slice.OptionChains.TryGetValue(canonicalFOPSymbol, out var fopChain))
                {
                    foreach (var contract in fopChain)
                    {
                        Log(contract.Symbol);
                    }
                }
            }
        }

        void LogOptionChains(Slice slice)
        {
            if (!slice.OptionChains.Any()) Log("# Slice has no OptionChains");
            foreach (var chain in slice.OptionChains)
            {
                Log(chain.Key + " " + chain.Key.ID.Date);                
            }
        }

    }
}