using System;
using AVFoundation;
using CoreGraphics;
using UIKit;
using OpenTok;

namespace Xamarin.Forms.Clinical6.iOS.Services
{
    /// <summary>
    /// Opentok streaming service.
    /// </summary>
    public class OpentokStreamingService
    {
        #region private state

        protected object _syncRoot = new object();
        protected string _apiKey;
        protected string _sessionId;
        protected string _userToken;
        protected bool _subscriberConnected;
        protected bool _sessionTerminationIsInProgress = false;

        #endregion

        public event Action OnSessionEnded = delegate { };
        public event Action OnPublishStarted = delegate { };

        #region singletone

        private static OpentokStreamingService _instance = new OpentokStreamingService();

        public static OpentokStreamingService Instance
        {
            get { return _instance; }
        }

        #endregion

        #region private state
        private OTSession _session;
        private OTPublisher _publisher;
        private OTSubscriber _subscriber;
        private UIView _myStreamContainer;
        private UIView _otherStreamContainer;
        private bool _lastKnownVideoPublishingState;

        #endregion

        /// <summary>
        /// Sets the config.
        /// </summary>
        /// <param name="apiKey">API key.</param>
        /// <param name="sessionId">Session identifier.</param>
        /// <param name="userToken">User token.</param>
        public void SetConfig(string apiKey, string sessionId, string userToken)
        {
            _apiKey = apiKey;
            _sessionId = sessionId;
            _userToken = userToken;
        }

        /// <summary>
        /// Inits the new session.
        /// </summary>
        public void InitNewSession()
        {
            InitNewSession(_apiKey, _sessionId, _userToken);
        }

        /// <summary>
        /// Inits the new session.
        /// </summary>
        /// <param name="apiKey">API key.</param>
        /// <param name="sessionId">Session identifier.</param>
        /// <param name="userToken">User token.</param>
        public void InitNewSession(string apiKey, string sessionId, string userToken)
        {
            if (_session != null)
            {
                //stop running session if any and dispose all the resources
                EndSession();
            }

            _apiKey = apiKey;
            _sessionId = sessionId;
            _userToken = userToken;
            IsVideoPublishingEnabled = true;
            IsAudioPublishingEnabled = true;
            IsVideoSubscriptionEnabled = true;
            IsAudioSubscriptionEnabled = true;
            IsSubscriberVideoEnabled = true;

            _session = new OTSession(_apiKey, _sessionId, null);
            SubscribeForSessionEvents(_session);
            _session.Init();

            OTError error;
            _session.ConnectWithToken(_userToken, out error);
        }

        /// <summary>
        /// Publish this instance.
        /// </summary>
        private void Publish()
        {
            lock (_syncRoot)
            {
                if (_publisher != null || _session == null)
                {
                    return;
                }
                    

                OTError error;
                _publisher = new OTPublisher(null, new OTPublisherSettings
                {
                    Name = "XamarinOpenTok",
                    CameraFrameRate = OTCameraCaptureFrameRate.OTCameraCaptureFrameRate15FPS,
                    CameraResolution = OTCameraCaptureResolution.High,
                });

                SubscribeForPublisherEvents(_publisher, true);
                _session.Publish(_publisher, out error);

                ActivateStreamContainer(_myStreamContainer, _publisher.View);

                OnPublishStarted();
            }
        }

        /// <summary>
        /// Subscribe the specified stream.
        /// </summary>
        /// <param name="stream">Stream.</param>
        private void Subscribe(OTStream stream)
        {
            lock (_syncRoot)
            {
                if (_subscriber != null || _session == null)
                    return;

                OTError error;
                _subscriber = new OTSubscriber(stream, null);
                SubscribeForSubscriberEvents(_subscriber);
                _session.Subscribe(_subscriber, out error);
            }
        }

