using System;

using System.Collections;

using System.Collections.Generic;

using System.Linq;

public interface IPredicate<TEntity>

{

    /// <summary>

    /// Determines whether the specified candidate is satisfied by the candidate.

    /// </summary>

    /// <param name="candidate">The candidate.</param>

    /// <returns>

    ///     <c>true</c> if the specified candidate is satisfied by the candidate; otherwise, <c>false</c>.

    /// </returns>

    bool IsSatisfiedBy(TEntity candidate);

}

​

​

public class Program

{

    public static void Main()

    {

        Console.WriteLine("Hello World");

    }

}

​

​

public interface ICqmExpression

{

    bool Evaluate();

}

​

public class CodeBase 

{

    public string Value { get; set; }

    public string CodeSystem { get; set; }

    public string CodeSystemName { get; set; }

    public string DisplayName { get; set; }

    public string ValueSet { get; set; }

    public string Unit { get; set; }

}

​

public class StatusCodeBase 

{

    public string Value { get; set; }

}

​

public class QualityDataModel

{

    public virtual string CategoryId { get; set; }

    public virtual string DataTypeId { get; set; }

    public CodeBase Code { get; set; }

    public string Text { get; set; }

    public StatusCodeBase StatusCode { get; set; }

    public virtual bool NegationIndicator { get; set; }

}

​

public interface ICondition<T, T2>{}

public class DateRange{}

public class OccurrenceTracker<T>{}

​

public abstract partial class CqmExpression : ICqmExpression

{

    private readonly IEvaluationStrategy _evaluationStrategy;

    public CqmExpression(IEvaluationStrategy evaluationStrategy)

    {

        this._evaluationStrategy = evaluationStrategy;

    }

    public interface IEvaluationStrategy

    {

        /// <summary>

        /// Evaluate entities against condition until first True evaluation result

        /// </summary>

        /// <returns></returns>

        bool EvaluateToBool();

    }

    public interface IEvaluationStrategy<T> : IEvaluationStrategy

    {

        /// <summary>

        /// Evaluate ALL entities against condition creating a list of ALL True evaluation results

        /// </summary>

        /// <returns></returns>

        IEnumerable<T> EvaluateToCollection();

    }

    public virtual bool Evaluate()

    {

        return EvaluateToBool();

    }

    protected abstract bool EvaluateToBool();

    #region Static Factory Methods

        public static CqmExpression<TFactoryL, TFactoryR> Factory<TFactoryL, TFactoryR>(TFactoryL left, ICondition<TFactoryL, TFactoryR> condition, OccurrenceTracker<TFactoryR> right)

            where TFactoryR : QualityDataModel

            {

                return new CqmExpression<TFactoryL, TFactoryR>(null /*new SingleOnOccurrence<TFactoryL, TFactoryR>(left, condition, right)*/);

            }

    public static CqmExpression<TFactoryL, TFactoryR> Factory<TFactoryL, TFactoryR>(TFactoryL left, ICondition<TFactoryL, TFactoryR> condition, TFactoryR right)

    {

        return new CqmExpression<TFactoryL, TFactoryR>(null /*new SingleOnSingle<TFactoryL, TFactoryR>(left, condition, right)*/);

    }

    public static CqmExpression<TFactoryL> Factory<TFactoryL>(IEnumerable<TFactoryL> left, ICondition<TFactoryL, DateRange> condition, DateRange dateRange)

    {

        return new CqmExpression<TFactoryL>(null /*new EnumerableOnSingle<TFactoryL, DateRange>(left, condition, dateRange)*/);

    }

    public static CqmExpression<TFactoryLeft, TFactoryRight> Factory<TFactoryLeft, TFactoryRight>(IEnumerable<TFactoryLeft> left, ICondition<TFactoryLeft, TFactoryRight> condition, OccurrenceTracker<TFactoryRight> right)

        where TFactoryRight : QualityDataModel

        {

            return new CqmExpression<TFactoryLeft, TFactoryRight>(null /*new EnumerableOnOccurrence<TFactoryLeft, TFactoryRight>(left, condition, right)*/);

        }

    public static CqmExpression<TFactoryL, TFactoryR> Factory<TFactoryL, TFactoryR>(OccurrenceTracker<TFactoryL> left, ICondition<TFactoryL, TFactoryR> condition, OccurrenceTracker<TFactoryR> right)

        where TFactoryL : QualityDataModel

            where TFactoryR : QualityDataModel

            {

                return new CqmExpression<TFactoryL, TFactoryR>(null /*new OccurrenceOnOccurrence<TFactoryL, TFactoryR>(left, condition, right)*/);

            }

    public static CqmExpression<TFactoryL, TFactoryR> Factory<TFactoryL, TFactoryR>(IEnumerable<TFactoryL> left, ICondition<TFactoryL, TFactoryR> condition, TFactoryR right)

