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

using System.Threading;
using System.Threading.Tasks;

#region DS.Framework


namespace DS.Framework.Collections
{
    /// <summary></summary>
    public interface IPage
    {
        #region properties


        /// <summary></summary>
        int CurrentPageIndex { get; }
        /// <summary></summary>
        int CurrentPageSize { get; }

        /// <summary></summary>
        bool HasNextPage { get; }
        /// <summary></summary>
        bool HasPrevPage { get; }

        /// <summary></summary>
        int TotalCount { get; }
        /// <summary></summary>
        int TotalPages { get; }


        #endregion
    }

    /// <summary></summary>
    /// <typeparam name="T"></typeparam>
    public interface IPage<T> : IPage, IList<T>
    {
    }
}

namespace DS.Framework.Extensions
{
    using System.Linq;

    /// <summary></summary>
    public static class SystemExtensions
    {
        #region methods (static)


        /// <summary></summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="source"></param>
        /// <returns></returns>
        public static bool None<T>(this IEnumerable<T> source)
        {
            return !source.Any();
        }

        /// <summary></summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="source"></param>
        /// <param name="predicate"></param>
        /// <returns></returns>
        public static bool None<T>(this IEnumerable<T> source, System.Func<T, bool> predicate)
        {
            return !source.Any(predicate);
        }


        #endregion
    }
}


#endregion

#region DS.Framework.Entities


namespace DS.Framework.Entities
{
    using DS.Framework.Collections;

    /// <summary></summary>
    public interface IEntity
    {
        #region properties


        /// <summary></summary>
        object Id { get; set; }


        #endregion
    }

    /// <summary></summary>
    public interface IEntityRepository
    {
        #region methods


        /// <summary></summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="entity"></param>
        /// <param name="ct"></param>
        /// <returns></returns>
        Task<T> CreateAsync<T>(T entity, CancellationToken ct)
            where T : IEntity;

        /// <summary></summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="entities"></param>
        /// <param name="ct"></param>
        /// <returns></returns>
        Task<IList<T>> CreateAsync<T>(IList<T> entities, CancellationToken ct)
            where T : IEntity;

        /// <summary></summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="entityId"></param>
        /// <param name="ct"></param>
        /// <returns></returns>
        Task<T> RetrieveAsync<T>(object entityId, CancellationToken ct)
            where T : IEntity;

        /// <summary></summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="filter"></param>
        /// <param name="ct"></param>
        /// <returns></returns>
        Task<IList<T>> RetrieveAsync<T>(System.Predicate<T> filter, CancellationToken ct)
            where T : IEntity;

        /// <summary></summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="filter"></param>
        /// <param name="sortby"></param>
        /// <param name="ct"></param>
        /// <returns></returns>
        Task<IList<T>> RetrieveAsync<T>(System.Predicate<T> filter, System.Comparison<T> sortby, CancellationToken ct)
            where T : IEntity;

        /// <summary></summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="filter"></param>
        /// <param name="sortby"></param>
        /// <param name="pageIndex"></param>
        /// <param name="pageSize"></param>
        /// <param name="ct"></param>
        /// <returns></returns>
        Task<IPage<T>> RetrieveAsync<T>(System.Predicate<T> filter, System.Comparison<T> sortby, int pageIndex, int pageSize, CancellationToken ct)
            where T : IEntity;

        /// <summary></summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="entity"></param>
        /// <param name="ct"></param>
        /// <returns></returns>
        Task<T> UpdateAsync<T>(T entity, CancellationToken ct)
            where T : IEntity;

        /// <summary></summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="entities"></param>
        /// <param name="ct"></param>
        /// <returns></returns>
        Task<IList<T>> UpdateAsync<T>(IList<T> entities, CancellationToken ct)
            where T : IEntity;

        /// <summary></summary>
        /// <param name="entityId"></param>
        /// <param name="ct"></param>
        /// <returns></returns>
        Task DeleteAsync(object entityId, CancellationToken ct);

        /// <summary></summary>
        /// <param name="entityIds"></param>
        /// <param name="ct"></param>
        /// <returns></returns>
        Task DeleteAsync(IList<object> entityIds, CancellationToken ct);


        #endregion
    }


    /// <summary></summary>
    public abstract class BaseEntity
    {
    }

    /// <summary></summary>
    /// <typeparam name="TEntityId"></typeparam>
    public abstract class BaseEntity<TEntityId> : BaseEntity, IEntity
    {
        #region properties


        /// <summary></summary>
        public TEntityId Id { get; set; }


        #endregion

        #region IEntity properties


        object IEntity.Id
        {
            get { return this.Id; }
            set { this.Id = (TEntityId)value; }
        }


