using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.AspNetCore.SignalR;
using xCommons.Extensions;
using xExceptions.Constants;
using xModels.Dtos;
using xPushService.Constants;
using xPushService.Extensions;
using xPushService.Interfaces;
using xPushService.Models;

namespace xPushService.Base {
    public abstract class XBaseWebRTCHub : XBaseHub {
        //
        #region Props ...
        protected readonly IXWebRTCConnectionStore webRTCConnectionStore;
        #endregion

        //
        #region Constructor ...
        public XBaseWebRTCHub (
            IXPushGroupStore groupStore,
            IXPushConnectionStore connectionStore,
            IXWebRTCConnectionStore webRTCConnectionStore
        ) : base (groupStore, connectionStore) {
            this.webRTCConnectionStore = webRTCConnectionStore;
        }
        #endregion

        //
        #region Overrides ...
        public override Task OnConnectedAsync () {
            return base.OnConnectedAsync ();
        }

        public override Task OnDisconnectedAsync (Exception exception) {
            // //
            // var connectionId = GetConnectionId ();

            // //
            // // Find Connections Active Calls ...
            // var activeConnections = webRTCConnectionStore
            //     .FindMany (c => c.CallerConnectionId
            //         .ToNormalString () == connectionId
            //         .ToNormalString () ||
            //         c.IsInCallees (connectionId)
            //     )
            //     .RunTask ();

            // //
            // if (activeConnections.HasChild ()) {
            //     activeConnections
            //         .ToList ()
            //         .ForEach (c => {
            //             //
            //             CancelCall (
            //                     cancellerConnectionId: connectionId,
            //                     reason: XCallEndReason.Disconnected,
            //                     request: c
            //                 )
            //                 .RunTask ();
            //         });
            // }

            //
            return base.OnDisconnectedAsync (exception);
        }
        #endregion

        //
        #region Actions ...
        /// <summary>
        /// Send PreOffer Call Request ...
        /// </summary>
        /// <param name="type"></param>
        /// <param name="connectionId"></param>
        /// <param name="device"></param>
        /// <returns></returns>
        public Task<bool> RequestCall (
            XCallType type,
            string connectionId,
            XDeviceDto device
        ) {
            //
            // Validate Args ...
            if (type == XCallType.None || connectionId.IsNullOrEmpty ()) {
                return Task.FromResult (false);
            }

            //
            // Check Connection Exists ...
            var isConnectionExists = connectionStore
                .IsExistsConnectionId (connectionId)
                .RunTask ();
            if (!isConnectionExists) {
                return Task.FromResult (false);
            }

            //
            // retrieve connection object ...
            var request = GetWebRTCConnection (
                    calleeDevice: device,
                    connectionType: type,
                    calleeConnectionId: connectionId
                )
                .RunTask ();

            //
            // Add Connection to Store ...
            AddOrUpdateWebRTCConnection (request)
                .RunTask ();

            //
            try {
                //
                Clients
                    .Clients (
                        request
                        .GetReceivers ()
                    )
                    .SendAsync (
                        XWebRTCAction.RequestCall.GetStringValue (),
                        request
                    )
                    .RunTask ();

                //
                return Task.FromResult (true);
            } catch { }

            //
            return Task.FromResult (false);
        }

        /// <summary>
        /// Send PreOffer Call Request ...
        /// </summary>
        /// <param name="type"></param>
        /// <param name="user"></param>
        /// <param name="device"></param>
        /// <returns></returns>
        public Task<bool> RequestUserCall (
            XCallType type,
            string user,
            XDeviceDto device
        ) {
            //
            // Validate Args ...
            if (type == XCallType.None || user.IsNullOrEmpty ()) {
                return Task.FromResult (false);
            }

            //
            // Check Connection Exists ...
            var isConnectionExists = connectionStore
                .IsExistsUser (user)
                .RunTask ();
            if (!isConnectionExists) {
                return Task.FromResult (false);
            }

            //
            // retrieve connection object ...
            var request = GetUserWebRTCConnection (
                    calleeDevice: device,
                    connectionType: type,
                    calleeUser: user
                )
                .RunTask ();

            //
            // Add Connection to Store ...
            AddOrUpdateWebRTCConnection (request)
                .RunTask ();

            //
            try {
                //
                Clients
                    .Clients (
                        request
                        .GetReceivers ()
                    )
                    .SendAsync (
                        XWebRTCAction.RequestCall.GetStringValue (),
                        request
                    )
                    .RunTask ();

                //
                return Task.FromResult (true);
            } catch { }

            //
            return Task.FromResult (false);
        }