    {

        return new CqmExpression<TFactoryL, TFactoryR>(null /*new EnumerableOnSingle<TFactoryL, TFactoryR>(left, condition, right)*/);

    }

    public static CqmExpression<TFactoryL, TFactoryR> Factory<TFactoryL, TFactoryR>(IEnumerable<TFactoryL> left, ICondition<TFactoryL, TFactoryR> condition, IEnumerable<TFactoryR> right)

    {

        return new CqmExpression<TFactoryL, TFactoryR>(null /*new EnumerableOnEnumerable<TFactoryL, TFactoryR>(left, condition, right)*/);

    }

    public static CqmExpression<TFactoryL, TFactoryR> Factory<TFactoryL, TFactoryR>(IEnumerable<TFactoryL> left, ICondition<TFactoryL, TFactoryR> condition, CqmExpression<TFactoryR> right)

    {

        return new CqmExpression<TFactoryL, TFactoryR>(null /*new EnumerableOnExpression<TFactoryL, TFactoryR>(left, condition, right)*/);

    }

    public static CqmExpression<TFactoryL, TFactoryR> Factory<TFactoryL, TFactoryR>(CqmExpression<TFactoryL> left, ICondition<TFactoryL, TFactoryR> condition, OccurrenceTracker<TFactoryR> right)

        where TFactoryR : QualityDataModel

    {

        return new CqmExpression<TFactoryL, TFactoryR>(null /*new ExpressionOnOccurrence<TFactoryL, TFactoryR>(left, condition, right)*/);

    }

    #endregion Static Factory Methods

}

​

public class CqmExpression<LeftOperand> : CqmExpression, IEnumerable<LeftOperand>

{

    protected internal readonly IEvaluationStrategy<LeftOperand> _evaluationStrategy;

    /* Debugging this inside _evaluationStrategy there is a _leftCollection that is not exposed, however, 

        to have this work the way I think it should work, was trying to figure out how to expose this collection */

        protected readonly List<LeftOperand> _leftExpressions = new List<LeftOperand>();

        public CqmExpression(IEvaluationStrategy<LeftOperand> evaluationStrategy)

            : base(evaluationStrategy)

            {

                this._evaluationStrategy = evaluationStrategy;

            }

        public CqmExpression(IEvaluationStrategy evaluationStrategy)

            : base(evaluationStrategy)

            {

                this._evaluationStrategy = (IEvaluationStrategy<LeftOperand>)evaluationStrategy;

            }

        IEnumerator IEnumerable.GetEnumerator()

        {

            return GetEnumerator();

        }

        public IEnumerator<LeftOperand> GetEnumerator()

        {

            SubsetEnumerator<LeftOperand> enumerator = new SubsetEnumerator<LeftOperand>(this._evaluationStrategy.EvaluateToCollection().ToList());

            return enumerator;

        }

        public void Add(LeftOperand leftExpressions)

        {

            this._leftExpressions.Add(leftExpressions);

        }

        protected override bool EvaluateToBool()

        {

            return this._evaluationStrategy.EvaluateToBool();

        }

        // BJ -- I removed this because when ever a collection is needed it will call GetEnumerator

        //public IEnumerable<LeftOperand> EvaluationToCollection()

        //{

        //  return this._evaluationStrategy.EvaluateToCollection();

        //}

    }

​

/// <summary>

///

/// </summary>

/// <typeparam name="LeftOperand"></typeparam>

/// <typeparam name="RightOperand"></typeparam>

public partial class CqmExpression<LeftOperand, RightOperand> : CqmExpression<LeftOperand>

{

    public CqmExpression(IEvaluationStrategy<LeftOperand> evaluationStrategy)

        : base(evaluationStrategy)

        {

        }

    public CqmExpression(IEvaluationStrategy evaluationStrategy)

        : base(evaluationStrategy)

        {

        }

}

​

public class SubsetEnumerator<T2> : IEnumerator<T2>

{

    private List<T2> subset;

    private int position = -1;

    public SubsetEnumerator(List<T2> subset)

    {

        this.subset = subset;

    }

​

    public virtual bool MoveNext()

    {

        position++;

        return (position < this.subset.Count());

    }

​

    public virtual void Reset()

    {

        this.position = -1;

    }

​

    object IEnumerator.Current

    {

        get

        {

            return this.Current;

        }

    }

​

    public virtual T2 Current

    {

        get

        {

            try

            {

                return this.subset.ElementAt(this.position);

            }

            catch (IndexOutOfRangeException)

            {

                throw new InvalidOperationException();

            }

        }

    }

​

    void IDisposable.Dispose()

    {

        this.Dispose();

    }

​

    public virtual void Dispose()

    {

    }

}