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

namespace System.Data.Linq
{

    /// <summary>
    /// Simple class to provide CRUD functionality for LINQ-to-SQL objects
    /// </summary>
    public abstract class DatabaseBase<TContext> where TContext : DataContext, new()
    {
        protected DatabaseBase() { }

        #region DataContext Helpers

        public static List<T> Query<T>(Func<TContext, IQueryable<T>> f)
        {
            using (var dc = new TContext { ObjectTrackingEnabled = false }) return f(dc).ToList();
        }

        public static T Query<T>(Func<TContext, T> f)
        {
            using (var dc = new TContext { ObjectTrackingEnabled = false }) return f(dc);
        }

        public static void Use(Action<TContext> f)
        {
            using (var dc = new TContext()) f(dc);
        }

        #endregion

        #region Tables

        protected static TableHelper<TItem> CreateTable<TItem>(Func<TContext, Table<TItem>> tableSelector)
             where TItem : class
        {
            return new TableHelper<TItem>(tableSelector);
        }

        /// <summary>Provides an easy way to create a specific TableBase.</summary>
        /// <param name="tableSelector">A func that selects the needed table.
        /// <example>dc => dc.Accounts</example></param>
        /// <param name="keySelectorExp">An expression to select the table's key.
        /// <example>a => a.AccountId</example></param>
        protected static TableHelper<TItem, TKey> CreateTable<TItem, TKey>(Func<TContext, Table<TItem>> tableSelector, Expression<Func<TItem, TKey>> keySelectorExp)
            where TItem : class
        {
            return new TableHelper<TItem, TKey>(tableSelector, keySelectorExp);
        }

        protected static TableHelper<TItem, TKey1, TKey2> CreateTable<TItem, TKey1, TKey2>(Func<TContext, Table<TItem>> tableSelector,
            Expression<Func<TItem, TKey1>> key1SelectorExp, Expression<Func<TItem, TKey2>> key2SelectorExp)
            where TItem : class
        {
            return new TableHelper<TItem, TKey1, TKey2>(tableSelector, key1SelectorExp, key2SelectorExp);
        }

        /// <summary>
        /// Class to provide CRUD functionality for a specific table. This is the base for TableHelper `TItem`TKey and TableHelper `TItem`TKey`TKey
        /// </summary>
        public class TableHelper<TItem> where TItem : class
        {
            public TableHelper(Func<TContext, Table<TItem>> tableSelector)
            {
                this.tableSelector = tableSelector;
            }
            protected Func<TContext, Table<TItem>> tableSelector;

            #region Basic querying

            public List<TItem> Where(Expression<Func<TItem, bool>> predicate)
            {
                return DatabaseBase<TContext>.Query(dc => tableSelector(dc).Where(predicate));
            }
            public List<TResult> Query<TResult>(Func<Table<TItem>, IQueryable<TResult>> f)
            {
                return DatabaseBase<TContext>.Query(dc => f(tableSelector(dc)));
            }
            public TItem SingleOrDefault(Expression<Func<TItem, bool>> predicate)
            {
                return DatabaseBase<TContext>.Query(dc => tableSelector(dc).SingleOrDefault(predicate));
            }

            #endregion

            #region Insert/Update

            protected static List<T> listApply<T>(IEnumerable<T> items, Func<T, T> f) { return items.Select(f).ToList(); }

            public List<TItem> Insert(IEnumerable<TItem> items)
            {
                return listApply(items, Insert);
            }

            public TItem Insert(TItem item)
            {
                return DatabaseBase<TContext>.Query(dc => {
                    dc.ObjectTrackingEnabled = true;
                    tableSelector(dc).InsertOnSubmit(item);
                    dc.SubmitChanges();
                    return item;
                });
            }

            public List<TItem> Update(IEnumerable<TItem> items)
            {
                return listApply(items, Update);
            }

            public TItem Update(TItem item)
            {
                return DatabaseBase<TContext>.Query(dc => {
                    dc.ObjectTrackingEnabled = true;
                    tableSelector(dc).Attach(item, true);
                    dc.SubmitChanges();
                    return item;
                });
            }

            #endregion
        }

        public class TableHelper<TItem, TKey> : TableHelper<TItem> where TItem : class
        {

            public TableHelper(
                Func<TContext, Table<TItem>> tableSelector,
                Expression<Func<TItem, TKey>> keySelectorExp
                )
                : base(tableSelector)
            {
                this.keySelectorExp = keySelectorExp;
                this.compiledKeySelector = keySelectorExp.Compile();
            }

            Expression<Func<TItem, TKey>> keySelectorExp;
            Func<TItem, TKey> compiledKeySelector;

