using System;

using System.Diagnostics;

using System.Collections.Generic;

using CodingSeb.ExpressionEvaluator;

using NCalc.Factories;

using NCalc.Handlers;

using NCalc;

public class Program

{

    public static void Main()

    {

        int asdfValue = 24;

        int helloWorldValue = 48;

        string expression = "Set(hello_world, asdf)";

        ExpressionEvaluator evaluator = new ExpressionEvaluator();

        evaluator.OptionVariablesPersistenceCustomComparer = true;

        evaluator.OptionInstanceMethodsCallActive = false;

        evaluator.OptionPropertyOrFieldSetActive = false;

        evaluator.OptionDetectExtensionMethodsOverloadsOnExtensionMethodNotFound = false;

        evaluator.OptionNewKeywordEvaluationActive = false;

        evaluator.Variables = new Dictionary<string, object> () { {"hello_world", helloWorldValue} };

        evaluator.PreEvaluateVariable += delegate (object sender, VariablePreEvaluationEventArg e)

        {

            if (e.Name == "asdf")

            {

                e.Value = asdfValue;

            }

        };

        evaluator.PreEvaluateFunction += delegate (object sender, FunctionPreEvaluationEventArg e)

        {

            if (e.Name == "Set")

            {

                object result = e.Evaluator.Evaluate(e.Args[1]);

                e.Evaluator.Variables[e.Args[0].Trim()] = result;

                e.Value = result;

            }

        };

​

        object? lastResult = null;

        Stopwatch stopWatch = new Stopwatch();

        int iterations = 10000;

        evaluator.Evaluate(expression);

​

        stopWatch.Start();

        for (int i = 0; i < iterations; ++i)

        {

            lastResult = evaluator.Evaluate(expression);

        }

        stopWatch.Stop();

        Console.WriteLine($"evaluation of {iterations} times reusing evaluator took: {stopWatch.ElapsedMilliseconds} ms ({stopWatch.Elapsed.TotalMicroseconds / (double)iterations} us / iteration)");

        Console.WriteLine($"last result: {lastResult}");

        stopWatch.Reset();

        stopWatch.Start();

        for (int i = 0; i < iterations; ++i)

        {

            ExpressionEvaluator newEvaluator = new ExpressionEvaluator();

            newEvaluator.OptionVariablesPersistenceCustomComparer = true;

            newEvaluator.Variables = new Dictionary<string, object> () { {"hello_world", helloWorldValue} };

            newEvaluator.PreEvaluateVariable += delegate (object sender, VariablePreEvaluationEventArg e)

            {

                if (e.Name == "asdf")

                {

                    e.Value = asdfValue;

                }

            };

            newEvaluator.PreEvaluateFunction += delegate (object sender, FunctionPreEvaluationEventArg e)

            {

                if (e.Name == "Set")

                {

                    object result = e.Evaluator.Evaluate(e.Args[1]);

                    e.Evaluator.Variables[e.Args[0].Trim()] = result;

                    e.Value = result;

                }

            };

            lastResult = newEvaluator.Evaluate(expression);

        }

        stopWatch.Stop();

        Console.WriteLine($"evaluation of {iterations} times with new evaluator each time took: {stopWatch.ElapsedMilliseconds} ms ({stopWatch.Elapsed.TotalMicroseconds / (double)iterations} us / iteration)");

        Console.WriteLine($"last result: {lastResult}");

        var exprTest = new Expression("hello_world");

        stopWatch.Reset();

        stopWatch.Start();

        for (int i = 0; i < iterations; ++i)

        {

            var expr = new Expression(expression);

            expr.EvaluateParameter += delegate(string name, ParameterArgs args)

            {

                if (name == "asdf")

                {

                    args.Result = asdfValue;

                }

            };

            expr.Functions["Set"] = (args) => {

                object result = args[1].Evaluate();

                expr.Parameters[args[0].ToString()] = args[1].Evaluate();

                return result;

            };

            expr.Parameters["hello_world"] = helloWorldValue;

            lastResult = expr.Evaluate();

        }

        stopWatch.Stop();

        Console.WriteLine($"evaluation of {iterations} times with ncalc (and new expression) took: {stopWatch.ElapsedMilliseconds} ms ({stopWatch.Elapsed.TotalMicroseconds / (double)iterations} us / iteration)");

        Console.WriteLine($"last result: {lastResult}");

        stopWatch.Reset();

        stopWatch.Start();

        var reused = new Expression(expression);

        var variables = new Dictionary<string, object>() { {"asdf", asdfValue} };

        reused.EvaluateParameter += delegate(string name, ParameterArgs args)

        {

            if (name == "asdf")

            {

                args.Result = variables["asdf"];

            }

        };

        reused.Functions["Set"] = (args) => {

            object result = args[1].Evaluate();

            // args.Context.StaticParameters["hello_world"] = args[1].Evaluate();

            return result;

        };

        for (int i = 0; i < iterations; ++i)

        {

            reused.Parameters["hello_world"] = helloWorldValue;

            lastResult = reused.Evaluate();

        }

        Console.WriteLine($"reused[\"hello_world\"] = {reused.Parameters["hello_world"]}");

        stopWatch.Stop();

        Console.WriteLine($"evaluation of {iterations} times with ncalc (and reused expression) took: {stopWatch.ElapsedMilliseconds} ms ({stopWatch.Elapsed.TotalMicroseconds / (double)iterations} us / iteration)");

        Console.WriteLine($"last result: {lastResult}");

    }

}