        /// <summary>
        /// Ends the session.
        /// </summary>
        public void EndSession()
        {
            lock (_syncRoot)
            {
                try
                {
                    _sessionTerminationIsInProgress = true;
                    if (_subscriber != null)
                    {
                        if (_subscriber.SubscribeToAudio)
                            _subscriber.SubscribeToAudio = false;
                        if (_subscriber.SubscribeToVideo)
                            _subscriber.SubscribeToVideo = false;
                        SubscribeForSubscriberEvents(_subscriber, false);
                        _subscriber.Dispose();
                        _subscriber = null;
                    }
                    if (_publisher != null)
                    {
                        if (_publisher.PublishAudio)
                            _publisher.PublishAudio = false;
                        if (_publisher.PublishVideo)
                            _publisher.PublishVideo = false;
                        SubscribeForPublisherEvents(_publisher, false);
                        _publisher.Dispose();
                        _publisher = null;
                    }

                    if (_session != null)
                    {
                        SubscribeForSessionEvents(_session, false);
                        _session.Disconnect();
                        _session.Dispose();
                        _session = null;
                    }

                    _myStreamContainer.InvokeOnMainThread(() =>
                    {
                        DeactivateStreamContainer(_myStreamContainer);
                        _myStreamContainer = null;

                        DeactivateStreamContainer(_otherStreamContainer);
                        _otherStreamContainer = null;
                    });

                    _apiKey = null;
                    _sessionId = null;
                    _userToken = null;

                    IsVideoPublishingEnabled = false;
                    IsAudioPublishingEnabled = false;
                    IsVideoSubscriptionEnabled = false;
                    IsAudioSubscriptionEnabled = false;
                    IsSubscriberVideoEnabled = false;

                    _subscriberConnected = false;
                }
                catch (Exception ex)
                {
                    Console.WriteLine(ex.Message);
                }
                finally
                {
                    _sessionTerminationIsInProgress = false;
                    OnSessionEnded();
                }
            }
        }

        /// <summary>
        /// Releases all resource used by the
        /// <see cref="T:Xamarin.Forms.Clinical6.iOS.Services.OpentokStreamingService"/> object.
        /// </summary>
        /// <remarks>Call <see cref="Dispose"/> when you are finished using the
        /// <see cref="T:Xamarin.Forms.Clinical6.iOS.Services.OpentokStreamingService"/>. The <see cref="Dispose"/>
        /// method leaves the <see cref="T:Xamarin.Forms.Clinical6.iOS.Services.OpentokStreamingService"/> in an
        /// unusable state. After calling <see cref="Dispose"/>, you must release all references to the
        /// <see cref="T:Xamarin.Forms.Clinical6.iOS.Services.OpentokStreamingService"/> so the garbage collector can
        /// reclaim the memory that the <see cref="T:Xamarin.Forms.Clinical6.iOS.Services.OpentokStreamingService"/> was occupying.</remarks>
        public void Dispose()
        {
            EndSession();
        }

        private bool _isVideoPublishingEnabled;

        /// <summary>
        /// Gets or sets a value indicating whether this
        /// <see cref="T:Xamarin.Forms.Clinical6.iOS.Services.OpentokStreamingService"/> is video publishing enabled.
        /// </summary>
        /// <value><c>true</c> if is video publishing enabled; otherwise, <c>false</c>.</value>
        public bool IsVideoPublishingEnabled
        {
            get { return _isVideoPublishingEnabled; }
            set
            {
                if (_isVideoPublishingEnabled == value)
                    return;
                _isVideoPublishingEnabled = value;
                OnVideoPublishingChanged();
            }
        }

        private bool _isAudioPublishingEnabled;

        public bool IsAudioPublishingEnabled
        {
            get
            {
                return _isAudioPublishingEnabled;
            }
            set
            {
                if (_isAudioPublishingEnabled == value)
                    return;
                _isAudioPublishingEnabled = value;
                OnAudioPublishingChanged();
            }
        }

        private bool _isVideoSubscriptionEnabled;

        public bool IsVideoSubscriptionEnabled
        {
            get { return _isVideoSubscriptionEnabled; }
            set
            {
                if (_isVideoSubscriptionEnabled == value)
                    return;
                _isVideoSubscriptionEnabled = value;
                OnVideoSubscriptionChanged();
            }
        }

        private bool _isAudioSubscriptionEnabled;

        public bool IsAudioSubscriptionEnabled
        {
            get
            {
                return _isAudioSubscriptionEnabled;
            }
            set
            {
                if (_isAudioSubscriptionEnabled == value)
                    return;
                _isAudioSubscriptionEnabled = value;
                OnAudioSubscriptionChanged();
            }
        }

        private bool _isSubscriberVideoEnabled;

        public bool IsSubscriberVideoEnabled
        {
            get { return _isSubscriberVideoEnabled; }
            protected set
            {
                if (_isSubscriberVideoEnabled == value)
                    return;
                _isSubscriberVideoEnabled = value;
                OnSubscriberVideoChanged();
            }
        }

        /// <summary>
        /// Ons the subscriber video changed.
        /// </summary>
        protected virtual void OnSubscriberVideoChanged()
        {
            //we have to keep and raise the enabled/disabled flag because Stream.HasVideo property doesn't reflect the change at once
        }

