using System;

using System.Collections.Generic;

using System.Linq;

​

public class Program

{

    private static (int ReferenceWaveNumber, double[] Definition)[] _elliottWavesDefinition = new[]

        {

            (2, new[] { -0.382, -0.5, -0.618 }),

            (3, new[] { 1.618, 2.618 }),

            (4, new[] { -0.382, -0.5 }),

            (5, new[] { 0.382, 0.5, 0.618 })

        };

    public static void Main()

    {

    _elliottWavesDefinition = new[]

        {

            (2, new[] { -0.618 }),

            (3, new[] { 3.138 }),

            (4, new[] { -1.034 }),

            (5, new[] { 3.136, 4.336 })

        };

        var valley = new Wave { Number = 0, Date = new DateTime(2021, 2, 4), Price = 39.20 };

        var firstWave = new Wave { Number = 1, Date = new DateTime(2021, 5, 25), Price = 47.4 };

        var currentWaves = new[] 

        {

            valley,

            firstWave,

            new Wave { Number = 2, Date = new DateTime(2021, 6, 22), Price = 44.75 },

        };

        var predictedWaves = PredictWaves(valley, firstWave);

        for (var i = 0; i < predictedWaves.Count; i++)

        {

            var pWave = predictedWaves[i];

            var cWave = currentWaves.ElementAtOrDefault(i);

            Console.WriteLine($"Predicted Wave {pWave.Number}: {string.Join(", ", pWave.PredictedPrices.Select(x => x.ToString("N4")))}");

        }

        Console.WriteLine();

        for (var i = 2; i < currentWaves.Length; i++)

        {

            var cWave = currentWaves[i];

            var cPrevWave = currentWaves[i - 1];

            Console.WriteLine($"Wave {cWave.Number} Retracement: {CalculateRetracementRatio(cWave, cPrevWave, valley, firstWave):N4}");

        }

    }

    private static IList<Wave> PredictWaves(Wave valley, Wave firstWave) 

    {

        var result = new List<Wave>() { valley, firstWave };

        Wave currentWave = firstWave;

        for (var i = 2; i <= 5; i++)

        {

            var nextPrices = PredictNextWaveStart(currentWave, valley, firstWave);

            currentWave = new Wave { Number = i, PredictedPrices = nextPrices };

            result.Add(currentWave);

        }

        return result;

    }

    private static IList<double> PredictNextWaveStart(Wave currentWave, Wave valley, Wave firstWave)

    {

        var result = new List<double>();

        var waveNumber = currentWave.Number + 1;

        if (waveNumber < 2)

            return new List<double>();

        var definitions = _elliottWavesDefinition[waveNumber - 2].Definition;

        for (var i = 0; i < definitions.Length; i++)

        {

            var definition = definitions[i];

            var allPrices = currentWave.Price != default ? new List<double> { currentWave.Price } : currentWave.PredictedPrices;

            foreach (var price in allPrices)

            {

                if (definition < 0)

                    result.Add(price - ((firstWave.Price - valley.Price) * definition * -1));

                else

                    result.Add(price + ((firstWave.Price - valley.Price) * definition));

            }

        }

        return result;

    }

    private static double CalculateRetracementRatio(Wave wave, Wave previousWave, Wave valley, Wave firstWave)

    {

        var definition = _elliottWavesDefinition[wave.Number - 2].Definition[0];

        if (definition < 0)

            return (previousWave.Price - wave.Price) / (firstWave.Price - valley.Price);

        else

            return (wave.Price - previousWave.Price) / (firstWave.Price - valley.Price);

    }

    public class Wave

    {

        public Wave() 

        {

            PredictedPrices = new List<double>();

        }

        public int Number;

        public DateTime Date;

        public double Price;

        public IList<double> PredictedPrices;

        public double Length;

    }

}