/* $Id$
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements. See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to you 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 "common/EtchError.h"
#include "common/EtchRuntimeException.h"
#include "support/EtchRuntime.h"
#include "support/EtchTransportHelper.h"
#include "util/EtchLogger.h"

//TODO remove this after refactoring
EtchRuntime* EtchRuntime::sRuntime = NULL;

EtchRuntime::EtchRuntime()
  : mIsClosed(false)
  , mLogger(NULL) {
  mMutex.lock();
  mId = getNextId();
  mMutex.unlock();

  //TODO remove this after refactoring
  sRuntime = this;
}

EtchRuntime::~EtchRuntime() {
}

capu::uint64_t EtchRuntime::getId() {
  return mId;
}

capu::bool_t EtchRuntime::isClosed() {
  return mIsClosed;
}

status_t EtchRuntime::registerListener(EtchRuntimeListener* listener) {
  if(listener == NULL) {
    return ETCH_EINVAL;
  }

  mMutex.lock();
  mListeners.add(listener);
  mMutex.unlock();
  return ETCH_OK;
}

status_t EtchRuntime::unregisterListener(EtchRuntimeListener* listener) {
  status_t status;
  mMutex.lock();
  capu::int_t index = mListeners.find(listener);
  if(index != -1) {
    mListeners.removeAt(index);
    status = ETCH_OK;
  } else {
    status = ETCH_ERROR;
  }
  mMutex.unlock();
  return status;
}

status_t EtchRuntime::start() {
  return ETCH_OK;
}

status_t EtchRuntime::shutdown() {
  if(!mIsClosed) {
    mIsClosed = true;
    fireOnRuntimeChanged();
  }
  return ETCH_OK;
}

status_t EtchRuntime::fireOnRuntimeChanged() {
  mMutex.lock();

  capu::List<EtchRuntimeListener*>::Iterator iter = mListeners.begin();
  while(iter.hasNext()) {
    EtchRuntimeListener* listener = NULL;
    iter.next(&listener);
    listener->onRuntimeChanged(this);
  }
  mMutex.unlock();
  return ETCH_OK;
}

capu::uint64_t EtchRuntime::getNextId() {
  static capu::uint64_t sId = 0;
  return sId++;
}

status_t EtchRuntime::setLogger(EtchLogger* logger) {
  if(logger == NULL) {
    return ETCH_EINVAL;
  }
  mLogger = logger;
  return ETCH_OK;
}

EtchLogger* EtchRuntime::getLogger() {
  return mLogger;
}

EtchRuntime* EtchRuntime::getRuntime() {
  return sRuntime;
}