using System;
using System.Collections.Generic;
using MarketData.MarketDataModel;
using MarketData.DataAccess;
using MarketData.Utils;
using System.Linq;
using MarketData.Numerical;
using MarketData.Cache;
using System.Configuration;

// Filename: MGSHMomentumGenerator.cs
// Author:Sean Kessler
// Date:02/2025
// Summary: This model was adapted from th MGMomentum model.  This new model adds the following new functionality
// 1) Places stop limits on positions.  This is configurable
// 2) Incorporates ability to buy a hedge position.  This is configurable
// 3) The model does not sell all positions at month end.  Instead, it holds positions until they stop out.  This is configurable

//BetaGenerator.Beta(symbol,tradeDate,cmtParams.BetaMonths);      // beta months is 6

namespace MarketData.Generator.MGSHMomentum
{
  /// <summary>Generate momentum selections - </summary>
  public class MGSHMomentumGenerator
  {
    public enum MomentumGeneratorConstants{DayCount=252};  // Trading days in one year

    private MGSHMomentumGenerator()
    {
    }
// These two interfaces are used by the UI so that it can capture the fallback candidates
    public static MGSHMomentumCandidates GenerateMomentum(DateTime tradeDate,MGSHConfiguration config)
    {
      List<String> symbolsHeld=new List<String>();
      return new MGSHMomentumCandidates(GenerateMomentum(tradeDate,symbolsHeld,config).Take(config.MaxPositions).ToList());
    }
    public static MGSHMomentumCandidates GenerateMomentumWithFallback(DateTime tradeDate,MGSHConfiguration config)
    {
      List<String> symbolsHeld=new List<String>();
      MGSHMomentumCandidates momentumCandidates=GenerateMomentum(tradeDate,symbolsHeld,config);
      MGSHQualityIndicator qualityIndicator=new MGSHQualityIndicator(config.QualityIndicatorType);
      if((null==momentumCandidates||0==momentumCandidates.Count)&&config.UseFallbackCandidate)
      {
        QualityIndicatorCandidate bestCandidate=null;
        if(null!=config.FallbackCandidateBestOf && !"".Equals(config.FallbackCandidateBestOf))
        {
          bestCandidate=CandidateSelector.SelectBestCandidate(qualityIndicator,Utility.ToList(config.FallbackCandidateBestOf),config.FallbackCandidate,tradeDate);
          if(null!=bestCandidate)
          {
            MGSHMomentumCandidate momentumCandidate=new MGSHMomentumCandidate();
            momentumCandidate.Symbol=bestCandidate.Symbol;
            momentumCandidate.AnalysisDate=tradeDate;
            momentumCandidate.CumReturn252=bestCandidate.CumReturn252;
            momentumCandidate.IDIndicator=bestCandidate.IDIndicator;
            momentumCandidate.Score=bestCandidate.Score;
            momentumCandidate.DayCount=bestCandidate.DayCount;
            momentumCandidate.PE=bestCandidate.PE;
            momentumCandidate.Beta=bestCandidate.Beta;
            momentumCandidate.Return1D=bestCandidate.Return1D;
            momentumCandidates=new MGSHMomentumCandidates();
            momentumCandidates.Add(momentumCandidate);
          }
        }
      }
      return momentumCandidates;
    }
// This interface is called by the Backtest 
    public static MGSHMomentumCandidates GenerateMomentum(DateTime tradeDate,List<String> symbolsHeld,MGSHConfiguration config)
    {
      DateGenerator dateGenerator=new DateGenerator();
      List<String> symbols=PricingDA.GetSymbols();
      MGSHMomentumCandidates momentumCandidates=new MGSHMomentumCandidates();
      MGSHMomentumCandidates highPECandidates=new MGSHMomentumCandidates();
      DateTime startDateOfReturns=dateGenerator.GetPrevMonthEnd(tradeDate,2); 
      List<String> noTradeSymbols=Utility.ToList(config.NoTradeSymbols);
      List<String> noTradeFinancialSymbols=Utility.ToList(config.NoTradeFinancialSymbols);
      CandidateViolations candidateViolations = new CandidateViolations();

      MDTrace.WriteLine(LogLevel.DEBUG,String.Format("Generate momentum.. examining candidates"));
// Go through the universe of stocks 
      for(int index=0;index<symbols.Count;index++)
      {
        String symbol=symbols[index];
        if(0==(index%500))Console.WriteLine("Processing item {0} of {1}",index+1,symbols.Count);

// Check if the symbol is held in any open positions
        if(symbolsHeld.Any(x=>x.Equals(symbol, StringComparison.CurrentCultureIgnoreCase)))
        {
          candidateViolations.Add(new CandidateViolation(symbol,"Candidate already held."));
          continue;
        }

// Check if the symbol is in the no trade list (i.e.) Bitcoin etc.,
        if(noTradeSymbols.Any(x=>x.Equals(symbol, StringComparison.CurrentCultureIgnoreCase)))
        {
          candidateViolations.Add(new CandidateViolation(symbol,"Candidate in NoTradeSymbol."));
          continue;
        }

// Check MarketCap, EBITDA, PE, and Revenue Per Share
        Fundamental fundamental=FundamentalDA.GetFundamentalMaxDate(symbol,tradeDate);
        if(null==fundamental)
        {
          candidateViolations.Add(new CandidateViolation(symbol,"Candidate no fundamental."));
          continue;
        }

        if(!(fundamental.MarketCap>=config.MarketCapLowerLimit))
        {
          candidateViolations.Add(new CandidateViolation(symbol,"Candidate MarketCapLimit."));
          continue;
        } 

        if(config.UseEBITDAScreen && (double.IsNaN(fundamental.EBITDA)||fundamental.EBITDA<=0))
        {  
          candidateViolations.Add(new CandidateViolation(symbol,"Candidate EBITDA violation."));
          continue;
        }

        if(config.UseRevenuePerShareScreen && (double.IsNaN(fundamental.RevenuePerShare)||fundamental.RevenuePerShare<0.00))
        {
          candidateViolations.Add(new CandidateViolation(symbol,"Candidate RevenuePerShare violation."));
          continue;
        }

// Initial PE screening.  This screen checks for existance of PE and if it is availabe it must be >0.00 .  There is another PE based on limits further below
        if(config.UsePEScreen && (double.IsNaN(fundamental.PE)||fundamental.PE<=0.00))
        {
          candidateViolations.Add(new CandidateViolation(symbol,"Candidate PE violation."));
          continue;
        }

// Exclude any company in the "Financial" sector
        CompanyProfile companyProfile=CompanyProfileDA.GetCompanyProfile(symbol);
        if(null!=companyProfile&&null!=companyProfile.Sector&&noTradeFinancialSymbols.Any(x=>x.Equals(companyProfile.Sector)))
        {
          candidateViolations.Add(new CandidateViolation(symbol,"Candidate Financial Sector violation."));
          continue;
        }

// Fetch single day price
        Price price=GBPriceCache.GetInstance().GetPrice(symbol,tradeDate);
        if(null==price)
        {
          candidateViolations.Add(new CandidateViolation(symbol,"Candidate missing price on trade date."));
          continue;
        }
// Filter penny stocks - don't trade anything less than $1.00
        if(price.Close<1.00||price.Open<1.00)
        {
          candidateViolations.Add(new CandidateViolation(symbol,"Candidate penny stock violation."));
          continue;
        }

// Retrieve prices                    
        Prices prices=null;
        prices=GBPriceCache.GetInstance().GetPrices(symbol,tradeDate,(int)MomentumGeneratorConstants.DayCount);
        if(null==prices||prices.Count!=(int)MomentumGeneratorConstants.DayCount)
        {
          candidateViolations.Add(new CandidateViolation(symbol,"Candidate missing price history."));
          continue;
        }

// calculate the one day return
        double return1D=prices.GetReturn1D();

// Liquidity check - if any day has volume < 10,000 then we reject it
       if(((from Price xPrice in prices where xPrice.Volume<10000 select xPrice).Count())>1)
       {
          candidateViolations.Add(new CandidateViolation(symbol,"Liquidity violation."));
         continue;
       }

// Calculate velocity as a percentage range of the open price within the 252+20 day range of prices - This is used for display purposes 
        double velocity;
        Prices velocityPrices=GBPriceCache.GetInstance().GetPrices(symbol,tradeDate,(int)MGSHMomentumGenerator.MomentumGeneratorConstants.DayCount+20);
        double priceHigh=(from Price selectPrice in velocityPrices select selectPrice.Open).Max();
        double priceLow=(from Price selectPrice in velocityPrices select selectPrice.Open).Min();
        if(0.00==priceHigh-priceLow)velocity=0.00;
        else velocity=((price.Open-priceLow)*(100/(priceHigh-priceLow)))/100.00;

// Price slopes - These are used for display purposes
        double[] pricesArray=null;
        LeastSquaresResult leastSquaresResult;

// Beta - first capture the fundamental beta and then determine whether we will calculate our own
        double beta = fundamental.Beta;

        if(config.UseBetaGenerator)
        {
          beta = BetaGenerator.Beta(symbol, config.UseBetaGeneratorMonths, false);    
          if(double.IsNaN(beta))
          {
            candidateViolations.Add(new CandidateViolation(symbol,"No Beta violation."));
            continue;
          }
        }

// Get the benchmark pricing low pricing data and check the slope of previous lows; only if Beta of candidate is >= LowSlopeBetaThreshhold
// The idea behind this check is that a high beta stock will track to the benchmark.  So if the benchmark lows are forming a downward pattern then we
// assume that this is a somewhat bearish condition.  The config has the setting at a 15 day check and the threshold beta set to 1.00
        if(config.UseLowSlopeBetaCheck && beta >= config.LowSlopeBetaThreshhold)
        {
          Prices benchmarkPrices=GBPriceCache.GetInstance().GetPrices(config.Benchmark,tradeDate,config.LowSlopeBetaDays);
          pricesArray=Numerics.ToDouble(benchmarkPrices.GetPricesLow());
          leastSquaresResult=Numerics.LeastSquares(pricesArray);
          double slopeBmk=leastSquaresResult.Slope;
          if(slopeBmk<0)
          {
            candidateViolations.Add(new CandidateViolation(symbol,"Beta threshhold violation."));
            continue;
          }
        }

// *** MACDSignal detection
        if(config.UseMACD)
        {
          MACDSetup macdSetup=new MACDSetup(config.MACDSetup);
          MACDSignals macdSignals=MACDGenerator.GenerateMACD(prices,macdSetup);
          Signals signalsMACD = SignalGenerator.GenerateSignals(macdSignals);
          signalsMACD=new Signals(signalsMACD.Take(config.MACDSignalDays).ToList());
          int weakSellSignals=(from Signal signal in signalsMACD where signal.IsWeakSell() select signal).Count();
          int strongSellSignals=(from Signal signal in signalsMACD where signal.IsStrongSell() select signal).Count();
          if(config.MACDRejectWeakSellSignals && weakSellSignals>0)
          {
            candidateViolations.Add(new CandidateViolation(symbol,"MACD Reject Weak Sell violation."));
            continue;
          }
          if(config.MACDRejectStrongSellSignals && strongSellSignals>0)
          {
            candidateViolations.Add(new CandidateViolation(symbol,"MACD Reject Strong Sell violation."));
            continue;
          }
        }

// *** Stochastics oscillator 
        if(config.UseStochastics)
        {
          Stochastics stochastics=StochasticsGenerator.GenerateStochastics(prices);
          Signals signalsStochastics=new Signals(SignalGenerator.GenerateSignals(stochastics).OrderByDescending(x => x.SignalDate).ToList());
          signalsStochastics=new Signals(signalsStochastics.Take(config.StochasticsSignalDays).ToList());
          int weakSellCount=(from Signal signal in signalsStochastics where signal.IsWeakSell() select signal).Count();
          int strongSellCount=(from Signal signal in signalsStochastics where signal.IsStrongSell() select signal).Count();
          if(config.StochasticsRejectStrongSells&&strongSellCount>0)
          { 
            candidateViolations.Add(new CandidateViolation(symbol,"Stochastics Oscillator Reject Strong Sell violation."));
            continue;
          }
          if(config.StochasticsRejectWeakSells&&weakSellCount>0)
          { 
            candidateViolations.Add(new CandidateViolation(symbol,"Stochastics Oscillator Reject Weak Sell violation."));
            continue;
          }
        }

// Analyst Ratings - "Downgrades" that are more than a year old (252 days) are not considered.  Mean reversion.... bad companies improve, good companies decline.
        DateTime minRatingDate=dateGenerator.GenerateHistoricalDate(startDateOfReturns,(int)MomentumGeneratorConstants.DayCount);
        AnalystRatings analystRatings=AnalystRatingsDA.GetAnalystRatingsMaxDateNoZacks(symbol,tradeDate);
        analystRatings.RemoveAll(x => x.Date<minRatingDate);
        AnalystRating rating=null;
        if(null!=analystRatings)rating=(from AnalystRating analystRating in analystRatings where analystRating.Type.Equals("Downgrades") select analystRating).FirstOrDefault();
        if(null!=rating)
        {
          candidateViolations.Add(new CandidateViolation(symbol,"AnalystRating Downgrade violation within set period."));
          continue;
        }

// The cumulative returns for the ranking skip to the previous month to eliminate short term reversal anomaly  (Wesley Gray : Quantum Momentum)
        prices=GBPriceCache.GetInstance().GetPrices(symbol,startDateOfReturns,(int)MomentumGeneratorConstants.DayCount);
        if(null==prices||(int)MomentumGeneratorConstants.DayCount!=prices.Count)
        {
          candidateViolations.Add(new CandidateViolation(symbol,"Insufficient pricing, cannot determine rank."));
          continue;
        }

// check for outliers in the return stream
        float[] returns = default;
        returns=prices.GetReturns();
        if((from float value in returns where Math.Abs(value)>.50 select value).Count()>0)
        {
          candidateViolations.Add(new CandidateViolation(symbol,"Candidate pricing contains outliers in the returns."));
          continue;
        }
// Cumulative return
        double cumulativeReturn=prices.GetCumulativeReturn();
        if(cumulativeReturn<.10)
        {
          candidateViolations.Add(new CandidateViolation(symbol,"Candidate cumulative returns below threshhold."));
          continue;
        }

// Apply the PEScreening last because there an option to permit the inclusion of the high PE candidates if we have no other available candidates.
// The idea is to try to avoid high PE stocks as they are more likey to introduce drawdowns as backtests have shown.
        if(config.UseMaxPEScreen && !double.IsNaN(fundamental.PE) && fundamental.PE>config.MaxPE)
        {
            candidateViolations.Add(new CandidateViolation(symbol,"PE violation."));
            MGSHMomentumCandidate highPECandidate=new MGSHMomentumCandidate();
            highPECandidate.AnalysisDate=tradeDate;
            highPECandidate.Symbol=symbol;
            highPECandidate.CumReturn252=prices.GetCumulativeReturn();
            highPECandidate.DayCount=(int)MomentumGeneratorConstants.DayCount;
            highPECandidate.IDIndicator=IDIndicator.Calculate(prices);
            highPECandidate.Score=ScoreIndicator.Calculate(prices);
            highPECandidate.PE=fundamental.PE;
            highPECandidate.Beta=beta;
            highPECandidate.Velocity=velocity;
            highPECandidate.Volume=price.Volume;
            highPECandidate.Return1D=return1D;
            highPECandidates.Add(highPECandidate);
            continue;
        }
// *********************************************************************** C A N D I D A T E  A C C E P T A N C E *******************************************************
// At this point whatever remains is taken so initialize the candidate and add to list
        MGSHMomentumCandidate momentumCandidate=new MGSHMomentumCandidate();
        momentumCandidate.AnalysisDate=tradeDate;
        momentumCandidate.Symbol=symbol;
        momentumCandidate.CumReturn252=prices.GetCumulativeReturn();
        momentumCandidate.DayCount=(int)MomentumGeneratorConstants.DayCount;
        momentumCandidate.IDIndicator=IDIndicator.Calculate(prices); 
        momentumCandidate.Score=ScoreIndicator.Calculate(prices);
        momentumCandidate.PE=fundamental.PE;
        momentumCandidate.Beta=beta;
        momentumCandidate.Velocity=velocity;
        momentumCandidate.Volume=price.Volume;
        momentumCandidate.Return1D=return1D;
        momentumCandidates.Add(momentumCandidate);

      }  // for all symbols

      if(0!=candidateViolations.Count)
      {
        MDTrace.WriteLine(LogLevel.DEBUG,"**************** C A N D I D A T E   S U M M A R Y  ************************");
        IEnumerable<Tuple<string, int>> groups = candidateViolations.GroupBy(x => x.ReasonCategory).OrderByDescending(group => group.Count()).Select(group => Tuple.Create(group.Key, group.Count()));
        foreach(Tuple<string, int> group in groups)
        {
          MDTrace.WriteLine(LogLevel.DEBUG,String.Format("Group: {0} Count:{1}",group.Item1, group.Item2));
        }
      }
      MDTrace.WriteLine(LogLevel.DEBUG,String.Format($"Total Considered : {momentumCandidates.Count+candidateViolations.Count}"));
      MDTrace.WriteLine(LogLevel.DEBUG,String.Format($"Total Disqualified : {candidateViolations.Count}"));
      MDTrace.WriteLine(LogLevel.DEBUG,String.Format($"Total Eligible : {momentumCandidates.Count}"));
      MDTrace.WriteLine(LogLevel.DEBUG,"******************************************************************************************************");

// ********************************************************* E N D  C A N D I D A T E  S E L E C T I O N   C R I T E R I A  ****************************************
//  If we wind up with less than the number of required candidates then check the StrictMaxPE
//  flag and, if allowed, add the highPECandidate (that we've accumulated but skipped) to the momentumCandidates ordering them by the Lowest PE
      if(!config.StrictMaxPE && momentumCandidates.Count<config.MaxPositions && highPECandidates.Count>0)
      {
        int takeCandidates=config.MaxPositions-momentumCandidates.Count;
        highPECandidates=new MGSHMomentumCandidates(highPECandidates.OrderBy(x=>x.PE).Take(takeCandidates).ToList());
        momentumCandidates.AddRange(highPECandidates);
        if(config.Verbose)MDTrace.WriteLine(LogLevel.DEBUG,String.Format("High PE Candidates,{0}",Utility.FromList((from MGSHMomentumCandidate momentumCandidate in highPECandidates select momentumCandidate.Symbol).ToList())));
      }

      MGSHQualityIndicator qualityIndicator=new MGSHQualityIndicator(config.QualityIndicatorType);
      if(qualityIndicator.Quality.Equals(MGSHQualityIndicator.QualityType.IDIndicator))
      {
        momentumCandidates=new MGSHMomentumCandidates((from MGSHMomentumCandidate momentumCandidate in momentumCandidates orderby momentumCandidate.IDIndicator ascending, momentumCandidate.CumReturn252 descending, momentumCandidate.Return1D descending, momentumCandidate.Volume descending select momentumCandidate).ToList());
      }
      else
      {
        momentumCandidates=new MGSHMomentumCandidates((from MGSHMomentumCandidate momentumCandidate in momentumCandidates orderby momentumCandidate.Score descending,momentumCandidate.CumReturn252 descending,momentumCandidate.Return1D descending,momentumCandidate.Volume descending select momentumCandidate).ToList());
      }
      MDTrace.WriteLine(LogLevel.DEBUG,String.Format("MomentumGenertor.GenerateMomentum:{0} candidates",momentumCandidates.Count()));
      return momentumCandidates;
    }
  }
}