        /// <summary>
        /// Cancel or End Requested Call ...
        /// </summary>
        /// <returns></returns>
        public Task<bool> CancelCall (
            string cancellerConnectionId,
            XCallEndReason reason,
            XWebRTCConnectionDto request) {
            //
            // Validate Args ...
            var isValid = IsWebRTCConnectionsExists (request)
                .RunTask ();
            if (!isValid) {
                return Task.FromResult (false);
            }

            //
            // Check if i am Caller ...
            var isCancellerCaller = request
                .IsCaller (cancellerConnectionId);
            var isCancellerInCallees = request
                .IsInCallees (cancellerConnectionId);

            //
            if (isCancellerCaller) {
                //
                request.Callees.ToList ().ForEach (callee => {
                    //
                    callee.EndReason = reason;
                    callee.EndTime = DateTime.UtcNow;
                });

                //
                // Remove Connection From Store ...
                webRTCConnectionStore
                    .Remove (request)
                    .RunTask ();
            } else if (isCancellerInCallees) {
                //
                var canceller = request.GetCallee (cancellerConnectionId);
                if (canceller.IsNull ()) {
                    return Task.FromResult (false);
                }

                //
                var updatedCanceller = canceller;
                updatedCanceller.EndReason = reason;
                updatedCanceller.EndTime = DateTime.UtcNow;

                //
                request.Callees = request.Callees
                    .Update (canceller, updatedCanceller);

                //
                // Remove connection from Store if all callees end calls ...
                var canRemoveConnection = request.Callees.All (c => !c.EndTime.IsNull () && !c.EndReason.IsNull ());
                if (canRemoveConnection) {
                    webRTCConnectionStore
                        .Remove (request)
                        .RunTask ();
                } else {
                    webRTCConnectionStore
                        .Update (request)
                        .RunTask ();
                }
            }

            //
            try {
                //
                Clients
                    .Clients (
                        request.GetReceivers ()
                    )
                    .SendAsync (
                        XWebRTCAction.CancelCall.GetStringValue (),
                        request
                    );

                //
                return Task.FromResult (true);
            } catch {
                return Task.FromResult (false);
            }
        }

        /// <summary>
        /// end a call request ...
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public Task<bool> RejectCall (
            string rejecterConnectionId,
            XWebRTCConnectionDto request
        ) {
            //
            // Validate Args ...
            var isValid = IsWebRTCConnectionsExists (request)
                .RunTask ();
            var isRejecterInCallees = request
                .IsInCallees (rejecterConnectionId);
            if (!isValid ||
                !isRejecterInCallees ||
                rejecterConnectionId.IsNullOrEmpty ()
            ) {
                return Task.FromResult (false);
            }

            //
            // Find Rejecter and Push Reject to it ...
            var rejecter = request
                .GetCallee (rejecterConnectionId);
            if (rejecter.IsNull ()) {
                return Task.FromResult (false);
            }

            //
            // Update request Callees ...
            var updatedRejecter = rejecter;
            updatedRejecter.EndTime = DateTime.UtcNow;
            updatedRejecter.EndReason = XCallEndReason.Reject;
            request.Callees = request.Callees
                .Update (rejecter, updatedRejecter);

            //
            // Check if Only one Callee and he Reject, Remove connection From Store,
            // otherwise Update connection ...
            var canRemoveConnection = request
                .Callees.Count () == 1 && request.Callees
                .All (c => c.ConnectionId
                    .ToNormalString () == rejecterConnectionId
                    .ToNormalString ()
                );
            if (canRemoveConnection) {
                webRTCConnectionStore
                    .Remove (request)
                    .RunTask ();
            }

            //
            // Prepare Receivers ...
            var receivers = new List<string> () {
                    request.CallerConnectionId,
                        rejecterConnectionId
                }
                .AsReadOnly ();

            //
            try {
                //
                Clients
                    .Clients (receivers)
                    .SendAsync (
                        XWebRTCAction.RejectCall.GetStringValue (),
                        request
                    )
                    .RunTask ();

                //
                return Task.FromResult (true);
            } catch { }

            //
            return Task.FromResult (false);
        }