        /// <summary>
        /// Swaps the camera.
        /// </summary>
        public void SwapCamera()
        {
            if (_publisher == null)
                return;

            if (_publisher.CameraPosition != AVCaptureDevicePosition.Front)
                _publisher.CameraPosition = AVCaptureDevicePosition.Front;
            else
                _publisher.CameraPosition = AVCaptureDevicePosition.Back;
        }

        /// <summary>
        /// Ons the video publishing changed.
        /// </summary>
        protected void OnVideoPublishingChanged()
        {
            if (_publisher == null)
                return;
            if (_publisher.PublishVideo != IsVideoPublishingEnabled)
                _publisher.PublishVideo = IsVideoPublishingEnabled;
        }

        /// <summary>
        /// Ons the audio publishing changed.
        /// </summary>
        protected void OnAudioPublishingChanged()
        {
            if (_publisher == null)
                return;
            if (_publisher.PublishAudio != IsAudioPublishingEnabled)
                _publisher.PublishAudio = IsAudioPublishingEnabled;
        }

        /// <summary>
        /// Ons the video subscription changed.
        /// </summary>
        protected void OnVideoSubscriptionChanged()
        {
            if (_subscriber == null)
                return;
            if (_subscriber.SubscribeToVideo != IsVideoSubscriptionEnabled)
                _subscriber.SubscribeToVideo = IsVideoSubscriptionEnabled;
        }

        /// <summary>
        /// Ons the audio subscription changed.
        /// </summary>
        protected void OnAudioSubscriptionChanged()
        {
            if (_subscriber == null)
                return;
            if (_subscriber.SubscribeToAudio != IsAudioSubscriptionEnabled)
                _subscriber.SubscribeToAudio = IsAudioSubscriptionEnabled;
        }

        /// <summary>
        /// Sets the stream container.
        /// </summary>
        /// <param name="container">Container.</param>
        /// <param name="myStream">If set to <c>true</c> my stream.</param>
        public void SetStreamContainer(object container, bool myStream)
        {
            var streamContainer = ((UIView)container);
            UIView streamView = null;

            if (myStream)
            {
                _myStreamContainer = streamContainer;
                if (_publisher != null)
                    streamView = _publisher.View;
            }
            else
            {
                _otherStreamContainer = streamContainer;
                if (_subscriber != null)
                    streamView = _subscriber.View;
            }

            ActivateStreamContainer(streamContainer, streamView);
        }

        #region private helpers
        /// <summary>
        /// Activates the stream container.
        /// </summary>
        /// <param name="streamContainer">Stream container.</param>
        /// <param name="streamView">Stream view.</param>
        private void ActivateStreamContainer(UIView streamContainer, UIView streamView)
        {
            DeactivateStreamContainer(streamContainer);
            if (streamContainer == null || streamView == null)
                return;

            if (streamView.Superview != null)
                streamView.RemoveFromSuperview();
            streamView.Frame = new CGRect(0, 0, streamContainer.Frame.Width, streamContainer.Frame.Height);
            streamContainer.Add(streamView);
        }

        /// <summary>
        /// Deactivates the stream container.
        /// </summary>
        /// <param name="streamContainer">Stream container.</param>
        private void DeactivateStreamContainer(UIView streamContainer)
        {
            if (streamContainer == null || streamContainer.Subviews == null)
                return;

            while (streamContainer.Subviews.Length > 0)
            {
                var view = streamContainer.Subviews[0];
                view.RemoveFromSuperview();
            }
        }

        #endregion

        #region events subscription
        /// <summary>
        /// Subscribes for session events.
        /// </summary>
        /// <param name="session">Session.</param>
        /// <param name="subscribe">If set to <c>true</c> subscribe.</param>
        private void SubscribeForSessionEvents(OTSession session, bool subscribe = true)
        {
            if (session == null)
                return;

            if (subscribe)
            {
                session.ConnectionDestroyed += OnConnectionDestroyed;
                session.DidConnect += OnDidConnect;
                session.StreamCreated += OnStreamCreated;
                session.StreamDestroyed += OnStreamDestroyed;
            }
            else
            {
                session.ConnectionDestroyed -= OnConnectionDestroyed;
                session.DidConnect -= OnDidConnect;
                session.StreamCreated -= OnStreamCreated;
                session.StreamDestroyed -= OnStreamDestroyed;
            }
        }

