using MarketData.Numerical;
using MarketData.DataAccess;
using MarketData.MarketDataModel;
using MarketData.Generator;
using MarketData.Utils;
using SkiaSharp;

namespace MarketData.CNNProcessing
{
  public class DataProcessor
	{
	  private String strFolderPath=default;
    private readonly SKColor colorBlack = new SKColor(0,0,0);
		private readonly SKColor colorWhite = new SKColor(255,255,255);
		private readonly SKColor colorRed = new SKColor(255,0,0);
    private readonly SKColor colorGreen = new SKColor(0,255,0);

	  public DataProcessor(int width=640,int height=480)
		{
		  Width=width;
			Height=height;
			PenWidth=2f;
			DrawingBrush = colorBlack;
      DrawingBrushRed = colorRed;
      DrawingBrushGreen = colorGreen;
			FillBrush = colorWhite;
			DrawPrice=true;
			UseGrayScale=false;
      NoiseColor=colorWhite;
			strFolderPath=Directory.GetCurrentDirectory();
		}

    public bool Debug { get; set; } = false;

		/// <summary>
		/// Width
		/// </summary>
		///<param name="value">Gets/Sets the width of the output image</param>
		public int Width{get;set;}

		/// <summary>
		/// Height
		/// </summary>
		///<param name="value">Gets/Sets the height of the output image</param>
		public int Height{get;set;}

		/// <summary>
		/// PenWidth
		/// </summary>
		///<param name="value">Gets/Sets the width of the drawing pen</param>
		public float PenWidth{get;set;}

		/// <summary>
		/// FillBrush
		/// </summary>
		///<param name="value">Gets/Sets the background brush</param>
    public SKColor FillBrush { get; set;}

		/// <summary>
		/// DrawingBrush
		/// </summary>
		///<param name="value">Gets/Sets the drawing brush brush</param>
		public SKColor DrawingBrush{get;set;}

		/// <summary>
		/// DrawingBrushRed
		/// </summary>
		///<param name="value">Gets/Sets the drawing brush brush</param>
		public SKColor DrawingBrushRed{get;set;}    

		/// <summary>
		/// DrawingBrushGreen
		/// </summary>
		///<param name="value">Gets/Sets the drawing brush brush</param>
		public SKColor DrawingBrushGreen{get;set;}        

		/// <summary>
		/// DrawBlack
		/// </summary>
		///<param name="value">Sets up the canvas to do black drawing</param>
		public void DrawBlack()
		{
			DrawingBrush = colorBlack;
			FillBrush = colorWhite;			
		}

		/// <summary>
		/// IncludePrice
		/// </summary>
		///<param name="value">Indicates whether we want to include price data in the graph</param>
		public bool DrawPrice{get; set;}

		/// <summary>
		/// UseGrayScale
		/// </summary>
		///<param name="value">Indicates whether we want to use grayscale.. default is B&W</param>
		public bool UseGrayScale{get; set;}

		/// <summary>
		/// DrawWhite
		/// </summary>
		///<param name="value">Sets up the canvas to do white drawing</param>
		public void DrawWhite()
		{
			DrawingBrush = colorBlack;
			FillBrush = colorWhite;			
		}

		/// <summary>
		/// MovingAverageArray
		/// </summary>
		///<param name="MovingAverageArray">Gets/Sets the moving average array</param>
		public int[] MovingAverageArray{get; set; }

		/// <summary>
		/// PenWidthArray
		/// </summary>
		///<param name="PenWidthArray">Gets/Sets thepen width array</param>
		public float[] PenWidthArray{get; set; }

		/// <summary>
		/// NoiseArray
		/// </summary>
		///<param name="NoiseArray">Gets/Sets the noise array</param>
		public double[] NoiseArray{get; set; }

		/// <summary>
		/// NoiseColor
		/// </summary>
		///<param name="NoiseColor">Gets/Sets the noise color</param>
		public SKColor NoiseColor{get; set; }

		/// <summary>
		/// UseNoise
		/// </summary>
		///<param name="seed">The seed value</param>
		///<param name="increment">The increment</param>
		///<param name="length">The size</param>
		public void UseNoise(double seed, double increment, int length, SKColor noiseColor)
    {
      NoiseColor=noiseColor;
      NoiseArray=new double[length+1];
      NoiseArray[0]=0.00;
      for(int index=1;index<length;index++)
      {
        NoiseArray[index]=seed;
        seed+=increment;
      }
    }

