using System;

using System.Linq;

using System.Collections.Generic;

​

namespace MyNamespace

{

    public class Program

    {

        public static void Main()

        {           

            // Setup

            // This Task has no conditions and always goes to /Foo/Bar

            var taskA = new TaskRoute(Guid.Parse("75716852-444d-4181-9fa4-83a71365232a"));

            taskA.Add(t => true, "/Foo/Bar");

            var taskB = new TaskRoute(Guid.Parse("0c9a451c-f4a8-476b-b822-3e32009e2cc5"));

            taskB.Add(t => t.LoanAmount > 300000, "/Big/Bucks");

            taskB.Add(t => true, "/My/Default/Route/For/This/Task");

            var taskC = new TaskRoute(Guid.Parse("b0847578-13bc-4204-81ae-6092cc03010a"));

            taskC.Add(t => t.Created > DateTime.Parse("1/1/2018") && t.HasHmda, "/Route/For/Hmda");

            taskC.Add(t => t.This && t.LoanAmount >= 10000, "/Go/There");

            taskC.Add(t => (t.This && t.LoanAmount >= 50000) || t.That, "/Go/Elsewhere");

            taskC.Add(t => t.This || t.That, "/Go/Here");

            taskC.Add(t => t.Created < DateTime.Parse("1/1/2018"), "/Route/For/Old/Process");

            taskC.Add(t => t.Created < DateTime.Parse("1/1/2019"), "/Route/For/New/Process");

            taskC.Add(t => true, "/My/Default/Route/For/This/Task");

            // Example usage

            var transaction = new TransactionData();

            var engine = new TaskRoutingEngine(new[] { taskA, taskB });

            var route = engine.Route(Guid.Parse("75716852-444d-4181-9fa4-83a71365232a"), transaction);

            Console.WriteLine("Route: " + route.TargetUrl);

        }

    }

    public class TransactionData

    {

        public DateTime Created { get; set; }

        public bool HasHmda { get; set; }   

        public bool This { get; set; }

        public bool That { get; set; }

        public decimal LoanAmount { get; set; }

    }

    public class TaskRoutingEngine

    {

        public TaskRoutingEngine(IEnumerable<TaskRoute> tasks)

        {

            Tasks = tasks;

        }

        public IEnumerable<TaskRoute> Tasks { get; private set; }

        public RouteCondition Route(Guid taskId, TransactionData transaction)

        {

            var task = Tasks.FirstOrDefault(t => t.TaskId == taskId);

            if (task == null)

            {

                throw new InvalidOperationException("Task does not exist for TaskId: " + taskId);

            }

            var route = task.Conditions.FirstOrDefault(r => r.Condition(transaction));

            if (route == null)

            {

                throw new InvalidOperationException("Default Route not found for TaskId: " + taskId);

            }

            else

            {

                return route;

            }

        }

    }

    public class TaskRoute

    {

        public TaskRoute(Guid taskId, IEnumerable<RouteCondition> conditions = null)

        {

            TaskId = taskId;

​

            if (conditions != null) 

            {

                _conditions.AddRange(conditions);

            }

        }

        public Guid TaskId { get; private set; }

        private List<RouteCondition> _conditions = new List<RouteCondition>();

        public IEnumerable<RouteCondition> Conditions

        {

            get             

            {

                return _conditions.AsReadOnly();

            }

        }

        public TaskRoute Add(Func<TransactionData, bool> transaction, string targetUrl)

        {

            _conditions.Add(new RouteCondition(transaction, targetUrl));

            return this;

        }

    }

    public class RouteCondition

    {

        public RouteCondition(Func<TransactionData, bool> condition, string targetUrl)

        {

            Condition = condition;

            TargetUrl = targetUrl;

        }

​

        public Func<TransactionData, bool> Condition { get; private set; }

        public string TargetUrl { get; private set; }

    }

}