        /// <summary>
        /// answer a call request ...
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public Task<bool> AcceptCall (
            string accepterConnectionId,
            XWebRTCConnectionDto request
        ) {
            //
            // Validate Args ...
            var isValid = IsWebRTCConnectionsExists (request)
                .RunTask ();
            var isAccepterInCallees = request
                .IsInCallees (accepterConnectionId);
            if (!isValid ||
                !isAccepterInCallees ||
                accepterConnectionId.IsNullOrEmpty ()
            ) {
                return Task.FromResult (false);
            }

            //
            // Add Or Update ...
            AddOrUpdateWebRTCConnection (request)
                .RunTask ();

            //
            // prepare recievers ...
            var receivers = new List<string> () {
                    request.CallerConnectionId,
                        accepterConnectionId,
                }
                .AsReadOnly ();

            //
            try {
                //
                Clients
                    .Clients (receivers)
                    .SendAsync (
                        XWebRTCAction.AcceptCall.GetStringValue (),
                        request
                    )
                    .RunTask ();

                //
                return Task.FromResult (true);
            } catch {
                return Task.FromResult (false);
            }
        }
        #endregion

        //
        #region WebRTC Signaling ...
        /// <summary>
        /// Send WebRTC Offer ...
        /// </summary>
        /// <param name="signal"></param>
        /// <param name="request"></param>
        /// <returns></returns>
        public Task<bool> WebRTCOffer (
            XWebRTCSignalDto signal,
            XWebRTCConnectionDto request
        ) {
            //
            if (
                signal.IsNull () ||
                signal.Offer.IsNull () ||
                !IsValidWebRTCConnection (request)
            ) {
                return Task.FromResult (false);
            }

            //
            var connectionId = GetConnectionId ();
            var offerRecievers = request
                .GetReceivers ()
                .Where (r => r.ToNormalString () != connectionId.ToNormalString ())
                .ToList ()
                .AsReadOnly ();

            //
            try {
                //
                Clients
                    .Clients (offerRecievers)
                    .SendAsync (
                        XWebRTCAction.WebRTCOffer.GetStringValue (),
                        signal,
                        request
                    )
                    .RunTask ();

                //
                return Task.FromResult (true);
            } catch {
                return Task.FromResult (false);
            }
        }

        /// <summary>
        /// Send WebRTC Answer ...
        /// </summary>
        /// <param name="signal"></param>
        /// <param name="request"></param>
        /// <returns></returns>
        public Task<bool> WebRTCAnswer (
            XWebRTCSignalDto signal,
            XWebRTCConnectionDto request
        ) {
            //
            if (
                signal.IsNull () ||
                signal.Offer.IsNull () ||
                signal.Answer.IsNull () ||
                !IsValidWebRTCConnection (request)
            ) {
                return Task.FromResult (false);
            }

            //
            var connectionId = GetConnectionId ();
            var answerRecievers = request
                .GetReceivers ()
                .Where (r => r.ToNormalString () != connectionId.ToNormalString ())
                .ToList ()
                .AsReadOnly ();

            //
            try {
                //
                Clients
                    .Clients (answerRecievers)
                    .SendAsync (
                        XWebRTCAction.WebRTCAnswer.GetStringValue (),
                        signal,
                        request
                    )
                    .RunTask ();

                //
                return Task.FromResult (true);
            } catch {
                return Task.FromResult (false);
            }
        }

