using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using xCommons.Extensions;
using xExceptions.Constants;
using xModels.Base;
using xModels.Dtos;
using xModels.Providers;
using xPushService.Interfaces;
using xPushService.Models;

namespace xPushService.Store {
    public class XPushConnectionInMemoryStore : XBaseInMemoryStore<XPushConnectionDto, string>, IXPushConnectionStore {
        //
        #region Custom ...
        /// <summary>
        /// retrieve specific connection by it's Id ...
        /// </summary>
        /// <param name="connectionId"></param>
        /// <returns></returns>
        public Task<XPushConnectionDto> GetByConnectionId (string connectionId) {
            return Get (connectionId);
        }

        /// <summary>
        /// retrieve specific user's connections ...
        /// </summary>
        /// <param name="userName"></param>
        /// <returns></returns>
        public Task<IEnumerable<XPushConnectionDto>> GetByUserName (string userName) {
            return FindMany (c => c.User.ToNormalString () == userName.ToNormalString ());
        }

        /// <summary>
        /// retrieve specific user's connected device connection
        /// </summary>
        /// <param name="userName"></param>
        /// <param name="device"></param>
        /// <returns></returns>
        public Task<XPushConnectionDto> GetByUserDevice (string userName, XDeviceDto device) {
            return FindOne (c =>
                c.User.ToNormalString () == userName.ToNormalString () &&
                c.Device.IsSameContent (
                    device, null, null, null, false
                )
            );
        }

        /// <summary>
        /// check a connection exists or not by it's id ...
        /// </summary>
        /// <param name="connectionId"></param>
        /// <returns></returns>
        public Task<bool> IsExistsConnectionId (string connectionId) {
            return IsExistsByKey (connectionId);
        }

        /// <summary>
        /// check specific user connected or not ...
        /// </summary>
        /// <param name="userName"></param>
        /// <returns></returns>
        public Task<bool> IsExistsUser (string userName) {
            return GetByUserName (userName)
                .ContinueWith (findTask => {
                    //
                    var findResult = findTask
                        .RunTask();

                    //
                    var result = findResult.Any ();
                    return result;
                });
        }

        /// <summary>
        /// retrieve specific user's connected devices ...
        /// </summary>
        /// <param name="userName"></param>
        /// <param name="device"></param>
        /// <returns></returns>
        public Task<IEnumerable<XDeviceDto>> GetUserDevices (string userName) {
            return GetByUserName (userName)
                .ContinueWith (userConnectionsTask => {
                    //
                    var userConnections = userConnectionsTask
                        .RunTask();

                    //
                    var result = userConnections.Select (c => c.Device);
                    return result;
                });
        }

        /// <summary>
        /// remove specific connection by it's id ...
        /// </summary>
        /// <param name="connectionId"></param>
        /// <returns></returns>
        public Task<bool> RemoveByConnectionId (string connectionId) {
            return RemoveByKey (connectionId);
        }

        /// <summary>
        /// remove specified user's connected device connection ...
        /// </summary>
        /// <param name="userName"></param>
        /// <param name="device"></param>
        /// <returns></returns>
        public Task<bool> RemoveByUserDevice (string userName, XDeviceDto device) {
            return GetByUserDevice (
                    device: device,
                    userName: userName
                )
                .ContinueWith (connectionTask => {
                    //
                    var connection = connectionTask
                        .RunTask();

                    //
                    if (connection.IsNull ()) {
                        return false;
                    }

                    //
                    var result = Remove (connection)
                        .RunTask();
                    return result;
                });
        }

        /// <summary>
        /// remove specific user's all connected devices ...
        /// </summary>
        /// <param name="userName"></param>
        /// <returns></returns>
        public Task<bool> RemoveUser (string userName) {
            return GetByUserName (userName)
                .ContinueWith (connectionsTask => {
                    //
                    var connections = connectionsTask
                        .RunTask();

                    //
                    if (!connections.HasChild ()) {
                        return false;
                    }

                    //
                    var result = RemoveMany (new XBaseRangeRequest<XPushConnectionDto> {
                            Items = connections
                        })
                        .RunTask();

                    //
                    return result;
                });
        }

        /// <summary>
        /// Get specific connections last seen ...
        /// </summary>
        /// <param name="connectionId"></param>
        /// <returns></returns>
        public Task<DateTime> GetLastSeenByConnectionId (string connectionId) {
            return GetByConnectionId (connectionId)
                .ContinueWith (connectionTask => {
                    //
                    var connection = connectionTask
                        .RunTask();

                    //
                    if (connection.IsNull ()) {
                        throw XException.NotFound.ToException ();
                    }

                    //
                    var result = connection.LastSeen;
                    return result;
                });
        }

        /// <summary>
        /// get specific user's last seen ...
        /// </summary>
        /// <param name="userName"></param>
        /// <returns></returns>
        public Task<DateTime> GetLastSeenByUserName (string userName) {
            return GetByUserName (userName)
                .ContinueWith (connectionsTask => {
                    //
                    var connections = connectionsTask
                        .RunTask ();

                    //
                    if (!connections.HasChild ()) {
                        throw XException.NotFound.ToException ();
                    }

                    //
                    var result = connections
                        .Select (c => c.LastSeen)
                        .Max ();

                    //
                    return result;
                });
        }

        /// <summary>
        /// get specific user's connected device last seen ...
        /// </summary>
        /// <param name="userName"></param>
        /// <param name="device"></param>
        /// <returns></returns>
        public Task<DateTime> GetLastSeenByUserDevice (string userName, XDeviceDto device) {
            return GetByUserDevice (
                    device: device,
                    userName: userName
                )
                .ContinueWith (connectionTask => {
                    //
                    var connection = connectionTask
                        .RunTask ();

                    //
                    if (connection.IsNull ()) {
                        throw XException.NotFound.ToException ();
                    }

                    //
                    var result = connection.LastSeen;
                    return result;
                });
        }

        /// <summary>
        /// Update Connection last seen ...
        /// </summary>
        /// <param name="connectionId"></param>
        /// <returns></returns>
        public Task<bool> UpdateLastSeen (string connectionId) {
            return IsExistsConnectionId (connectionId)
                .ContinueWith (isExistsTask => {
                    //
                    // define empty result ...
                    var result = false;

                    //
                    // run task and get result ...
                    result = isExistsTask
                        .RunTask();

                    //
                    // check result is false ...
                    if (!result) {
                        return result;
                    }

                    //
                    // retreive connection ...
                    var connection = GetByConnectionId (connectionId)
                        .RunTask();
                    result = !connection.IsNull ();
                    if (!result) {
                        return result;
                    }

                    //
                    // Update Connection last seen ...
                    connection.LastSeen = DateTime.UtcNow;
                    var updatedConnection = Update (connection)
                        .RunTask ();
                    result = !updatedConnection.IsNull ();

                    //
                    return result;
                });
        }
        #endregion
    }
}