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

namespace LinqExtensions
{
    public static class Extensions
    {
        public interface IEqualTo<T, T2, TKey>
        {
            IEnumerable<TResult> Alias<TResult>(Func<T, T2, TResult> composite);
        }

        public interface IOn<T, T2, TKey>
        {
            IEqualTo<T, T2, TKey> EqualTo(Func<T2, TKey> toFunction);
        }

        public interface IJoin<T, T2>
        {
            IOn<T, T2, TKey> On<TKey>(Func<T, TKey> fromFunction);
        }

        private class Join<T, T2> : IJoin<T, T2>
        {
            public IEnumerable<T> FromList { get; set; }
            public IEnumerable<T2> ToList { get; set; }

            public IOn<T, T2, TKey> On<TKey>(Func<T, TKey> fromFunction)
            {
                return new On<T, T2, TKey> { Join = this, FromFunction = fromFunction };
            }
        }

        private class On<T, T2, TKey> : IOn<T, T2, TKey>
        {
            public IJoin<T, T2> Join { get; set; }
            public Func<T, TKey> FromFunction { get; set; }


            public IEqualTo<T, T2, TKey> EqualTo(Func<T2, TKey> toFunction)
            {
                return new Is<T, T2, TKey> { Join = Join, FromFunction = FromFunction, ToFunction = toFunction };
            }

        }

        private class Is<T, T2, TKey> : IEqualTo<T, T2, TKey>
        {
            public IJoin<T, T2> Join { get; set; }
            public Func<T, TKey> FromFunction { get; set; }
            public Func<T2, TKey> ToFunction { get; set; }

            public IEnumerable<TResult> Alias<TResult>(Func<T, T2, TResult> composite)
            {
                var join = ((Join<T, T2>)Join);
                return join.FromList.Join(join.ToList, FromFunction, ToFunction, composite);
            }
        }

        public static IJoin<T, T2> JoinTo<T, T2>(this IEnumerable<T> joinFrom, IEnumerable<T2> joinTo)
        {
            return new Join<T, T2> { FromList = joinFrom, ToList = joinTo };
        }

    }
}