            // Here we add the single key specific stuff
            private Expression<Func<TItem, bool>> createKeyPredicate(TKey key)
            {
                var itemParam = Expression.Parameter(typeof(TItem), "item");
                var equalExp = Expression.Equal(
                    Expression.Constant(key, typeof(TKey)),
                    Expression.Invoke(keySelectorExp, itemParam));
                return Expression.Lambda<Func<TItem, bool>>(equalExp, itemParam);
            }

            public TItem SelectByKey(TKey key)
            {
                var pred = createKeyPredicate(key);
                return SingleOrDefault(pred);
            }

            public void Delete(IEnumerable<TKey> keys)
            {
                foreach (var key in keys) Delete(key);
            }

            public IList<TItem> Delete(IEnumerable<TItem> items)
            {
                return listApply(items, Delete);
            }

            public TItem Delete(TItem item)
            {
                TKey key = compiledKeySelector(item);
                Delete(key);
                return item;
            }

            public void Delete(TKey key)
            {
                // We have to select first to make sure the item exists
                // This provides the same semantics as update
                // A transaction is needed to enforce this guarantee
                DatabaseBase<TContext>.Use(dc => {
                    using (var txScope = new System.Transactions.TransactionScope()) {
                        var table = tableSelector(dc);
                        var pred = createKeyPredicate(key);
                        var item = table.SingleOrDefault(pred);
                        if (item == null) throw new ChangeConflictException("Row not found.");
                        table.DeleteOnSubmit(item);
                        dc.SubmitChanges();
                        txScope.Complete();
                    }
                });
            }
        }

        public class TableHelper<TItem, TKey1, TKey2> : TableHelper<TItem> where TItem : class
        {
            public TableHelper(
                Func<TContext, Table<TItem>> tableSelector,
                Expression<Func<TItem, TKey1>> key1SelectorExp,
                Expression<Func<TItem, TKey2>> key2SelectorExp
                )
                : base(tableSelector)
            {
                this.key1SelectorExp = key1SelectorExp;
                this.compiledKey1Selector = key1SelectorExp.Compile();
                this.key2SelectorExp = key2SelectorExp;
                this.compiledKey2Selector = key2SelectorExp.Compile();
            }

            Expression<Func<TItem, TKey1>> key1SelectorExp;
            Func<TItem, TKey1> compiledKey1Selector;
            Expression<Func<TItem, TKey2>> key2SelectorExp;
            Func<TItem, TKey2> compiledKey2Selector;

            // Dual key specific stuff
            private Expression<Func<TItem, bool>> createDualKeyPredicate(TKey1 key1, TKey2 key2)
            {
                var itemParam = Expression.Parameter(typeof(TItem), "item");
                var key1EqExp = Expression.Equal(
                    Expression.Constant(key1, typeof(TKey1)),
                    Expression.Invoke(key1SelectorExp, itemParam));
                var key2EqExp = Expression.Equal(
                    Expression.Constant(key2, typeof(TKey2)),
                    Expression.Invoke(key2SelectorExp, itemParam));
                var and = Expression.And(key1EqExp, key2EqExp);
                return Expression.Lambda<Func<TItem, bool>>(and, itemParam);
            }

            public TItem SelectByKey(TKey1 key1, TKey2 key2)
            {
                var pred = createDualKeyPredicate(key1, key2);
                return SingleOrDefault(pred);
            }

            public void Delete(IEnumerable<Tuple<TKey1, TKey2>> keys)
            {
                foreach (var key in keys) Delete(key.A, key.B);
            }

            public IList<TItem> Delete(IEnumerable<TItem> items)
            {
                return listApply(items, Delete);
            }

            public TItem Delete(TItem item)
            {
                var key1 = compiledKey1Selector(item);
                var key2 = compiledKey2Selector(item);
                Delete(key1, key2);
                return item;
            }

            public void Delete(TKey1 key1, TKey2 key2)
            {
                // We have to select first to make sure the item exists
                // This provides the same semantics as update
                // A transaction is needed to enforce this guarantee
                DatabaseBase<TContext>.Use(dc => {
                    using (var txScope = new System.Transactions.TransactionScope()) {
                        var table = tableSelector(dc);
                        var pred = createDualKeyPredicate(key1, key2);
                        var item = table.SingleOrDefault(pred);
                        if (item == null) throw new ChangeConflictException("Row not found.");
                        table.DeleteOnSubmit(item);
                        dc.SubmitChanges();
                        txScope.Complete();
                    }
                });
            }
        }
        #endregion
    }
}