        #endregion
    }
}


#endregion

#region DS.Framework.Entities.Couch


namespace DS.Framework.Entities.Couch
{
    using DS.Framework.Collections;

    /// <summary></summary>
    /// <typeparam name="TEntityId"></typeparam>
    public abstract class CouchEntity<TEntityId> : BaseEntity<TEntityId>
    {
        #region ctor


        /// <summary></summary>
        protected CouchEntity()
        {
            this.Type = this.GetType().FullName;
        }


        #endregion

        #region properties


        /// <summary></summary>
        public string Type { get; private set; }


        #endregion
    }

    /// <summary></summary>
    public abstract class CouchEntityRepository : IEntityRepository
    {
        #region ctor


        /// <summary></summary>
        /// <param name="cluster"></param>
        protected CouchEntityRepository(Couchbase.Core.ICluster cluster)
        {
            this.Cluster = cluster;
        }


        #endregion

        #region properties


        /// <summary></summary>
        protected Couchbase.Core.ICluster Cluster { get; private set; }

        /// <summary></summary>
        protected abstract string BucketName { get; }


        #endregion

        #region IEntityRepository methods


        /// <summary></summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="entity"></param>
        /// <param name="ct"></param>
        /// <returns></returns>
        public virtual async Task<T> CreateAsync<T>(T entity, CancellationToken ct) where T : IEntity
        {
            throw new System.NotImplementedException();
        }

        /// <summary></summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="entities"></param>
        /// <param name="ct"></param>
        /// <returns></returns>
        public virtual async Task<IList<T>> CreateAsync<T>(IList<T> entities, CancellationToken ct) where T : IEntity
        {
            throw new System.NotImplementedException();
        }

        public virtual async Task DeleteAsync(object entityId, CancellationToken ct)
        {
            throw new System.NotImplementedException();
        }

        /// <summary></summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="entityId"></param>
        /// <param name="ct"></param>
        /// <returns></returns>
        public virtual async Task<T> RetrieveAsync<T>(object entityId, CancellationToken ct) where T : IEntity
        {
            throw new System.NotImplementedException();
        }

        /// <summary></summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="filter"></param>
        /// <param name="ct"></param>
        /// <returns></returns>
        public virtual async Task<IList<T>> RetrieveAsync<T>(System.Predicate<T> filter, CancellationToken ct) where T : IEntity
        {
            throw new System.NotImplementedException();
        }

        /// <summary></summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="filter"></param>
        /// <param name="sortby"></param>
        /// <param name="ct"></param>
        /// <returns></returns>
        public virtual async Task<IList<T>> RetrieveAsync<T>(System.Predicate<T> filter, System.Comparison<T> sortby, CancellationToken ct) where T : IEntity
        {
            throw new System.NotImplementedException();
        }

        /// <summary></summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="filter"></param>
        /// <param name="sortby"></param>
        /// <param name="pageIndex"></param>
        /// <param name="pageSize"></param>
        /// <param name="ct"></param>
        /// <returns></returns>
        public virtual async Task<IPage<T>> RetrieveAsync<T>(System.Predicate<T> filter, System.Comparison<T> sortby, int pageIndex, int pageSize, CancellationToken ct) where T : IEntity
        {
            throw new System.NotImplementedException();
        }

        /// <summary></summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="entity"></param>
        /// <param name="ct"></param>
        /// <returns></returns>
        public virtual async Task<T> UpdateAsync<T>(T entity, CancellationToken ct) where T : IEntity
        {
            throw new System.NotImplementedException();
        }

        /// <summary></summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="entities"></param>
        /// <param name="ct"></param>
        /// <returns></returns>
        public virtual async Task<IList<T>> UpdateAsync<T>(IList<T> entities, CancellationToken ct) where T : IEntity
        {
            throw new System.NotImplementedException();
        }

        /// <summary></summary>
        /// <param name="entityIds"></param>
        /// <param name="ct"></param>
        /// <returns></returns>
        public virtual async Task DeleteAsync(IList<object> entityIds, CancellationToken ct)
        {
            throw new System.NotImplementedException();
        }


        #endregion
    }
}


#endregion

#region DS.Framework.Entities.MsSql
#endregion

#region DS.Providers.Configuration


namespace DS.Providers.Configuration
{
    /// <summary></summary>
    public interface IConfigProvider
    {
        #region properties


        /// <summary></summary>
        /// <param name="key"></param>
        /// <returns></returns>
        string this[string key] { get; }


        #endregion
    }
}


#endregion

#region DS.Providers.Cryptography
#endregion

#region DS.Providers.Email


namespace DS.Providers.Email
{
    /// <summary></summary>
    public interface IEmailProvider
    {
        #region methods