        /// <summary>
        /// Send WebRTC ICE Candidates ...
        /// </summary>
        /// <param name="signal"></param>
        /// <param name="request"></param>
        /// <returns></returns>
        public Task<bool> WebRTCICECandidate (
            XWebRTCSignalDto signal,
            XWebRTCConnectionDto request
        ) {
            //
            if (
                signal.IsNull () ||
                signal.Offer.IsNull () ||
                signal.Answer.IsNull () ||
                !signal.Cadidates.HasChild () ||
                !IsValidWebRTCConnection (request)
            ) {
                return Task.FromResult (false);
            }

            //
            var connectionId = GetConnectionId ();
            var candidatesRecievers = request
                .GetReceivers ()
                .Where (r => r.ToNormalString () != connectionId.ToNormalString ())
                .ToList ()
                .AsReadOnly ();

            //
            try {
                //
                Clients
                    .Clients (candidatesRecievers)
                    .SendAsync (
                        XWebRTCAction.WebRTCICECandidate.GetStringValue (),
                        signal,
                        request
                    )
                    .RunTask ();

                //
                return Task.FromResult (true);
            } catch {
                return Task.FromResult (false);
            }
        }
        #endregion

        //
        #region Protected ...
        /// <summary>
        /// create first time WebRTC connection by user name ...
        /// </summary>
        /// <param name="connectionType"></param>
        /// <param name="calleeUser"></param>
        /// <param name="calleeDevice"></param>
        /// <returns></returns>
        protected Task<XWebRTCConnectionDto> GetUserWebRTCConnection (
            XCallType connectionType,
            string calleeUser,
            XDeviceDto calleeDevice
        ) {
            //
            // Validate Args ...
            if (
                calleeDevice.IsNull () ||
                connectionType == XCallType.None ||
                calleeUser.IsNullOrEmpty ()
            ) {
                throw XException.InvalidArgs.ToException ();
            }

            //
            var id = Guid.NewGuid ().ToString ();

            //
            var httpContext = Context.GetHttpContext ();
            var deviceJson = httpContext.Request.Query["Option"].ToString ();

            //
            // Retrieve Caller Info ...
            var callerConnectionId = Context.ConnectionId;
            var callerUserName = Context?.User?.Identity?.Name;
            var callerDevice = deviceJson.FromJSON<XDeviceDto> ();

            //
            // Retrieve Connection ...
            var calleeConnection = connectionStore
                .FindOne (c => c.User.ToNormalString () == calleeUser.ToNormalString ())
                .RunTask ();

            //
            var result = new XWebRTCConnectionDto {
                //
                Id = id,
                //
                Payload = null,
                Type = connectionType,
                //
                RequestTime = DateTime.UtcNow,
                //
                CallerUser = callerUserName,
                CallerDevice = callerDevice,
                CallerConnectionId = callerConnectionId,
                //
                Callees = new List<XWebRTCCalleeDto> {
                new XWebRTCCalleeDto {
                Device = calleeDevice,
                User = calleeConnection.User,
                ConnectionId = calleeConnection.Id,
                }
                }
            };

            //
            return Task.FromResult (result);
        }

        /// <summary>
        /// create first time WebRTC connection ...
        /// </summary>
        /// <param name="connectionType"></param>
        /// <param name="calleeConnectionId"></param>
        /// <param name="calleeDevice"></param>
        /// <returns></returns>
        protected Task<XWebRTCConnectionDto> GetWebRTCConnection (
            XCallType connectionType,
            string calleeConnectionId,
            XDeviceDto calleeDevice
        ) {
            //
            // Validate Args ...
            if (
                calleeDevice.IsNull () ||
                connectionType == XCallType.None ||
                calleeConnectionId.IsNullOrEmpty ()
            ) {
                throw XException.InvalidArgs.ToException ();
            }

            //
            var id = Guid.NewGuid ().ToString ();

            //
            var httpContext = Context.GetHttpContext ();
            var deviceJson = httpContext.Request.Query["Option"].ToString ();

            //
            // Retrieve Caller Info ...
            var callerConnectionId = Context.ConnectionId;
            var callerUserName = Context?.User?.Identity?.Name;
            var callerDevice = deviceJson.FromJSON<XDeviceDto> ();

            //
            // Retrieve Connection ...
            var calleeConnection = connectionStore
                .GetByConnectionId (calleeConnectionId)
                .RunTask ();

            //
            var result = new XWebRTCConnectionDto {
                //
                Id = id,
                //
                Payload = null,
                Type = connectionType,
                //
                RequestTime = DateTime.UtcNow,
                //
                CallerUser = callerUserName,
                CallerDevice = callerDevice,
                CallerConnectionId = callerConnectionId,
                //
                Callees = new List<XWebRTCCalleeDto> {
                new XWebRTCCalleeDto {
                Device = calleeDevice,
                User = calleeConnection.User,
                ConnectionId = calleeConnectionId,
                }
                }
            };

            //
            return Task.FromResult (result);
        }