		/// <summary>
		/// SetOutputFolderPath
		/// </summary>
		///<param name="testCases">The test cases</param>
		public void SetOutputFolderPath(String strFolderPath)
		{
		  this.strFolderPath=strFolderPath;
			if(!this.strFolderPath.EndsWith(@"/"))this.strFolderPath=this.strFolderPath+@"/";
		}

		/// <summary>
		/// ClearFolderPath
		/// </summary>
		///<param name="testCases">The test cases</param>
		public void ClearFolderPath()
		{
      if(String.IsNullOrEmpty(strFolderPath))throw new InvalidDataException($"{nameof(strFolderPath)} cannot be null");
      if(!Directory.Exists(strFolderPath))
      {
        Directory.CreateDirectory(strFolderPath);
      }
      else
      {
        String[] pathFileNames = Directory.GetFiles(strFolderPath);
        Console.WriteLine($"Deleting {pathFileNames.Length} files from {strFolderPath}");
        foreach(String file in pathFileNames)
        {
          File.Delete(file);
        }
      }    
    }

		public void ProcessData(TestCases testCases)
		{
			for(int index=0;index<testCases.Count;index++)
			{
				TestCase testCase=testCases[index];
				ProcessData(testCase,index);
			}
		}

		/// <summary>
		/// ProcessData item
		/// </summary>
		///<param name="testCases">The test cases</param>
		public void ProcessData(TestCase testCase,int index=0)
		{
			if(null==PenWidthArray)PenWidthArray=new float[]{PenWidth};
      if(null==NoiseArray)NoiseArray=new double[]{0.00};
      if(testCase.TypeGenerate.Equals(TestCase.GenerateType.BollingerBand))
      {
        testCase.PathFileNames.Add(CreateFileName(testCase.HomePath,testCase.Symbol,testCase.DayCount,0,0,0,TestCase.CaseType.Test,TestCase.GenerateType.BollingerBand,testCase.PurchaseDate));
			  ProcessBollingerBandData(testCase,PenWidthArray[0],NoiseArray[0]);
      }
      else if(testCase.TypeGenerate.Equals(TestCase.GenerateType.BollingerBandWithVIX))
      {
        testCase.PathFileNames.Add(CreateFileName(testCase.HomePath,testCase.Symbol,testCase.DayCount,0,0,0,TestCase.CaseType.Test,TestCase.GenerateType.BollingerBandWithVIX,testCase.PurchaseDate));
        ProcessBollingerBandDataWithVolatility(testCase,PenWidthArray[0],NoiseArray[0]);
      }
    }

    private String CreateFileName(String strFolderPath,String symbol,int dayCount,int index,int penIndex,int noiseIndex,TestCase.CaseType caseType,TestCase.GenerateType generateType,DateTime purchaseDate)
    {
      if(!strFolderPath.EndsWith("/"))strFolderPath+="/";
      return String.Format("{0}{1}_{2}_{3}_{4}_{5}_{6}_{7}_{8}d.jpg",strFolderPath,symbol,index,penIndex,noiseIndex,caseType.ToString(),generateType.ToString(),Utility.DateToLong(purchaseDate),dayCount);
    }

