/*
 * Copyright (c) 2011-2013 The original author or authors
 *  ------------------------------------------------------
 *  All rights reserved. This program and the accompanying materials
 *  are made available under the terms of the Eclipse Public License v1.0
 *  and Apache License v2.0 which accompanies this distribution.
 *
 *      The Eclipse Public License is available at
 *      http://www.eclipse.org/legal/epl-v10.html
 *
 *      The Apache License v2.0 is available at
 *      http://www.opensource.org/licenses/apache2.0.php
 *
 *  You may elect to redistribute this code under either of these licenses.
 */

package io.vertx.test.fakemetrics;

import io.vertx.core.eventbus.EventBus;
import io.vertx.core.eventbus.ReplyFailure;
import io.vertx.core.spi.metrics.EventBusMetrics;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * @author <a href="mailto:julien@julienviet.com">Julien Viet</a>
 */
public class FakeEventBusMetrics extends FakeMetricsBase implements EventBusMetrics<HandlerMetric> {

  private final List<SentMessage> sentMessages = Collections.synchronizedList(new ArrayList<>());
  private final List<ReceivedMessage> receivedMessages = Collections.synchronizedList(new ArrayList<>());
  private final List<HandlerMetric> registrations = new ArrayList<>();
  private final Map<String, AtomicInteger> encoded = new ConcurrentHashMap<>();
  private final Map<String, AtomicInteger> decoded = new ConcurrentHashMap<>();
  private final List<String> replyFailureAddresses = Collections.synchronizedList(new ArrayList<>());
  private final List<ReplyFailure> replyFailures = Collections.synchronizedList(new ArrayList<>());

  public FakeEventBusMetrics(EventBus eventBus) {
    super(eventBus);
  }

  public Map<String, AtomicInteger> getEncoded() {
    return encoded;
  }

  public Map<String, AtomicInteger> getDecoded() {
    return decoded;
  }

  public List<SentMessage> getSentMessages() {
    return sentMessages;
  }

  public List<ReceivedMessage> getReceivedMessages() {
    return receivedMessages;
  }

  public List<HandlerMetric> getRegistrations() {
    return registrations;
  }

  public List<String> getReplyFailureAddresses() {
    return replyFailureAddresses;
  }

  public List<ReplyFailure> getReplyFailures() {
    return replyFailures;
  }

  public int getEncodedBytes(String address) {
    AtomicInteger value = encoded.get(address);
    return value != null ? value.get() : 0;
  }

  public int getDecodedBytes(String address) {
    AtomicInteger value = decoded.get(address);
    return value != null ? value.get() : 0;
  }

  @Override
  public HandlerMetric handlerRegistered(String address, String repliedAddress) {
    HandlerMetric registration = new HandlerMetric(address, repliedAddress);
    registrations.add(registration);
    return registration;
  }

  public void handlerUnregistered(HandlerMetric handler) {
    registrations.remove(handler);
  }

  @Override
  public void scheduleMessage(HandlerMetric handler, boolean local) {
    handler.scheduleCount.incrementAndGet();
    if (local) {
      handler.localScheduleCount.incrementAndGet();
    }
  }

  @Override
  public void beginHandleMessage(HandlerMetric handler, boolean local) {
    handler.beginCount.incrementAndGet();
    if (local) {
      handler.localBeginCount.incrementAndGet();
    }
  }

  public void endHandleMessage(HandlerMetric handler, Throwable failure) {
    handler.endCount.incrementAndGet();
    if (failure != null) {
      handler.failureCount.incrementAndGet();
    }
  }

  @Override
  public void messageSent(String address, boolean publish, boolean local, boolean remote) {
    sentMessages.add(new SentMessage(address, publish, local, remote));
  }

  @Override
  public void messageReceived(String address, boolean publish, boolean local, int handlers) {
    receivedMessages.add(new ReceivedMessage(address, publish, local, handlers));
  }

  @Override
  public void messageWritten(String address, int numberOfBytes) {
    AtomicInteger value = new AtomicInteger();
    AtomicInteger existing = encoded.putIfAbsent(address, value);
    if (existing != null) {
      value = existing;
    }
    value.addAndGet(numberOfBytes);
  }

  @Override
  public void messageRead(String address, int numberOfBytes) {
    AtomicInteger value = new AtomicInteger();
    AtomicInteger existing = decoded.putIfAbsent(address, value);
    if (existing != null) {
      value = existing;
    }
    value.addAndGet(numberOfBytes);
  }

  public void replyFailure(String address, ReplyFailure failure) {
    replyFailureAddresses.add(address);
    replyFailures.add(failure);
  }

  public boolean isEnabled() {
    return true;
  }

  public void close() {
  }
}
