/*
 * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
 * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
*/

using System;
using System.Linq;
using QuantConnect.Util;
using QuantConnect.Orders;
using System.Collections.Generic;
using QuantConnect.Securities.Option;
using QuantConnect.Securities.Option.StrategyMatcher;

namespace QuantConnect.Securities.Positions
{
    /// <summary>
    /// Class in charge of resolving option strategy groups which will use the <see cref="OptionStrategyPositionGroupBuyingPowerModel"/>
    /// </summary>
    public class OptionStrategyPositionGroupResolver : IPositionGroupResolver
    {
        private readonly SecurityManager _securities;
        private readonly OptionStrategyMatcher _strategyMatcher;

        /// <summary>
        /// Creates the default option strategy group resolver for <see cref="OptionStrategyDefinitions.AllDefinitions"/>
        /// </summary>
        public OptionStrategyPositionGroupResolver(SecurityManager securities)
            : this(securities, OptionStrategyMatcherOptions.ForDefinitions(OptionStrategyDefinitions.AllDefinitions))
        {
        }

        /// <summary>
        /// Creates a custom option strategy group resolver
        /// </summary>
        /// <param name="strategyMatcherOptions">The option strategy matcher options instance to use</param>
        /// <param name="securities">The algorithms securities</param>
        public OptionStrategyPositionGroupResolver(SecurityManager securities, OptionStrategyMatcherOptions strategyMatcherOptions)
        {
            _securities = securities;
            _strategyMatcher = new OptionStrategyMatcher(strategyMatcherOptions);
        }

        /// <summary>
        /// Attempts to group the specified positions into a new <see cref="IPositionGroup"/> using an
        /// appropriate <see cref="IPositionGroupBuyingPowerModel"/> for position groups created via this
        /// resolver.
        /// </summary>
        /// <param name="newPositions">The positions to be grouped</param>
        /// <param name="currentPositions">The currently grouped positions</param>
        /// <param name="group">The grouped positions when this resolver is able to, otherwise null</param>
        /// <returns>True if this resolver can group the specified positions, otherwise false</returns>
        public bool TryGroup(IReadOnlyCollection<IPosition> newPositions, PositionGroupCollection currentPositions, out IPositionGroup @group)
        {
            IEnumerable<IPosition> positions;
            if (currentPositions.Count > 0)
            {
                var impactedGroups = GetImpactedGroups(currentPositions, newPositions);
                var positionsToConsiderInNewGroup = impactedGroups.SelectMany(positionGroup => positionGroup.Positions);
                positions = newPositions.Concat(positionsToConsiderInNewGroup);
            }
            else
            {
                if (newPositions.Count == 1)
                {
                    // there's no existing position and there's only a single position, no strategy will match
                    @group = null;
                    return false;
                }
                positions = newPositions;
            }

            @group = GetPositionGroups(positions)
                .Select(positionGroup =>
                {
                    if (positionGroup.Count == 0)
                    {
                        return positionGroup;
                    }

                    if (newPositions.Any(position => positionGroup.TryGetPosition(position.Symbol, out position)))
                    {
                        return positionGroup;
                    }

                    // When none of the new positions are contained in the position group,
                    // it means that we are liquidating the assets in the new positions
                    // but some other existing positions were considered as impacted groups.
                    // Example:
                    //   Buy(OptionStrategies.BullCallSpread(...), 1);
                    //   Buy(OptionStrategies.BearPutSpread(...), 1);
                    //   ...
                    //   Sell(OptionStrategies.BullCallSpread(...), 1);
                    //   Sell(OptionStrategies.BearPutSpread(...), 1);
                    //   -----
                    //   When attempting revert the bull call position group, the bear put group
                    //   will be selected as impacted group, so the group will contain the put positions
                    //   but not the call ones. In this case, we return an valid empty group because the
                    //   liquidation is happening.
                    return PositionGroup.Empty(new OptionStrategyPositionGroupBuyingPowerModel(null));
                })
                .Where(positionGroup => positionGroup != null)
                .FirstOrDefault();

            return @group != null;
        }

        /// <summary>
        /// Resolves the position groups that exist within the specified collection of positions.
        /// </summary>
        /// <param name="positions">The collection of positions</param>
        /// <returns>An enumerable of position groups</returns>
        public PositionGroupCollection Resolve(PositionCollection positions)
        {
            var result = PositionGroupCollection.Empty;

            var groups = GetPositionGroups(positions).ToList();
            if (groups.Count != 0)
            {
                result = new PositionGroupCollection(groups);

                // we are expected to remove any positions which we resolved into a position group
                positions.Remove(result);
            }

            return result;
        }

