/* 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 "PSMRunnable.h"
#include "mozilla/Assertions.h"
#include "mozilla/DebugOnly.h"
#include "mozilla/RefPtr.h"
#include "nsCOMPtr.h"
#include "GeckoProfiler.h"
#include "nsPKCS11Slot.h"
#include "nsProtectedAuthThread.h"
#include "nsReadableUtils.h"
#include "nsString.h"
#include "nsThreadUtils.h"
#include "pk11func.h"

using namespace mozilla;
using namespace mozilla::psm;

NS_IMPL_ISUPPORTS(nsProtectedAuthThread, nsIProtectedAuthThread)

static void nsProtectedAuthThreadRunner(void *arg)
{
    AUTO_PROFILER_REGISTER_THREAD("Protected Auth");
    NS_SetCurrentThreadName("Protected Auth");

    nsProtectedAuthThread *self = static_cast<nsProtectedAuthThread *>(arg);
    self->Run();
}

nsProtectedAuthThread::nsProtectedAuthThread()
: mMutex("nsProtectedAuthThread.mMutex")
, mIAmRunning(false)
, mLoginReady(false)
, mThreadHandle(nullptr)
, mSlot(0)
, mLoginResult(SECFailure)
{
}

nsProtectedAuthThread::~nsProtectedAuthThread()
{
}

NS_IMETHODIMP nsProtectedAuthThread::Login(nsIObserver *aObserver)
{
    NS_ENSURE_ARG(aObserver);

    if (!mSlot)
        // We need pointer to the slot
        return NS_ERROR_FAILURE;

    MutexAutoLock lock(mMutex);

    if (mIAmRunning || mLoginReady) {
        return NS_OK;
    }

    if (aObserver) {
      // We must AddRef aObserver here on the main thread, because it probably
      // does not implement a thread-safe AddRef.
      mNotifyObserver = new NotifyObserverRunnable(aObserver,
                                                   "operation-completed");
    }

    mIAmRunning = true;

    mThreadHandle = PR_CreateThread(PR_USER_THREAD, nsProtectedAuthThreadRunner, static_cast<void*>(this),
        PR_PRIORITY_NORMAL, PR_GLOBAL_THREAD, PR_JOINABLE_THREAD, 0);

    // bool thread_started_ok = (threadHandle != nullptr);
    // we might want to return "thread started ok" to caller in the future
    MOZ_ASSERT(mThreadHandle,
               "Could not create nsProtectedAuthThreadRunner thread");
    return NS_OK;
}

NS_IMETHODIMP nsProtectedAuthThread::GetTokenName(nsAString &_retval)
{
    MutexAutoLock lock(mMutex);

    // Get token name
    CopyUTF8toUTF16(nsDependentCString(PK11_GetTokenName(mSlot)), _retval);

    return NS_OK;
}

NS_IMETHODIMP nsProtectedAuthThread::GetSlot(nsIPKCS11Slot **_retval)
{
    RefPtr<nsPKCS11Slot> slot;
    {
        MutexAutoLock lock(mMutex);
        slot = new nsPKCS11Slot(mSlot);
    }

    slot.forget(_retval);
    return NS_OK;
}

void nsProtectedAuthThread::SetParams(PK11SlotInfo* aSlot)
{
    MutexAutoLock lock(mMutex);

    mSlot = (aSlot) ? PK11_ReferenceSlot(aSlot) : 0;
}

SECStatus nsProtectedAuthThread::GetResult()
{
    return mLoginResult;
}

void nsProtectedAuthThread::Run(void)
{
    // Login with null password. This call will also do C_Logout() but
    // it is harmless here
    mLoginResult = PK11_CheckUserPassword(mSlot, 0);

    nsCOMPtr<nsIRunnable> notifyObserver;
    {
        MutexAutoLock lock(mMutex);

        mLoginReady = true;
        mIAmRunning = false;

        // Forget the slot
        if (mSlot)
        {
            PK11_FreeSlot(mSlot);
            mSlot = 0;
        }

        notifyObserver.swap(mNotifyObserver);
    }

    if (notifyObserver) {
        DebugOnly<nsresult> rv = NS_DispatchToMainThread(notifyObserver);
	MOZ_ASSERT(NS_SUCCEEDED(rv),
		   "Failed to dispatch protected auth observer to main thread");
    }
}

void nsProtectedAuthThread::Join()
{
    if (!mThreadHandle)
        return;

    PR_JoinThread(mThreadHandle);
    mThreadHandle = nullptr;
}