// Copyright 2018 The Cobalt Authors. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#include "starboard/shared/starboard/player/job_thread.h"

#include "starboard/common/condition_variable.h"

namespace starboard {
namespace shared {
namespace starboard {
namespace player {

namespace {

struct ThreadParam {
  explicit ThreadParam(JobThread* job_thread)
      : condition_variable(mutex), job_thread(job_thread) {}
  Mutex mutex;
  ConditionVariable condition_variable;
  JobThread* job_thread;
};

}  // namespace

JobThread::JobThread(const char* thread_name,
                     int64_t stack_size,
                     SbThreadPriority priority) {
  ThreadParam thread_param(this);
  thread_ =
      SbThreadCreate(stack_size, priority, kSbThreadNoAffinity, true,
                     thread_name, &JobThread::ThreadEntryPoint, &thread_param);
  SB_DCHECK(SbThreadIsValid(thread_));
  ScopedLock scoped_lock(thread_param.mutex);
  while (!job_queue_) {
    thread_param.condition_variable.Wait();
  }
  SB_DCHECK(job_queue_);
}

JobThread::~JobThread() {
  // TODO: There is a potential race condition here since job_queue_ can get
  // reset if it's is stopped while this dtor is running. Thus, avoid stopping
  // job_queue_ before JobThread is destructed.
  if (job_queue_) {
    job_queue_->Schedule(std::bind(&JobQueue::StopSoon, job_queue_.get()));
  }
  SbThreadJoin(thread_, nullptr);
}

// static
void* JobThread::ThreadEntryPoint(void* context) {
  ThreadParam* param = static_cast<ThreadParam*>(context);
  SB_DCHECK(param != nullptr);
  JobThread* job_thread = param->job_thread;
  {
    ScopedLock scoped_lock(param->mutex);
    job_thread->job_queue_.reset(new JobQueue);
    param->condition_variable.Signal();
  }
  job_thread->RunLoop();
  return nullptr;
}

void JobThread::RunLoop() {
  SB_DCHECK(job_queue_->BelongsToCurrentThread());

  job_queue_->RunUntilStopped();
  // TODO: Investigate removing this line to avoid the race condition in the
  // dtor.
  job_queue_.reset();
}

}  // namespace player
}  // namespace starboard
}  // namespace shared
}  // namespace starboard