        /// <summary>
        /// Determines the position groups that would be evaluated for grouping of the specified
        /// positions were passed into the <see cref="Resolve"/> method.
        /// </summary>
        /// <remarks>
        /// This function allows us to determine a set of impacted groups and run the resolver on just
        /// those groups in order to support what-if analysis
        /// </remarks>
        /// <param name="groups">The existing position groups</param>
        /// <param name="positions">The positions being changed</param>
        /// <returns>An enumerable containing the position groups that could be impacted by the specified position changes</returns>
        public IEnumerable<IPositionGroup> GetImpactedGroups(PositionGroupCollection groups, IReadOnlyCollection<IPosition> positions)
        {
            if(groups.Count == 0)
            {
                // there's no existing groups, nothing to impact
                return Enumerable.Empty<IPositionGroup>();
            }

            var symbolsSet = positions.Where(position => position.Symbol.SecurityType.HasOptions() || position.Symbol.SecurityType.IsOption())
                .SelectMany(position =>
                {
                    return position.Symbol.HasUnderlying ? new[] { position.Symbol, position.Symbol.Underlying } : new[] { position.Symbol };
                })
                .ToHashSet();

            if (symbolsSet.Count == 0)
            {
                return Enumerable.Empty<IPositionGroup>();
            }

            // will select groups for which we actually hold some security quantity and any of the changed symbols or underlying are in it if they are options
            return groups.Where(group => group.Quantity != 0
                && group.Positions.Any(position1 => symbolsSet.Contains(position1.Symbol)
                    || position1.Symbol.HasUnderlying && position1.Symbol.SecurityType.IsOption() && symbolsSet.Contains(position1.Symbol.Underlying)));
        }

        private IEnumerable<IPositionGroup> GetPositionGroups(IEnumerable<IPosition> positions)
        {
            foreach (var positionsByUnderlying in positions
                .Where(position => position.Symbol.SecurityType.HasOptions() || position.Symbol.SecurityType.IsOption())
                .GroupBy(position => position.Symbol.HasUnderlying? position.Symbol.Underlying : position.Symbol)
                .Select(x => x.ToList()))
            {
                var optionPosition = positionsByUnderlying.FirstOrDefault(position => position.Symbol.SecurityType.IsOption());
                if (optionPosition == null)
                {
                    // if there isn't any option position we aren't really interested, can't create any option strategy!
                    continue;
                }
                var contractMultiplier = (_securities[optionPosition.Symbol].SymbolProperties as OptionSymbolProperties)?.ContractUnitOfTrade ?? 100;

                var optionPositionCollection = OptionPositionCollection.FromPositions(positionsByUnderlying, contractMultiplier);

                if (optionPositionCollection.Count == 0 && positionsByUnderlying.Count > 0)
                {
                    // we could be liquidating there will be no position left!
                    yield return PositionGroup.Empty(new OptionStrategyPositionGroupBuyingPowerModel(null));
                    yield break;
                }

                var matches = _strategyMatcher.MatchOnce(optionPositionCollection);
                if (matches.Strategies.Count == 0)
                {
                    continue;
                }

                foreach (var matchedStrategy in matches.Strategies)
                {
                    var groupQuantity = Math.Abs(matchedStrategy.OptionLegs.Cast<Leg>().Concat(matchedStrategy.UnderlyingLegs)
                        .Select(leg => leg.Quantity)
                        .GreatestCommonDivisor());
                    var positionsToGroup = matchedStrategy.OptionLegs
                        .Select(optionLeg => (IPosition)new Position(optionLeg.Symbol, optionLeg.Quantity,
                            // The unit quantity of each position is the ratio of the quantity of the leg to the group quantity.
                            // e.g. a butterfly call strategy three legs: 10:-20:10, the unit quantity of each leg is 1:2:1
                            Math.Abs(optionLeg.Quantity) / groupQuantity))
                        .Concat(matchedStrategy.UnderlyingLegs.Select(underlyingLeg => new Position(underlyingLeg.Symbol,
                            underlyingLeg.Quantity * contractMultiplier,
                            // Same as for the option legs, but we need to multiply by the contract multiplier.
                            // e.g. a covered call strategy has 100 shares of the underlying, per shorted contract
                            (Math.Abs(underlyingLeg.Quantity) * contractMultiplier / groupQuantity))))
                        .ToDictionary(position => position.Symbol);

                    yield return new PositionGroup(
                        new PositionGroupKey(new OptionStrategyPositionGroupBuyingPowerModel(matchedStrategy), positionsToGroup.Values),
                        groupQuantity,
                        positionsToGroup);
                }
            }
        }
    }
}