using System;

using System.Collections;

using System.Collections.Generic;

public class Program

{

    public interface ILinkedParam

    {

        public void ExecuteTask(Processor processor);

    }

    public struct LinkedParam<Param_T> : ILinkedParam

    {

        public Param_T param;

        public Action<Processor, Param_T> task;

        public void ExecuteTask(Processor processor)

        {

            task(processor, param);

        }

    }

    internal static class LinkedParamCreator

    {

        internal static LinkedParam<T> Create<T>(T start_value)

        {

            return new LinkedParam<T>() {param = start_value, task = (Processor processor, T in_value) => {

                Console.WriteLine("Inner call");

                if (typeof(T) == typeof(bool))

                {

                    bool casted_param = (bool)((object)in_value);

                    processor.DoProcessBool(casted_param);

                    return;

                }

                if (typeof(T) == typeof(double))

                {

                    double casted_param = (double)((object)in_value);

                    processor.DoProcessDouble(casted_param);

                    return;

                }

                if (typeof(T).IsEnum)

                {

                    Enum casted_param = (Enum)((object)in_value);

                    processor.DoProcessEnum<Enum>(casted_param);

                    return;

                }

                Console.WriteLine($"The type {typeof(T)} is unsupported yet. The input had the value: {in_value.ToString()}");

            }};

        }

    }

    enum AnEnum

    {

        option_a, option_b

    }

    enum AnotherEnum

    {

        another_option_a, another_option_b

    }

    public static void Main()

    {

        List<ILinkedParam> parameters = new List<ILinkedParam>();

        parameters.Add(LinkedParamCreator.Create(20.5));

        parameters.Add(LinkedParamCreator.Create(true));

        parameters.Add(LinkedParamCreator.Create(AnEnum.option_a));

        parameters.Add(LinkedParamCreator.Create(AnotherEnum.another_option_b));

        parameters.Add(LinkedParamCreator.Create("Just a string"));

        Processor proc = new Processor();

        proc.Process(parameters);

    }

    public class Processor

    {

        internal void Process(List<ILinkedParam> parameters)

        {

            foreach (ILinkedParam ptr in parameters)

                ptr.ExecuteTask(this);

        }

        internal void DoProcessBool(bool bool_param)

        {

            Console.WriteLine("Processed a BOOL with value: " + bool_param.ToString());

        }

        internal void DoProcessDouble(double double_param)

        {

            Console.WriteLine("Processed a DOUBLE with value: " + double_param.ToString());

        }

        internal void DoProcessEnum<Enum>(Enum enum_param)

        {

            Console.WriteLine("Processed an ENUM with value: " + enum_param.ToString());

        }

    }

}