/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#ifndef peerconnectionctx_h_h_
#define peerconnectionctx_h_h_

#include <map>
#include <string>

#include "MediaTransportHandler.h"  // Mostly for IceLogPromise
#include "PeerConnectionImpl.h"
#include "api/field_trials_view.h"
#include "call/audio_state.h"
#include "mozIGeckoMediaPluginService.h"
#include "mozilla/StaticPrefs_media.h"
#include "mozilla/StaticPtr.h"
#include "nsIRunnable.h"

class WebrtcLogSinkHandle;

namespace webrtc {
class AudioDecoderFactory;

class MozTrialsConfig : public FieldTrialsView {
 public:
  MozTrialsConfig() = default;
  std::string Lookup(absl::string_view key) const override {
    // Upstream added a new default field trial string for
    // CongestionWindow, that we don't want.  In
    // third_party/libwebrtc/rtc_base/experiments/rate_control_settings.cc
    // they set kCongestionWindowDefaultFieldTrialString to
    // "QueueSize:350,MinBitrate:30000,DropFrame:true". With QueueSize
    // set, GoogCcNetworkController::UpdateCongestionWindowSize is
    // called.  Because negative values are calculated in
    // feedback_rtt, an assert fires when calculating data_window in
    // GoogCcNetworkController::UpdateCongestionWindowSize.  We probably
    // need to figure out why we're calculating negative feedback_rtt.
    // See Bug 1780620.
    if ("WebRTC-CongestionWindow" == key) {
      return std::string("MinBitrate:30000,DropFrame:true");
    }
    if ("WebRTC-VP9-SvcForSimulcast" == key) {
      return mozilla::StaticPrefs::media_webrtc_simulcast_vp9_enabled()
                 ? "Enabled"
                 : "Disabled";
    }
    return std::string();
  }
};
}  // namespace webrtc

namespace mozilla {
class PeerConnectionCtxObserver;

namespace dom {
class WebrtcGlobalInformation;
}

/**
 * Refcounted class containing state shared across all PeerConnections and all
 * Call instances. Managed by PeerConnectionCtx, and kept around while there are
 * registered peer connections.
 */
class SharedWebrtcState {
 public:
  NS_INLINE_DECL_THREADSAFE_REFCOUNTING(SharedWebrtcState)

  SharedWebrtcState(RefPtr<AbstractThread> aCallWorkerThread,
                    webrtc::AudioState::Config&& aAudioStateConfig,
                    RefPtr<webrtc::AudioDecoderFactory> aAudioDecoderFactory,
                    UniquePtr<webrtc::FieldTrialsView> aTrials);

  // A global Call worker thread shared between all Call instances. Implements
  // AbstractThread for running tasks that call into a Call instance through its
  // webrtc::TaskQueue member, and for using AbstractThread-specific higher
  // order constructs like StateMirroring.
  const RefPtr<AbstractThread> mCallWorkerThread;

  // AudioState config containing dummy implementations of the audio stack,
  // since we use our own audio stack instead. Shared across all Call instances.
  const webrtc::AudioState::Config mAudioStateConfig;

  // AudioDecoderFactory instance shared between calls, to limit the number of
  // instances in large calls.
  const RefPtr<webrtc::AudioDecoderFactory> mAudioDecoderFactory;

  // Trials instance shared between calls, to limit the number of instances in
  // large calls.
  const UniquePtr<webrtc::FieldTrialsView> mTrials;

 private:
  virtual ~SharedWebrtcState();
};

// A class to hold some of the singleton objects we need:
// * The global PeerConnectionImpl table and its associated lock.
// * Stats report objects for PCs that are gone
// * GMP related state
// * Upstream webrtc state shared across all Calls (processing thread)
class PeerConnectionCtx {
 public:
  // This is a singleton, so don't copy construct it, etc.
  PeerConnectionCtx(const PeerConnectionCtx& other) = delete;
  void operator=(const PeerConnectionCtx& other) = delete;

  static nsresult InitializeGlobal();
  static PeerConnectionCtx* GetInstance();
  static bool isActive();
  static void Destroy();

  bool isReady() {
    // If mGMPService is not set, we aren't using GMP.
    if (mGMPService) {
      return mGMPReady;
    }
    return true;
  }

  void queueJSEPOperation(nsIRunnable* aJSEPOperation);
  void onGMPReady();

  static void UpdateNetworkState(bool online);

  RefPtr<MediaTransportHandler> GetTransportHandler() const {
    return mTransportHandler;
  }

  SharedWebrtcState* GetSharedWebrtcState() const;

  void RemovePeerConnection(const std::string& aKey);
  void AddPeerConnection(const std::string& aKey,
                         PeerConnectionImpl* aPeerConnection);
  PeerConnectionImpl* GetPeerConnection(const std::string& aKey) const;
  template <typename Function>
  void ForEachPeerConnection(Function&& aFunction) const {
    MOZ_ASSERT(NS_IsMainThread());
    for (const auto& pair : mPeerConnections) {
      aFunction(pair.second);
    }
  }

  void ClearClosedStats();

 private:
  virtual ~PeerConnectionCtx() = default;
  std::map<const std::string, PeerConnectionImpl*> mPeerConnections;

  PeerConnectionCtx();

  nsresult Initialize();
  nsresult StartTelemetryTimer();
  void StopTelemetryTimer();
  nsresult Cleanup();

  void initGMP();

  static void EverySecondTelemetryCallback_m(nsITimer* timer, void*);

  nsCOMPtr<nsITimer> mTelemetryTimer;

 private:
  void DeliverStats(UniquePtr<dom::RTCStatsReportInternal>&& aReport);

  std::map<nsString, UniquePtr<dom::RTCStatsReportInternal>> mLastReports;
  // We cannot form offers/answers properly until the Gecko Media Plugin stuff
  // has been initted, which is a complicated mess of thread dispatches,
  // including sync dispatches to main. So, we need to be able to queue up
  // offer creation (or SetRemote, when we're the answerer) until all of this is
  // ready to go, since blocking on this init is just begging for deadlock.
  nsCOMPtr<mozIGeckoMediaPluginService> mGMPService;
  bool mGMPReady;
  nsTArray<nsCOMPtr<nsIRunnable>> mQueuedJSEPOperations;

  const RefPtr<WebrtcLogSinkHandle> mLogHandle;

  // Not initted, just for ICE logging stuff
  RefPtr<MediaTransportHandler> mTransportHandler;

  // State used by libwebrtc that needs to be shared across all PeerConnections
  // and all Call instances. Set while there is at least one peer connection
  // registered. CallWrappers can hold a ref to this object to be sure members
  // are alive long enough.
  RefPtr<SharedWebrtcState> mSharedWebrtcState;

  static PeerConnectionCtx* gInstance;

 public:
  static mozilla::StaticRefPtr<mozilla::PeerConnectionCtxObserver>
      gPeerConnectionCtxObserver;
};

}  // namespace mozilla

#endif