		/// <summary>
		/// ProcessBollingerBandData item
		/// </summary>
		///<param name="testCase">Symbol</param>
		private void ProcessBollingerBandData(TestCase testCase,float penWidth,double noise)
		{
		  DateGenerator dateGenerator=new DateGenerator();

			int daysInPeriod=dateGenerator.DaysBetweenActual(testCase.PurchaseDate,testCase.HistDate);
			daysInPeriod+=60;
		  Prices prices=PricingDA.GetPrices(testCase.Symbol,testCase.PurchaseDate,daysInPeriod);
			BollingerBands bollingerBands=BollingerBandGenerator.GenerateBollingerBands(prices);	 // we want to grab K, L, and Close
			bollingerBands=new BollingerBands(bollingerBands.Where(x=>x.Date>=testCase.HistDate).ToList());
			float[] k=new float[bollingerBands.Count];
			float[] l=new float[bollingerBands.Count];
			float[] close=new float[bollingerBands.Count];

// populate the arrays in reverse order so that we have the most historical date in the lowest index
			for(int index=bollingerBands.Count-1;index>=0;index--)
			{
				BollingerBandElement bollingerBandElement=bollingerBands[index];
				k[bollingerBands.Count-index-1]=(float)Math.Log(bollingerBandElement.K)*1000.00f;
				l[bollingerBands.Count-index-1]=(float)Math.Log(bollingerBandElement.L)*1000.00f;
				close[bollingerBands.Count-index-1]=(float)Math.Log(bollingerBandElement.Close)*1000.00f;
			}
			Numerics.ZeroForNaNOrInfinity(ref k);
			Numerics.ZeroForNaNOrInfinity(ref l);
			Numerics.ZeroForNaNOrInfinity(ref close);
			float maxY=Math.Max(Numerics.Max(ref l),Math.Max(Numerics.Max(ref close),Numerics.Max(ref k)));
			float minY=Math.Min(Numerics.Min(ref l),Math.Min(Numerics.Min(ref close),Numerics.Min(ref k)))-5f;
			float maxX=close.Length;
			float minX=0.00f;

      ImageHelper imageHelper=new ImageHelper();

      PointMapping pointMapping=new PointMapping(Width,Height,maxX,minX,maxY,minY);
      imageHelper.CreateImage(Width,Height,pointMapping);
      imageHelper.Fill(FillBrush);

// draw price
      if(DrawPrice)imageHelper.DrawSeries(DrawingBrushRed,penWidth,close);     

// draw k
      imageHelper.DrawSeries(DrawingBrushRed,penWidth,k); 

// draw l
      imageHelper.DrawSeries(DrawingBrushRed,penWidth,l); 

      if(0.00!=noise)imageHelper.AddNoise(NoiseColor,noise);

			if(Debug || testCase.TypeOutput.Equals(TestCase.OutputType.OutputFile))
			{
        MDTrace.WriteLine(LogLevel.DEBUG,$"Writing {testCase.LastPathFileName}");
			  if(null==testCase.LastPathFileName)testCase.PathFileNames.Add($"{strFolderPath}{testCase.Symbol}.jpg");
				if(File.Exists(testCase.LastPathFileName))File.Delete(testCase.LastPathFileName);
				if(UseGrayScale)imageHelper.SaveGrayScaleJPG(testCase.LastPathFileName);
				else imageHelper.SaveBlackAndWhiteJPG(testCase.LastPathFileName);
			}

			if(testCase.TypeOutput.Equals(TestCase.OutputType.OutputStream))
			{
			  testCase.Streams.Add(imageHelper.SaveBlackAndWhiteJPG());
			}
		}

    /// <summary>
    /// ProcessBollingerBandDataWithVolatility item - Draws Price, K, L and Volatility
    /// </summary>
    ///<param name="testCase">Symbol</param>
		private void ProcessBollingerBandDataWithVolatility(TestCase testCase,float penWidth,double noise)
		{
      String symbolVolatility="^VIX";
		  DateGenerator dateGenerator=new DateGenerator();

			int daysInPeriod=dateGenerator.DaysBetweenActual(testCase.PurchaseDate,testCase.HistDate);
			daysInPeriod+=60;
		  Prices prices=PricingDA.GetPrices(testCase.Symbol,testCase.PurchaseDate,daysInPeriod);
      Prices volatilityPrices=PricingDA.GetPrices(symbolVolatility,testCase.PurchaseDate,daysInPeriod);
			BollingerBands bollingerBands=BollingerBandGenerator.GenerateBollingerBands(prices);	 // we want to grab K, L, and Close
			bollingerBands=new BollingerBands(bollingerBands.Where(x=>x.Date>=testCase.HistDate).ToList());
			float[] k=new float[bollingerBands.Count];
			float[] l=new float[bollingerBands.Count];
			float[] close=new float[bollingerBands.Count];

// Line up volatility dates with bollinger bands
      DateTime minDate = bollingerBands.Min(x=>x.Date);
      DateTime maxDate = bollingerBands.Max(x=>x.Date);
      volatilityPrices = new Prices(volatilityPrices.Where(x=>x.Date<=maxDate && x.Date>=minDate).OrderBy(x=>x.Date).ToList());  // most historical date in lowest index
      float[] v=volatilityPrices.GetPrices();
      float minV=Numerics.Min(ref v);              // get the minimum volatility value
      double minP=bollingerBands.Min(x=>x.Close);  // get minimum price
      double factor=minP/minV;                     // determine scaling factor
      for(int index=0;index<v.Length;index++)
      {
        double item = v[index];
        item*=factor;
        v[index]=(float)Math.Log(item)*1000.00f; 
      }
                                                                                                                      
// populate the arrays in reverse order so that we have the most historical date in the lowest index
			for(int index=bollingerBands.Count-1;index>=0;index--)
			{
				BollingerBandElement bollingerBandElement=bollingerBands[index];
				k[bollingerBands.Count-index-1]=(float)Math.Log(bollingerBandElement.K)*1000.00f;   // put the data in log form
				l[bollingerBands.Count-index-1]=(float)Math.Log(bollingerBandElement.L)*1000.00f;   // put the data in log form
				close[bollingerBands.Count-index-1]=(float)Math.Log(bollingerBandElement.Close)*1000.00f;  // put the data in log form
			}
			Numerics.ZeroForNaNOrInfinity(ref k);
			Numerics.ZeroForNaNOrInfinity(ref l);
			Numerics.ZeroForNaNOrInfinity(ref close);
      Numerics.ZeroForNaNOrInfinity(ref v);
			float maxY=Math.Max(Math.Max(Numerics.Max(ref l),Math.Max(Numerics.Max(ref close),Numerics.Max(ref k))),Numerics.Max(ref v));
			float minY=Math.Min(Math.Min(Numerics.Min(ref l),Math.Min(Numerics.Min(ref close),Numerics.Min(ref k))),Numerics.Min(ref v))-5f;
			float maxX=close.Length;
			float minX=0.00f;

      ImageHelper imageHelper=new ImageHelper();

      PointMapping pointMapping=new PointMapping(Width,Height,maxX,minX,maxY,minY);
      imageHelper.CreateImage(Width,Height,pointMapping);
      imageHelper.Fill(FillBrush);

// draw volatility
      imageHelper.DrawSeries(DrawingBrushRed,penWidth,v); 

// draw prices
      if(DrawPrice)imageHelper.DrawSeries(DrawingBrush,penWidth,close); 

// draw k
      imageHelper.DrawSeries(DrawingBrushGreen,penWidth,k); 

// draw l
      imageHelper.DrawSeries(DrawingBrushGreen,penWidth,l);       

      if(0.00!=noise)imageHelper.AddNoise(NoiseColor,noise);
			if(testCase.TypeOutput.Equals(TestCase.OutputType.OutputFile))
			{
        MDTrace.WriteLine(LogLevel.DEBUG,$"Writing {testCase.LastPathFileName}");
				if(File.Exists(testCase.LastPathFileName))File.Delete(testCase.LastPathFileName);
				if(UseGrayScale)imageHelper.SaveGrayScaleJPG(testCase.LastPathFileName);
        else imageHelper.Save(testCase.LastPathFileName);
			}
			else
			{
        testCase.Streams.Add(imageHelper.ToStream());
			}
		}

