#include "mozilla/Logging.h"

#include "HandlerServiceParent.h"

#include "nsIHandlerService.h"

#include "nsIMIMEInfo.h"

#include "ContentHandlerService.h"

#include "nsStringEnumerator.h"

#ifdef MOZ_WIDGET_GTK

#include "unix/nsGNOMERegistry.h"

#endif

using mozilla::dom::HandlerInfo;

using mozilla::dom::HandlerApp;

using mozilla::dom::ContentHandlerService;

using mozilla::dom::RemoteHandlerApp;

namespace {

class ProxyHandlerInfo final : public nsIHandlerInfo {

public:

  explicit ProxyHandlerInfo(const HandlerInfo& aHandlerInfo);

  NS_DECL_ISUPPORTS;

  NS_DECL_NSIHANDLERINFO;

  nsTArray<nsCString>& Extensions() {

    return mHandlerInfo.extensions();

  }

protected:

  ~ProxyHandlerInfo() {}

  HandlerInfo mHandlerInfo;

  nsHandlerInfoAction mPrefAction;

  nsCOMPtr<nsIMutableArray> mPossibleApps;

};

NS_IMPL_ISUPPORTS(ProxyHandlerInfo, nsIHandlerInfo)

ProxyHandlerInfo::ProxyHandlerInfo(const HandlerInfo& aHandlerInfo)

  : mHandlerInfo(aHandlerInfo),

    mPrefAction(nsIHandlerInfo::alwaysAsk),

    mPossibleApps(do_CreateInstance(NS_ARRAY_CONTRACTID))

{

  for (auto& happ : aHandlerInfo.possibleApplicationHandlers()) {

    mPossibleApps->AppendElement(new RemoteHandlerApp(happ));

  }

}

/* readonly attribute ACString type; */

NS_IMETHODIMP ProxyHandlerInfo::GetType(nsACString & aType)

{

  aType.Assign(mHandlerInfo.type());

  return NS_OK;

}

/* attribute AString description; */

NS_IMETHODIMP ProxyHandlerInfo::GetDescription(nsAString & aDescription)

{

  return NS_ERROR_NOT_IMPLEMENTED;

}

NS_IMETHODIMP ProxyHandlerInfo::SetDescription(const nsAString & aDescription)

{

  return NS_ERROR_NOT_IMPLEMENTED;

}

/* attribute nsIHandlerApp preferredApplicationHandler; */

NS_IMETHODIMP ProxyHandlerInfo::GetPreferredApplicationHandler(nsIHandlerApp * *aPreferredApplicationHandler)

{

  *aPreferredApplicationHandler = new RemoteHandlerApp(mHandlerInfo.preferredApplicationHandler());

  NS_IF_ADDREF(*aPreferredApplicationHandler);

  return NS_OK;

}

NS_IMETHODIMP ProxyHandlerInfo::SetPreferredApplicationHandler(nsIHandlerApp *aApp)

{

  nsString name;

  nsString detailedDescription;

  if (aApp) {

    aApp->GetName(name);

    aApp->GetDetailedDescription(detailedDescription);

  }

  mHandlerInfo.preferredApplicationHandler() = HandlerApp(name, detailedDescription);

  return NS_OK;

}

/* readonly attribute nsIMutableArray possibleApplicationHandlers; */

NS_IMETHODIMP ProxyHandlerInfo::GetPossibleApplicationHandlers(nsIMutableArray * *aPossibleApplicationHandlers)

{

  *aPossibleApplicationHandlers = mPossibleApps;

  NS_IF_ADDREF(*aPossibleApplicationHandlers);

  return NS_OK;

}

/* readonly attribute boolean hasDefaultHandler; */

NS_IMETHODIMP ProxyHandlerInfo::GetHasDefaultHandler(bool *aHasDefaultHandler)

{

  return NS_ERROR_NOT_IMPLEMENTED;

}

/* readonly attribute AString defaultDescription; */

NS_IMETHODIMP ProxyHandlerInfo::GetDefaultDescription(nsAString & aDefaultDescription)

{

  return NS_ERROR_NOT_IMPLEMENTED;

}

/* void launchWithURI (in nsIURI aURI, [optional] in nsIInterfaceRequestor aWindowContext); */

NS_IMETHODIMP ProxyHandlerInfo::LaunchWithURI(nsIURI *aURI, nsIInterfaceRequestor *aWindowContext)

{

  return NS_ERROR_NOT_IMPLEMENTED;

}

/* attribute ProxyHandlerInfoAction preferredAction; */

NS_IMETHODIMP ProxyHandlerInfo::GetPreferredAction(nsHandlerInfoAction *aPreferredAction)

{

  *aPreferredAction = mPrefAction;

  return NS_OK;

}

NS_IMETHODIMP ProxyHandlerInfo::SetPreferredAction(nsHandlerInfoAction aPreferredAction)

{

  mHandlerInfo.preferredAction() = aPreferredAction;

  mPrefAction = aPreferredAction;

  return NS_OK;

}

/* attribute boolean alwaysAskBeforeHandling; */

NS_IMETHODIMP ProxyHandlerInfo::GetAlwaysAskBeforeHandling(bool *aAlwaysAskBeforeHandling)

{

  *aAlwaysAskBeforeHandling = mHandlerInfo.alwaysAskBeforeHandling();

  return NS_OK;

}

NS_IMETHODIMP ProxyHandlerInfo::SetAlwaysAskBeforeHandling(bool aAlwaysAskBeforeHandling)

{

  mHandlerInfo.alwaysAskBeforeHandling() = aAlwaysAskBeforeHandling;

  return NS_OK;

}

class ProxyMIMEInfo : public nsIMIMEInfo

{

public:

