using System;
using System.Diagnostics;
using System.Linq;
using System.Threading.Tasks;

namespace HeuristicLab.Algorithms.PushGP.Cli {
  using HeuristicLab.Problems.ProgramSynthesis.Push.Configuration;
  using HeuristicLab.Problems.ProgramSynthesis.Push.Data.Pool;
  using HeuristicLab.Problems.ProgramSynthesis.Push.Expressions;
  using HeuristicLab.Problems.ProgramSynthesis.Push.Generators;
  using HeuristicLab.Problems.ProgramSynthesis.Push.Interpreter;
  using HeuristicLab.Problems.ProgramSynthesis.Push.Parser;
  using HeuristicLab.Random;

  class Program {
    static void Main(string[] args) {
      //SimpleTest();
      //Stepwise().Wait();
      //PerformanceTestInterpreter();
      //PerformanceParallelTestInterpreter();
      //PerformanceTestCodeGenerator();
      TestRobustness();
      //TestPool();
      //TestPoolPerformance();
      //TestSimplifier();

      Console.WriteLine("\nPress any key to continue...");

      //if (args.Length == 0) return;

      //var code = args[0];
      //EvaluateStepwise(code).Wait();

      Console.ReadKey();
    }

    static async Task EvaluateStepwise(string code) {
      var interpreter = new PushInterpreter(new PushConfiguration {
        TopLevelPushCode = false
      });

      interpreter.RunAsync(code, true).Wait();

      while (!interpreter.IsCompleted) {
        Console.Clear();
        interpreter.PrintStacks();
        interpreter.Step();

        var input = Console.ReadKey();
        if (input.Key == ConsoleKey.Escape) {
          break;
        } else if (input.Key == ConsoleKey.Spacebar) {
          await interpreter.ResumeAsync();
        }
      }

      Console.Clear();
      interpreter.PrintStacks();
    }

    static void SimpleTest() {
      var interpreter = new PushInterpreter();

      interpreter.Run("5 INTEGER.DUP INTEGER.+");

      interpreter.PrintStacks();
    }

    static async Task Stepwise() {
      var interpreter = new PushInterpreter();

      interpreter.RunAsync("( 0 2 CODE.QUOTE ( 1 INTEGER.+ 0 3 CODE.QUOTE ( 1 INTEGER.+ INTEGER.* ) CODE.DO*RANGE INTEGER.+ ) CODE.DO*RANGE )", true).Wait();

      while (!interpreter.IsCompleted) {
        Console.Clear();
        interpreter.PrintStacks();
        interpreter.Step();

        var input = Console.ReadKey();
        if (input.Key == ConsoleKey.Escape) {
          break;
        } else if (input.Key == ConsoleKey.Spacebar) {
          await interpreter.ResumeAsync();
        }
      }

      Console.Clear();
      interpreter.PrintStacks();
    }

    static void PerformanceTestInterpreter() {
      var program = PushParser.Parse("( 5 INTEGER.DUP INTEGER.+ )");

      var interpreter = new PushInterpreter();
      var sw = new Stopwatch();

      sw.Start();
      for (var i = 0; i < 60000000; i++) {
        interpreter.Run(program);
        interpreter.Clear();
      }
      sw.Stop();

      Console.WriteLine(sw.Elapsed);
    }

    static void PerformanceParallelTestInterpreter() {
      var program = PushParser.Parse("( 5 INTEGER.DUP INTEGER.+ )");

      var sw = new Stopwatch();
      var iterations = 100;
      var amount = 600000;
      var pool = new PushInterpreterPool(iterations, 1024);

      sw.Start();
      Parallel.For(0, iterations, i => {
        using (var interpreter = pool.GetInstance()) {

          for (var j = 0; j < amount; j++) {
            interpreter.Run(program);
            interpreter.Clear();
          }
        }
      });
      sw.Stop();

      Console.WriteLine(sw.Elapsed);
    }

    static void PerformanceTestCodeGenerator() {
      var sw = new Stopwatch();
      var random = new FastRandom(1337);

      sw.Start();
      var expressions = CodeGenerator.RandomCode(60000000, random).ToList();
      sw.Stop();

      Console.WriteLine("Generated {0} in {1}", expressions.Count(), sw.Elapsed);
    }

    static void TestRobustness() {
      var sw = new Stopwatch();
      var parallelism = Environment.ProcessorCount;
      var maxProgramSizeLimit = 1024;
      var partitionSize = 10000;
      var execCounters = new int[parallelism];

      var config = new PushConfiguration {
        EvalPushLimit = 4096,
        IsCodeStackEnabled = false,
        //IsExecStackEnable = false,
        //IsBooleanStackEnabled = false,
        //IsFloatStackEnabled = false,
        //IsIntegerStackEnabled = false,
        IsNameStackEnabled = false,
      };

      var pool = new PushInterpreterPool(config);

      sw.Start();
      Parallel.For(0, parallelism, i => {
        var random = new MersenneTwister(1337);
        using (var interpreter = pool.GetInstance(random)) {
          for (var j = 0; j < partitionSize; j++) {
            var program = CodeGenerator.RandomProgram(interpreter.PushProgramPool, maxProgramSizeLimit, random, config);
            interpreter.Run(program);

            execCounters[i] += interpreter.ExecCounter;
            interpreter.Clear();
          }
        }
      });
      sw.Stop();

      Console.WriteLine("ExecCount: {0}", execCounters.Sum());
      Console.WriteLine("Duration: {0}", sw.Elapsed);
    }

    static void TestPool() {
      var pool = new PushInterpreterPool();
      var normal = new PushInterpreter();
      int id;

      using (var interpreter = pool.GetInstance()) {
        interpreter.Run("( 1 2 INTEGER.+ )");

        id = interpreter.GetHashCode();
        if (id == normal.GetHashCode()) Console.WriteLine("equal 1");
      }

      using (var interpreter = pool.GetInstance())
      using (var interpreter2 = pool.GetInstance()) {
        interpreter.Run("( 1 2 INTEGER.+ )");
        if (id == interpreter.GetHashCode()) Console.WriteLine("equal 2");
        if (id == interpreter2.GetHashCode()) Console.WriteLine("equal 3");
      }
    }

    static void TestPoolPerformance() {
      var sw = new Stopwatch();
      var iterations = 100000000;

      sw.Start();
      for (var i = 0; i < iterations; i++) {
        var interpreter = new PushInterpreter();
        interpreter.Clear();
      }
      sw.Stop();

      Console.WriteLine(sw.Elapsed);

      var pool = new PushInterpreterPool();
      sw.Restart();
      for (var i = 0; i < iterations; i++) {
        using (var interpreter = pool.GetInstance()) {
          interpreter.Clear();
        }
      }
      sw.Stop();

      Console.WriteLine(sw.Elapsed);
    }

    //static void TestSimplifier() {
    //  var interpreter = new PushInterpreter();
    //  var program = PushParser.Parse("( 5 INTEGER.DUP FLOAT.+ INTEGER.+ )") as PushProgram;
    //  var simplifier = new RandomSimplifier { Trys = 10 };
    //  var random = new FastRandom(1337);

    //  var simplerProgram = simplifier.Simplify(
    //    program,
    //    random,
    //    solution => {
    //      interpreter.Clear();
    //      interpreter.Run(solution);
    //      return interpreter.IntegerStack.Top == 10;
    //    });

    //  Console.WriteLine(simplerProgram);
    //}
  }
}