        /// <summary>
        /// Check i am caller or not ...
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        protected bool AmICaller (XWebRTCConnectionDto request) {
            //
            // Validate Args ...
            if (!request.IsValid () ||
                !IsValidWebRTCConnection (request)
            ) {
                throw XException.InvalidArgs.ToException ();
            }

            //
            var result = request.IsCaller (GetConnectionId ());
            return result;
        }

        /// <summary>
        /// Check i am callee or not ...
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        protected bool AmICallee (XWebRTCConnectionDto request) {
            //
            // Validate Args ...
            if (!request.IsValid () ||
                !IsValidWebRTCConnection (request)) {
                throw XException.InvalidArgs.ToException ();
            }

            //
            var result = request.IsInCallees (GetConnectionId ());
            return result;
        }

        /// <summary>
        /// validate a web rtc connection ...
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        protected bool IsValidWebRTCConnection (XWebRTCConnectionDto request) {
            //
            // Validate Args ...
            if (
                request.IsNull () ||
                !request.IsValid () ||
                !request.Callees.HasChild () ||
                request.Type == XCallType.None ||
                request.CallerConnectionId.IsNullOrEmpty ()
            ) {
                return false;
            }

            //
            return true;
        }

        /// <summary>
        /// check bot Caller and Callee Connections Exists ...
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        protected Task<bool> IsWebRTCConnectionsExists (XWebRTCConnectionDto request) {
            //
            // Validate Args ...
            if (!IsValidWebRTCConnection (request)) {
                return Task.FromResult (false);
            }

            //
            var isCallerConnectionExists = connectionStore
                .IsExistsConnectionId (request.CallerConnectionId)
                .RunTask ();

            //
            var isCalleesConnectionExists = !request.Callees.HasChild () ? true :
                Task.WhenAll (request.Callees.Select (callee => connectionStore
                    .IsExistsConnectionId (callee.ConnectionId)))
                .ContinueWith (allTasks => {
                    //
                    var allResults = allTasks
                        .RunTask ();

                    //
                    return allResults.All (r => r == true);
                })
                .RunTask ();

            //
            if (!isCallerConnectionExists || !isCalleesConnectionExists) {
                return Task.FromResult (false);
            }

            //
            return Task.FromResult (true);
        }

        /// <summary>
        /// Add or Update a WebRTCConnection To/In Store ...
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        protected Task<bool> AddOrUpdateWebRTCConnection (XWebRTCConnectionDto request) {
            //
            if (!request.IsValid () ||
                request.Id.IsNullOrEmpty ()
            ) {
                return Task.FromResult (false);
            }

            //
            // Check Exists or not ...
            var isWebRTCConnectionExists = webRTCConnectionStore
                .IsExistsByKey (request.Id)
                .RunTask ();

            //
            // Act based on existance ...
            if (!isWebRTCConnectionExists) {
                return webRTCConnectionStore.Add (request);
            } else {
                //
                var updated = webRTCConnectionStore.Update (request)
                    .RunTask ();
                var isUpdate = !updated.IsNull ();

                //
                return Task.FromResult (isUpdate);
            }
        }
        #endregion
    }
}