        /// <summary></summary>
        /// <param name="message"></param>
        /// <param name="ct"></param>
        /// <returns></returns>
        Task SendAsync(EmailMessage message, CancellationToken ct);

        /// <summary></summary>
        /// <param name="messages"></param>
        /// <param name="ct"></param>
        /// <returns></returns>
        Task SendAsync(IList<EmailMessage> messages, CancellationToken ct);

        /// <summary></summary>
        /// <param name="json"></param>
        /// <param name="template"></param>
        /// <returns></returns>
        EmailMessage Transform(string json, EmailTemplate template);


        #endregion
    }


    /// <summary></summary>
    public class EmailMessage
    {
        #region properties
        #endregion
    }

    /// <summary></summary>
    public class EmailTemplate
    {
        #region properties
        #endregion
    }
}


#endregion

#region DS.Providers.Email.Smtp


namespace DS.Providers.Email.Smtp
{
    /// <summary></summary>
    public class SmtpProvider : IEmailProvider
    {
        #region ctor


        /// <summary></summary>
        /// <param name="host"></param>
        /// <param name="port"></param>
        /// <param name="username"></param>
        /// <param name="password"></param>
        public SmtpProvider(string host, string port, string username, string password)
        {
            this._host = host;
            this._port = port;
            this._user = username;
            this._pass = password;
        }


        #endregion

        #region members


        private readonly string _host;
        private readonly string _port;
        private readonly string _user;
        private readonly string _pass;


        #endregion

        #region methods


        private System.Net.Mail.SmtpClient CreateSmtpClient()
        {
            return new System.Net.Mail.SmtpClient
            {
                Host = this._host,
                Port = int.Parse(this._port),
                DeliveryMethod = System.Net.Mail.SmtpDeliveryMethod.Network,
                Credentials = new System.Net.NetworkCredential(this._user, this._user),
            };
        }

        private System.Net.Mail.MailMessage CreateSmtpMessage(EmailMessage message)
        {
            throw new System.NotImplementedException();
        }


        #endregion

        #region IEmailProvider methods


        /// <summary></summary>
        /// <param name="message"></param>
        /// <param name="ct"></param>
        /// <returns></returns>
        public virtual async Task SendAsync(EmailMessage message, CancellationToken ct)
        {
            await this.SendAsync(new List<EmailMessage> { message }, ct);
        }

        /// <summary></summary>
        /// <param name="messages"></param>
        /// <param name="ct"></param>
        /// <returns></returns>
        public virtual async Task SendAsync(IList<EmailMessage> messages, CancellationToken ct)
        {
            using (var smtp = this.CreateSmtpClient())
            {
                foreach (var message in messages)
                    await smtp.SendMailAsync(this.CreateSmtpMessage(message));
            }
        }

        /// <summary></summary>
        /// <param name="json"></param>
        /// <param name="template"></param>
        /// <returns></returns>
        public virtual EmailMessage Transform(string json, EmailTemplate template)
        {
            throw new System.NotImplementedException();
        }


        #endregion
    }
}


#endregion




#region Tests.DS.Framework


namespace DS.Framework.Extensions
{
    using Microsoft.VisualStudio.TestTools.UnitTesting;

    [TestClass]
    public class SystemExtensionsTests
    {
        [TestMethod]
        public void None_returns_true_when_sequence_has_no_items()
        {
            // arrange
            var source = new List<object>();

            // act
            var actual = SystemExtensions.None(source);

            // assert
            Assert.IsTrue(actual);
        }

        [TestMethod]
        public void None_returns_true_when_sequence_has_no_items_that_satisfy_the_given_predicate()
        {
            // arrange
            var source = new List<Example> { new Example(0), new Example(1) };

            // act
            var actual = SystemExtensions.None(source, e => e.Value == 3);

            // assert
            Assert.IsTrue(actual);
        }

        [TestMethod]
        public void None_returns_false_when_sequence_has_items()
        {
            // arrange
            var source = new List<object> { new object(), new object() };

            // act
            var actual = SystemExtensions.None(source);

            // assert
            Assert.IsFalse(actual);
        }

        [TestMethod]
        public void None_returns_false_when_sequence_has_items_that_satisfy_the_given_predicate()
        {
            // arrange
            var source = new List<Example> { new Example(0), new Example(1) };

            // act
            var actual = SystemExtensions.None(source, e => e.Value == 0);

            // assert
            Assert.IsFalse(actual);
        }

        private class Example
        {
            public Example(int value)
            {
                this.Value = value;
            }

            public int Value { get; private set; }
        }
    }
}


#endregion

#region Tests.DS.Framework.Entities
#endregion

#region Tests.DS.Framework.Entities.Couch
#endregion