  NS_DECL_ISUPPORTS

  NS_DECL_NSIMIMEINFO

  NS_FORWARD_NSIHANDLERINFO(mProxyHandlerInfo->);

  explicit ProxyMIMEInfo(const HandlerInfo &aHandlerInfo)

    : mProxyHandlerInfo(new ProxyHandlerInfo(aHandlerInfo))

  {

  }

private:

  virtual ~ProxyMIMEInfo() {}

  RefPtr<ProxyHandlerInfo> mProxyHandlerInfo;

protected:

  /* additional members */

};

NS_IMPL_ISUPPORTS(ProxyMIMEInfo, nsIMIMEInfo, nsIHandlerInfo)

/* nsIUTF8StringEnumerator getFileExtensions (); */

NS_IMETHODIMP ProxyMIMEInfo::GetFileExtensions(nsIUTF8StringEnumerator * *_retval)

{

  return NS_NewUTF8StringEnumerator(_retval, &mProxyHandlerInfo->Extensions(), this);

}

/* void setFileExtensions (in AUTF8String aExtensions); */

NS_IMETHODIMP ProxyMIMEInfo::SetFileExtensions(const nsACString & aExtensions)

{

  return NS_ERROR_NOT_IMPLEMENTED;

}

/* boolean extensionExists (in AUTF8String aExtension); */

NS_IMETHODIMP ProxyMIMEInfo::ExtensionExists(const nsACString & aExtension, bool *_retval)

{

  *_retval = mProxyHandlerInfo->Extensions().Contains(aExtension);

  return NS_OK;

}

/* void appendExtension (in AUTF8String aExtension); */

NS_IMETHODIMP ProxyMIMEInfo::AppendExtension(const nsACString & aExtension)

{

  mProxyHandlerInfo->Extensions().AppendElement(aExtension);

  return NS_OK;

}

/* attribute AUTF8String primaryExtension; */

NS_IMETHODIMP ProxyMIMEInfo::GetPrimaryExtension(nsACString & aPrimaryExtension)

{

  const auto& extensions = mProxyHandlerInfo->Extensions();

  if (extensions.IsEmpty()) {

    return NS_ERROR_FAILURE;

  }

  aPrimaryExtension = extensions[0];

  return NS_OK;

}

NS_IMETHODIMP ProxyMIMEInfo::SetPrimaryExtension(const nsACString & aPrimaryExtension)

{

  return NS_ERROR_NOT_IMPLEMENTED;

}

/* readonly attribute ACString MIMEType; */

NS_IMETHODIMP ProxyMIMEInfo::GetMIMEType(nsACString & aMIMEType)

{

  return NS_ERROR_NOT_IMPLEMENTED;

}

/* boolean equals (in nsIMIMEInfo aMIMEInfo); */

NS_IMETHODIMP ProxyMIMEInfo::Equals(nsIMIMEInfo *aMIMEInfo, bool *_retval)

{

  return NS_ERROR_NOT_IMPLEMENTED;

}

/* readonly attribute nsIArray possibleLocalHandlers; */

NS_IMETHODIMP ProxyMIMEInfo::GetPossibleLocalHandlers(nsIArray * *aPossibleLocalHandlers)

{

  return NS_ERROR_NOT_IMPLEMENTED;

}

/* void launchWithFile (in nsIFile aFile); */

NS_IMETHODIMP ProxyMIMEInfo::LaunchWithFile(nsIFile *aFile)

{

  return NS_ERROR_NOT_IMPLEMENTED;

}

static already_AddRefed<nsIHandlerInfo> WrapHandlerInfo(const HandlerInfo& aHandlerInfo) {

  nsCOMPtr<nsIHandlerInfo> info;

  if (aHandlerInfo.isMIMEInfo()) {

    info = new ProxyMIMEInfo(aHandlerInfo);

  } else {

    info = new ProxyHandlerInfo(aHandlerInfo);

  }

  return info.forget();

}

} // anonymous namespace

