using System;

using System.Collections.Generic;

using System.Linq;

​

namespace lmts;

​

class Measurement

{

    public double Temperature { get; set; }

    public double Phi { get; set; }

    public double Theta { get; set; }

    public double Power { get; set; }

​

    public Measurement(double temp, double phi, double theta, double power)

    {

        Temperature = temp;

        Phi = phi;

        Theta = theta;

        Power = power;

    }

}

​

enum Oper

{

    Less,

    Greater,

    Equal

}

​

class Condition

{

    public string Name { get; set; }

    public string VariableName { get; set; }

    public Oper Op { get; set; }

    public double Value { get; set; }

}

​

class Limit : Condition

{

    public IEnumerable<Condition> Conditions { get; set; }

}

​

// Evaluator will eventually be configured from a text file that contains the limits and conditions

// For now we just hard code a set

class Evaluator

{

    private readonly IEnumerable<IMeasurement> _measurements;

    private readonly IEnumerable<Link> _links;

    private readonly IEnumerable<Limit> _limits;

​

    public Evaluator(IEnumerable<IMeasurement> measurements, IEnumerable<Link> links)

    {

        var c1 = new Condition { Name = "c1", VariableName = "temp", Op = Oper.Greater, Value = 10 };

        var l1 = new Limit { Name = "l1", VariableName = "power", Op = Oper.Greater, Value = 4, Conditions = new List<Condition>() { c1 } };

        _limits = new List<Limit> { l1 };

​

        _measurements = measurements;

        _links = links;

    }

​

    public bool Run()

    {

        var pass = true;

        IEnumerable<IMeasurement> fitMeasurements = _measurements;

        foreach (var limit in _limits)

        {

            foreach (var condition in limit.Conditions)

            {

                var link = _links.FirstOrDefault(l => l.VariableName == condition.VariableName);

                if (link == null)

                    continue;

​

                fitMeasurements = fitMeasurements.Where(m => Evaluate(link.func.Invoke(m), condition.Op, condition.Value));

            }

​

            var limitLink = _links.FirstOrDefault(l => l.VariableName == limit.VariableName);

            if (limitLink == null)

                continue;

​

            pass = pass && fitMeasurements.All(m => Evaluate(limitLink.func.Invoke(m), limit.Op, limit.Value));

        }

​

        return pass;

    }

​

    private bool Evaluate(double measure, Oper op, double threshold)

    {

        // switch on op, for now, just hard code

        return measure > threshold;

    }

}

​

class Link

{

    public string VariableName { get; set; }

    public Func<IMeasurement, double> func { get; set; }

}

​

interface IMeasurement

{

    double Temperature { get; }

    double Phi { get; }

    double Theta { get; }

    double Power { get; }

}

​

class MyMeasurement : Measurement, IMeasurement

{

    public MyMeasurement(double temp, double phi, double theta, double power) 

        : base(temp, phi, theta, power)

    {

    }

}

​

static class Program

{

    public static void Main()

    {

        var measurements = new List<IMeasurement>

        {

            new MyMeasurement(5,1,2,3),

            new MyMeasurement(5,1,4,5),

            new MyMeasurement(5,2,2,4),

            new MyMeasurement(15,1,2,13),

            new MyMeasurement(15,1,4,15),

            new MyMeasurement(15,2,2,14)

        };

​

        // Hand the entire measurement data to the Evaluator

        // Provide some method for the evaluator to look up data that is defined in the variablename of limit and condition

        // Link variablename "power" to the Power property of the measurement data

        var link1 = new Link() { VariableName = "power", func = m => m.Power };

        var link2 = new Link() { VariableName = "temp", func = m => m.Temperature };

        var ev = new Evaluator(measurements, new List<Link> { link1, link2 });

        var result = ev.Run();

    }

}