        /// <summary>
        /// Subscribes for subscriber events.
        /// </summary>
        /// <param name="subscriber">Subscriber.</param>
        /// <param name="subscribe">If set to <c>true</c> subscribe.</param>
        private void SubscribeForSubscriberEvents(OTSubscriber subscriber, bool subscribe = true)
        {
            if (subscriber == null)
                return;

            if (subscribe)
            {
                subscriber.DidConnectToStream += OnSubscriberDidConnectToStream;
                subscriber.VideoDataReceived += OnSubscriberVideoDataReceived;
                subscriber.VideoEnabled += OnSubscriberVideoEnabled;
            }
            else
            {
                subscriber.DidConnectToStream -= OnSubscriberDidConnectToStream;
                subscriber.VideoDataReceived -= OnSubscriberVideoDataReceived;
                subscriber.VideoEnabled -= OnSubscriberVideoEnabled;
            }
        }

        /// <summary>
        /// Subscribes for publisher events.
        /// </summary>
        /// <param name="publisher">Publisher.</param>
        /// <param name="subscribe">If set to <c>true</c> subscribe.</param>
        private void SubscribeForPublisherEvents(OTPublisher publisher, bool subscribe = true)
        {
            if (publisher == null)
                return;

            if (subscribe)
            {
                publisher.StreamCreated += OnPublisherStreamCreated;
            }
            else
            {
                publisher.StreamCreated += OnPublisherStreamCreated;
            }
        }

        #endregion

        #region session events
        /// <summary>
        /// Ons the connection destroyed.
        /// </summary>
        /// <param name="sender">Sender.</param>
        /// <param name="e">E.</param>
        private void OnConnectionDestroyed(object sender, OTSessionDelegateConnectionEventArgs e)
        {
            EndSession();
        }

        /// <summary>
        /// Ons the did connect.
        /// </summary>
        /// <param name="sender">Sender.</param>
        /// <param name="e">E.</param>
        private void OnDidConnect(object sender, EventArgs e)
        {
            Publish();
        }

        /// <summary>
        /// Ons the stream created.
        /// </summary>
        /// <param name="sender">Sender.</param>
        /// <param name="e">E.</param>
        private void OnStreamCreated(object sender, OTSessionDelegateStreamEventArgs e)
        {
            Subscribe(e.Stream);
        }

        /// <summary>
        /// Ons the stream destroyed.
        /// </summary>
        /// <param name="sender">Sender.</param>
        /// <param name="e">E.</param>
        private void OnStreamDestroyed(object sender, OTSessionDelegateStreamEventArgs e)
        {
            _myStreamContainer?.InvokeOnMainThread(() =>
            {
                DeactivateStreamContainer(_myStreamContainer);
                DeactivateStreamContainer(_otherStreamContainer);
            });
        }

        #endregion

        #region subscriber evenets
        /// <summary>
        /// Ons the subscriber video data received.
        /// </summary>
        /// <param name="sender">Sender.</param>
        /// <param name="e">E.</param>
        private void OnSubscriberVideoDataReceived(object sender, EventArgs e)
        {
            ActivateStreamContainer(_otherStreamContainer, _subscriber.View);
        }

        /// <summary>
        /// Ons the subscriber video enabled.
        /// </summary>
        /// <param name="sender">Sender.</param>
        /// <param name="e">E.</param>
        private void OnSubscriberVideoEnabled(object sender, OTSubscriberKitDelegateVideoEventReasonEventArgs e)
        {
            lock (_syncRoot)
            {
                if (_subscriber != null && _subscriber.Stream != null && _subscriber.Stream.HasVideo)
                    IsSubscriberVideoEnabled = true;
            }
        }

        /// <summary>
        /// Ons the subscriber did connect to stream.
        /// </summary>
        /// <param name="sender">Sender.</param>
        /// <param name="e">E.</param>
        private void OnSubscriberDidConnectToStream(object sender, EventArgs e)
        {
            lock (_syncRoot)
            {
                if (_subscriber != null)
                {
                    _subscriberConnected = true;
                    ActivateStreamContainer(_otherStreamContainer, _subscriber.View);
                    if (_subscriber.Stream != null && _subscriber.Stream.HasVideo)
                        IsSubscriberVideoEnabled = true;
                }
            }
        }

        #endregion

        #region subscriber evenets
        /// <summary>
        /// Ons the publisher stream created.
        /// </summary>
        /// <param name="sender">Sender.</param>
        /// <param name="e">E.</param>
        void OnPublisherStreamCreated(object sender, OTPublisherDelegateStreamEventArgs e)
        {
            OnPublishStarted();
        }

        #endregion
    }
}