/* 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/. */

#include "TCPSocketChild.h"

#include <algorithm>

#include "TCPSocket.h"
#include "js/ArrayBuffer.h"  // JS::NewArrayBufferWithContents
#include "js/RootingAPI.h"   // JS::MutableHandle
#include "js/Utility.h"  // js::ArrayBufferContentsArena, JS::FreePolicy, js_pod_arena_malloc
#include "js/Value.h"  // JS::Value
#include "mozilla/HoldDropJSObjects.h"
#include "mozilla/UniquePtr.h"
#include "mozilla/dom/BrowserChild.h"
#include "mozilla/dom/PBrowserChild.h"
#include "mozilla/net/NeckoChild.h"
#include "nsContentUtils.h"
#include "nsITCPSocketCallback.h"

using mozilla::net::gNeckoChild;

namespace IPC {

bool DeserializeArrayBuffer(JSContext* cx, const nsTArray<uint8_t>& aBuffer,
                            JS::MutableHandle<JS::Value> aVal) {
  mozilla::UniquePtr<uint8_t[], JS::FreePolicy> data(
      js_pod_arena_malloc<uint8_t>(js::ArrayBufferContentsArena,
                                   aBuffer.Length()));
  if (!data) return false;
  memcpy(data.get(), aBuffer.Elements(), aBuffer.Length());

  JSObject* obj =
      JS::NewArrayBufferWithContents(cx, aBuffer.Length(), std::move(data));
  if (!obj) return false;

  aVal.setObject(*obj);
  return true;
}

}  // namespace IPC

namespace mozilla::dom {

NS_IMPL_CYCLE_COLLECTION_CLASS(TCPSocketChildBase)

NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(TCPSocketChildBase)
  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mSocket)
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END

NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(TCPSocketChildBase)
  NS_IMPL_CYCLE_COLLECTION_UNLINK(mSocket)
NS_IMPL_CYCLE_COLLECTION_UNLINK_END

NS_IMPL_CYCLE_COLLECTION_TRACE_BEGIN(TCPSocketChildBase)
NS_IMPL_CYCLE_COLLECTION_TRACE_END

NS_IMPL_CYCLE_COLLECTING_ADDREF(TCPSocketChildBase)
NS_IMPL_CYCLE_COLLECTING_RELEASE(TCPSocketChildBase)

NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(TCPSocketChildBase)
  NS_INTERFACE_MAP_ENTRY(nsISupports)
NS_INTERFACE_MAP_END

TCPSocketChildBase::TCPSocketChildBase() : mIPCOpen(false) {
  mozilla::HoldJSObjects(this);
}

TCPSocketChildBase::~TCPSocketChildBase() { mozilla::DropJSObjects(this); }

NS_IMETHODIMP_(MozExternalRefCountType) TCPSocketChild::Release(void) {
  nsrefcnt refcnt = TCPSocketChildBase::Release();
  if (refcnt == 1 && mIPCOpen) {
    PTCPSocketChild::SendRequestDelete();
    return 1;
  }
  return refcnt;
}

TCPSocketChild::TCPSocketChild(const nsAString& aHost, const uint16_t& aPort,
                               nsISerialEventTarget* aTarget)
    : mHost(aHost), mPort(aPort), mIPCEventTarget(aTarget) {}

void TCPSocketChild::SendOpen(nsITCPSocketCallback* aSocket, bool aUseSSL,
                              bool aUseArrayBuffers) {
  mSocket = aSocket;

  AddIPDLReference();
  gNeckoChild->SendPTCPSocketConstructor(this, mHost, mPort);
  PTCPSocketChild::SendOpen(mHost, mPort, aUseSSL, aUseArrayBuffers);
}

void TCPSocketChildBase::ReleaseIPDLReference() {
  MOZ_ASSERT(mIPCOpen);
  mIPCOpen = false;
  mSocket = nullptr;
  this->Release();
}

void TCPSocketChildBase::AddIPDLReference() {
  MOZ_ASSERT(!mIPCOpen);
  mIPCOpen = true;
  this->AddRef();
}

TCPSocketChild::~TCPSocketChild() = default;

mozilla::ipc::IPCResult TCPSocketChild::RecvUpdateBufferedAmount(
    const uint32_t& aBuffered, const uint32_t& aTrackingNumber) {
  mSocket->UpdateBufferedAmount(aBuffered, aTrackingNumber);
  return IPC_OK();
}

mozilla::ipc::IPCResult TCPSocketChild::RecvCallback(
    const nsString& aType, const CallbackData& aData,
    const uint32_t& aReadyState) {
  mSocket->UpdateReadyState(aReadyState);

  if (aData.type() == CallbackData::Tvoid_t) {
    mSocket->FireEvent(aType);

  } else if (aData.type() == CallbackData::TTCPError) {
    const TCPError& err(aData.get_TCPError());
    mSocket->FireErrorEvent(err.name(), err.message(), err.errorCode());

  } else if (aData.type() == CallbackData::TSendableData) {
    const SendableData& data = aData.get_SendableData();

    if (data.type() == SendableData::TArrayOfuint8_t) {
      mSocket->FireDataArrayEvent(aType, data.get_ArrayOfuint8_t());
    } else if (data.type() == SendableData::TnsCString) {
      mSocket->FireDataStringEvent(aType, data.get_nsCString());
    } else {
      MOZ_CRASH("Invalid callback data type!");
    }
  } else {
    MOZ_CRASH("Invalid callback type!");
  }
  return IPC_OK();
}

void TCPSocketChild::SendSend(const nsACString& aData) {
  SendData(nsCString(aData));
}

void TCPSocketChild::SendSend(nsTArray<uint8_t>&& aData) {
  SendData(SendableData{std::move(aData)});
}

void TCPSocketChild::SetSocket(TCPSocket* aSocket) { mSocket = aSocket; }

void TCPSocketChild::GetHost(nsAString& aHost) { aHost = mHost; }

void TCPSocketChild::GetPort(uint16_t* aPort) const { *aPort = mPort; }

mozilla::ipc::IPCResult TCPSocketChild::RecvRequestDelete() {
  (void)Send__delete__(this);
  return IPC_OK();
}

}  // namespace mozilla::dom