HandlerServiceParent::HandlerServiceParent()

{

}

HandlerServiceParent::~HandlerServiceParent()

{

}

mozilla::ipc::IPCResult

HandlerServiceParent::RecvFillHandlerInfo(const HandlerInfo& aHandlerInfoData,

                                          const nsCString& aOverrideType,

                                          HandlerInfo* handlerInfoData)

{

  nsCOMPtr<nsIHandlerInfo> info(WrapHandlerInfo(aHandlerInfoData));

  nsCOMPtr<nsIHandlerService> handlerSvc = do_GetService(NS_HANDLERSERVICE_CONTRACTID);

  handlerSvc->FillHandlerInfo(info, aOverrideType);

  ContentHandlerService::nsIHandlerInfoToHandlerInfo(info, handlerInfoData);

  return IPC_OK();

}

mozilla::ipc::IPCResult

HandlerServiceParent::RecvExists(const HandlerInfo& aHandlerInfo,

                                 bool* exists)

{

  nsCOMPtr<nsIHandlerInfo> info(WrapHandlerInfo(aHandlerInfo));

  nsCOMPtr<nsIHandlerService> handlerSvc = do_GetService(NS_HANDLERSERVICE_CONTRACTID);

  handlerSvc->Exists(info, exists);

  return IPC_OK();

}

mozilla::ipc::IPCResult

HandlerServiceParent::RecvExistsForProtocol(const nsCString& aProtocolScheme,

                                            bool* aHandlerExists)

{

#ifdef MOZ_WIDGET_GTK

  // Check the GNOME registry for a protocol handler

  *aHandlerExists = nsGNOMERegistry::HandlerExists(aProtocolScheme.get());

#else

  *aHandlerExists = false;

#endif

  return IPC_OK();

}

mozilla::ipc::IPCResult

HandlerServiceParent::RecvGetTypeFromExtension(const nsCString& aFileExtension,

                                               nsCString* type)

{

  nsCOMPtr<nsIHandlerService> handlerSvc = do_GetService(NS_HANDLERSERVICE_CONTRACTID);

  handlerSvc->GetTypeFromExtension(aFileExtension, *type);

  return IPC_OK();

}

void HandlerServiceParent::ActorDestroy(ActorDestroyReason aWhy)

{

}