#region Using Directives

using System;
using System.Collections.Generic;
using System.Linq.Expressions;

#endregion

namespace BlogPosts
{
    public class Sequence
    {
        public static IEnumerable<T> From<T>( T min, T max )
        {
            return From( min, max, i => Operator.Add( i, 1 ) );
        }

        public static IEnumerable<T> From<T>( T min, T max, T increment )
        {
            return From( min, max, i => Operator.Add<T>( i, increment ), default( T ) );
        }

        public static IEnumerable<T> From<T>( T min, T max, Func<T, T> increment )
        {
            return From( min, max, increment, default( T ) );
        }

        public static IEnumerable<T> From<T>( T min, T max, T increment, T offset )
        {
            return From( min, max, i => Operator.Add<T>( i, increment ), offset );
        }

        public static IEnumerable<T> From<T>( T min, T max, Func<T, T> increment, T offset )
        {
            return From( min, max, increment, i => true, offset );
        }

        public static IEnumerable<T> From<T>( T min, T max, T increment, Func<T, bool> filter )
        {
            return From( min,
                         i => Operator.LessThan( i, max ),
                         i => Operator.Add<T>( i, increment ),
                         filter );
        }

        public static IEnumerable<T> From<T>( T min, Func<T, bool> max, T increment )
        {
            return From( min, max, i => Operator.Add<T>( i, increment ) );
        }

        public static IEnumerable<T> From<T>( T min, T max, T increment, Func<T, bool> filter, T offset )
        {
            return From( Operator.Add<T>( min, offset ),
                         i => Operator.LessThan( i, max ),
                         i => Operator.Add<T>( i, increment ),
                         filter );
        }

        public static IEnumerable<T> From<T>( T min, T max, Func<T, T> increment, Func<T, bool> filter )
        {
            return From( min, i => Operator.LessThan( i, max ), increment, filter );
        }

        public static IEnumerable<T> From<T>( T min, T max, Func<T, T> increment, Func<T, bool> filter, T offset )
        {
            return From( Operator.Add<T>( min, offset ),
                         i => Operator.LessThan( i, max ),
                         increment,
                         filter );
        }

        public static IEnumerable<T> From<T>( T min, Func<T, bool> max, Func<T, T> increment )
        {
            return From( min, max, increment, i => true );
        }

        public static IEnumerable<T> From<T>( T min, Func<T, bool> max, Func<T, T> increment, Func<T, bool> filter )
        {
            for ( T i = min; max( i ); i = increment( i ) )
            {
                if ( filter( i ) )
                {
                    yield return i;
                }
            }
        }

        #region Nested type: Operator

        private class Operator
        {
            public static T Add<T>( T lhs, T rhs )
            {
                return Operators<T>.AddDelegate.Invoke( lhs, rhs );
            }

            public static TLhs Add<TLhs, TRhs>( TLhs lhs, TRhs rhs )
            {
                return Operators<TRhs, TLhs>.AddDelegate.Invoke( lhs, rhs );
            }

            public static bool LessThan<T>( T lhs, T rhs )
            {
                return Operators<T>.LessThanDelegate.Invoke( lhs, rhs );
            }

            #region Nested type: Operators

            private class Operators<T>
            {
                public static readonly Func<T, T, T> AddDelegate;
                public static readonly Func<T, T, bool> LessThanDelegate;

                static Operators()
                {
                    AddDelegate = CreateAddDelegate();
                    LessThanDelegate = CreateLessThanDelegate();
                }

                private static Func<T, T, T> CreateAddDelegate()
                {
                    ParameterExpression lhs = Expression.Parameter( typeof (T), "lhs" );
                    ParameterExpression rhs = Expression.Parameter( typeof (T), "rhs" );

                    return
                        Expression.Lambda<Func<T, T, T>>(
                            new Func<Expression, Expression, BinaryExpression>( Expression.Add )
                                .Invoke( lhs, rhs ), new[] {lhs, rhs} )
                            .Compile();
                }

                private static Func<T, T, bool> CreateLessThanDelegate()
                {
                    ParameterExpression lhs = Expression.Parameter( typeof (T), "lhs" );
                    ParameterExpression rhs = Expression.Parameter( typeof (T), "rhs" );

                    return
                        Expression.Lambda<Func<T, T, bool>>(
                            new Func<Expression, Expression, BinaryExpression>( Expression.LessThan )
                                .Invoke( lhs, rhs ), new[] {lhs, rhs} )
                            .Compile();
                }
            }

            private class Operators<TValue, TResult>
            {
                public static readonly Func<TResult, TValue, TResult> AddDelegate;

                static Operators()
                {
                    AddDelegate = CreateAddDelegate();
                }

                private static Func<TResult, TValue, TResult> CreateAddDelegate()
                {
                    ParameterExpression lhs = Expression.Parameter( typeof (TValue), "lhs" );
                    ParameterExpression rhs = Expression.Parameter( typeof (TResult), "rhs" );

                    return
                        Expression.Lambda<Func<TResult, TValue, TResult>>(
                            new Func<Expression, Expression, BinaryExpression>( Expression.Add )
                                .Invoke( lhs, rhs ), new[] {lhs, rhs} )
                            .Compile();
                }
            }

            #endregion
        }

        #endregion
    }
}