		/// <summary>
		/// ProcessPriceData item
		/// </summary>
		///<param name="testCase">TestCase</param>
		private void ProcessPriceData(TestCase testCase,float penWidth,double noise)
		{
		  Prices prices=PricingDA.GetPrices(testCase.Symbol,testCase.PurchaseDate,testCase.HistDate);
			prices.Reverse();			// get the most historical date into the lowest index
			float[] priceArray=prices.GetPrices();
			for(int index=0;index<priceArray.Length;index++)
			{
			  priceArray[index]=(float)Math.Log((double)priceArray[index])*1000.00f;
			}
			Numerics.ZeroForNaNOrInfinity(ref priceArray);

			float maxY=Numerics.Max(ref priceArray);
			float minY=Numerics.Min(ref priceArray)-5f;
			float maxX=priceArray.Length;
			float minX=0.00f;
      
      ImageHelper imageHelper=new ImageHelper();

      PointMapping pointMapping=new PointMapping(Width,Height,maxX,minX,maxY,minY);
      imageHelper.CreateImage(Width,Height,pointMapping);
      imageHelper.Fill(FillBrush);

			LineSegments lineSegments=new LineSegments();
			for(int index=0;index<priceArray.Length;index++)
			{
			  if(0==index)continue;
				SKPoint p1=new SKPoint(index-1,(int)priceArray[index-1]);
				SKPoint p2=new SKPoint(index,(int)priceArray[index]);
				lineSegments.Add(p1,p2);
			}
			imageHelper.DrawPath(DrawingBrush,penWidth,lineSegments);
      if(0.00!=noise)imageHelper.AddNoise(NoiseColor,noise);
			
			if(testCase.TypeOutput.Equals(TestCase.OutputType.OutputFile))
			{
        MDTrace.WriteLine(LogLevel.DEBUG,$"Writing {testCase.LastPathFileName}");
				if(File.Exists(testCase.LastPathFileName))File.Delete(testCase.LastPathFileName);
				if(UseGrayScale)imageHelper.SaveGrayScaleJPG(testCase.LastPathFileName);
				else imageHelper.SaveBlackAndWhiteJPG(testCase.LastPathFileName);
			}
			else
			{
			  testCase.Streams.Add(imageHelper.SaveBlackAndWhiteJPG());
			}
		}
	}
}