/* 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 mozilla_dom_serviceworkerinfo_h
#define mozilla_dom_serviceworkerinfo_h

#include "MainThreadUtils.h"
#include "mozilla/OriginAttributes.h"
#include "mozilla/TimeStamp.h"
#include "mozilla/dom/ServiceWorkerBinding.h"  // For ServiceWorkerState
#include "mozilla/dom/ServiceWorkerDescriptor.h"
#include "mozilla/dom/ServiceWorkerLifetimeExtension.h"
#include "mozilla/dom/WorkerCommon.h"
#include "nsIServiceWorkerManager.h"

namespace mozilla::dom {

class ClientInfo;
class PostMessageSource;
class ServiceWorkerPrivate;

namespace ipc {
class StructuredCloneData;
}

/*
 * Wherever the spec treats a worker instance and a description of said worker
 * as the same thing; i.e. "Resolve foo with
 * _GetNewestWorker(serviceWorkerRegistration)", we represent the description
 * by this class and spawn a ServiceWorker in the right global when required.
 */
class ServiceWorkerInfo final : public nsIServiceWorkerInfo {
 private:
  nsCOMPtr<nsIPrincipal> mPrincipal;
  ServiceWorkerDescriptor mDescriptor;
  const nsString mCacheName;
  OriginAttributes mOriginAttributes;
  const nsString mWorkerPrivateId;

  // This LoadFlags is only applied to imported scripts, since the main script
  // has already been downloaded when performing the bytecheck. This LoadFlag is
  // composed of three parts:
  //   1. nsIChannel::LOAD_BYPASS_SERVICE_WORKER
  //   2. (Optional) nsIRequest::VALIDATE_ALWAYS
  //      depends on ServiceWorkerUpdateViaCache of its registration.
  //   3. (optional) nsIRequest::LOAD_BYPASS_CACHE
  //      depends on whether the update timer is expired.
  const nsLoadFlags mImportsLoadFlags;

  // Timestamp to track SW's state
  PRTime mCreationTime;
  TimeStamp mCreationTimeStamp;

  // The time of states are 0, if SW has not reached that state yet. Besides, we
  // update each of them after UpdateState() is called in SWRegistrationInfo.
  PRTime mInstalledTime;
  PRTime mActivatedTime;
  PRTime mRedundantTime;

  RefPtr<ServiceWorkerPrivate> mServiceWorkerPrivate;
  bool mSkipWaitingFlag;

  enum { Unknown, Enabled, Disabled } mHandlesFetch;

  uint32_t mNavigationFaultCount;

  // Testing helper to trigger fetch event cancellation when not NS_OK.
  // See `nsIServiceWorkerInfo::testingInjectCancellation`.
  nsresult mTestingInjectCancellation;

  ~ServiceWorkerInfo();

  // Generates a unique id for the service worker, with zero being treated as
  // invalid.
  uint64_t GetNextID() const;

 public:
  NS_DECL_ISUPPORTS
  NS_DECL_NSISERVICEWORKERINFO

  void PostMessage(ipc::StructuredCloneData* aData,
                   const PostMessageSource& aSource);

  class ServiceWorkerPrivate* WorkerPrivate() const {
    MOZ_ASSERT(mServiceWorkerPrivate);
    return mServiceWorkerPrivate;
  }

  nsIPrincipal* Principal() const { return mPrincipal; }

  const nsCString& ScriptSpec() const { return mDescriptor.ScriptURL(); }

  const nsCString& Scope() const { return mDescriptor.Scope(); }
  WorkerType Type() const { return mDescriptor.Type(); }
  Maybe<ClientInfo> GetClientInfo();

  // Pass-through of ServiceWorkerPrivate::GetLifetimeDeadline(); note that
  // we have an XPCOM variation that returns a double for testing purposes.
  TimeStamp LifetimeDeadline();

  bool SkipWaitingFlag() const {
    MOZ_ASSERT(NS_IsMainThread());
    return mSkipWaitingFlag;
  }

  void SetSkipWaitingFlag() {
    MOZ_ASSERT(NS_IsMainThread());
    mSkipWaitingFlag = true;
  }

  void ReportNavigationFault() {
    MOZ_ASSERT(NS_IsMainThread());
    mNavigationFaultCount++;
  }

  ServiceWorkerInfo(nsIPrincipal* aPrincipal, const nsACString& aScope,
                    const WorkerType& aType, uint64_t aRegistrationId,
                    uint64_t aRegistrationVersion,
                    const nsACString& aScriptSpec, const nsAString& aCacheName,
                    nsLoadFlags aImportsLoadFlags);

  ServiceWorkerState State() const { return mDescriptor.State(); }

  const OriginAttributes& GetOriginAttributes() const {
    return mOriginAttributes;
  }

  const nsString& CacheName() const { return mCacheName; }

  nsLoadFlags GetImportsLoadFlags() const { return mImportsLoadFlags; }

  uint64_t ID() const { return mDescriptor.Id(); }

  const ServiceWorkerDescriptor& Descriptor() const { return mDescriptor; }

  nsresult TestingInjectCancellation() { return mTestingInjectCancellation; }

  void UpdateState(ServiceWorkerState aState);

  // Only used to set initial state when loading from disk!
  void SetActivateStateUncheckedWithoutEvent(ServiceWorkerState aState) {
    MOZ_ASSERT(NS_IsMainThread());
    mDescriptor.SetState(aState);
  }

  void SetHandlesFetch(bool aHandlesFetch) {
    MOZ_ASSERT(NS_IsMainThread());
    MOZ_DIAGNOSTIC_ASSERT(mHandlesFetch == Unknown);
    mHandlesFetch = aHandlesFetch ? Enabled : Disabled;
    mDescriptor.SetHandlesFetch(aHandlesFetch);
  }

  void SetRegistrationVersion(uint64_t aVersion);

  bool HandlesFetch() const {
    MOZ_ASSERT(NS_IsMainThread());
    MOZ_DIAGNOSTIC_ASSERT(mHandlesFetch != Unknown);
    return mHandlesFetch != Disabled;
  }

  void UpdateInstalledTime();

  void UpdateActivatedTime();

  void UpdateRedundantTime();

  int64_t GetInstalledTime() const { return mInstalledTime; }

  void SetInstalledTime(const int64_t aTime) {
    if (aTime == 0) {
      return;
    }

    mInstalledTime = aTime;
  }

  int64_t GetActivatedTime() const { return mActivatedTime; }

  void SetActivatedTime(const int64_t aTime) {
    if (aTime == 0) {
      return;
    }

    mActivatedTime = aTime;
  }
};

}  // namespace mozilla::dom

#endif  // mozilla_dom_serviceworkerinfo_h