/*
* Copyright 2014 Red Hat, Inc.
*
* Red Hat 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.
*/

package io.vertx.blueprint.kue.service;

import io.vertx.blueprint.kue.service.JobService;
import io.vertx.core.Vertx;
import io.vertx.core.Handler;
import io.vertx.core.AsyncResult;
import io.vertx.core.eventbus.EventBus;
import io.vertx.core.eventbus.Message;
import io.vertx.core.eventbus.MessageConsumer;
import io.vertx.core.eventbus.DeliveryOptions;
import io.vertx.core.eventbus.ReplyException;
import io.vertx.core.json.JsonObject;
import io.vertx.core.json.JsonArray;
import java.util.Collection;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.UUID;
import java.util.stream.Collectors;
import io.vertx.serviceproxy.ProxyHelper;
import io.vertx.serviceproxy.ProxyHandler;
import io.vertx.serviceproxy.ServiceException;
import io.vertx.serviceproxy.ServiceExceptionMessageCodec;
import io.vertx.blueprint.kue.service.JobService;
import io.vertx.core.Vertx;
import io.vertx.blueprint.kue.queue.JobState;
import io.vertx.core.json.JsonArray;
import java.util.List;
import io.vertx.blueprint.kue.queue.Job;
import io.vertx.core.json.JsonObject;
import io.vertx.core.AsyncResult;
import io.vertx.core.Handler;

/*
  Generated Proxy code - DO NOT EDIT
  @author Roger the Robot
*/
@SuppressWarnings({"unchecked", "rawtypes"})
public class JobServiceVertxProxyHandler extends ProxyHandler {

  public static final long DEFAULT_CONNECTION_TIMEOUT = 5 * 60; // 5 minutes 

  private final Vertx vertx;
  private final JobService service;
  private final long timerID;
  private long lastAccessed;
  private final long timeoutSeconds;

  public JobServiceVertxProxyHandler(Vertx vertx, JobService service) {
    this(vertx, service, DEFAULT_CONNECTION_TIMEOUT);
  }

  public JobServiceVertxProxyHandler(Vertx vertx, JobService service, long timeoutInSecond) {
    this(vertx, service, true, timeoutInSecond);
  }

  public JobServiceVertxProxyHandler(Vertx vertx, JobService service, boolean topLevel, long timeoutSeconds) {
    this.vertx = vertx;
    this.service = service;
    this.timeoutSeconds = timeoutSeconds;
    try {
      this.vertx.eventBus().registerDefaultCodec(ServiceException.class,
        new ServiceExceptionMessageCodec());
    } catch (IllegalStateException ex) {
    }
    if (timeoutSeconds != -1 && !topLevel) {
      long period = timeoutSeconds * 1000 / 2;
      if (period > 10000) {
        period = 10000;
      }
      this.timerID = vertx.setPeriodic(period, this::checkTimedOut);
    } else {
      this.timerID = -1;
    }
    accessed();
  }

  public MessageConsumer<JsonObject> registerHandler(String address) {
    MessageConsumer<JsonObject> consumer = vertx.eventBus().<JsonObject>consumer(address).handler(this);
    this.setConsumer(consumer);
    return consumer;
  }

  private void checkTimedOut(long id) {
    long now = System.nanoTime();
    if (now - lastAccessed > timeoutSeconds * 1000000000) {
      close();
    }
  }

  @Override
  public void close() {
    if (timerID != -1) {
      vertx.cancelTimer(timerID);
    }
    super.close();
  }

  private void accessed() {
    this.lastAccessed = System.nanoTime();
  }

  public void handle(Message<JsonObject> msg) {
    try {
      JsonObject json = msg.body();
      String action = msg.headers().get("action");
      if (action == null) {
        throw new IllegalStateException("action not specified");
      }
      accessed();
      switch (action) {


        case "getJob": {
          service.getJob(json.getValue("id") == null ? null : (json.getLong("id").longValue()), res -> {
            if (res.failed()) {
              if (res.cause() instanceof ServiceException) {
                msg.reply(res.cause());
              } else {
                msg.reply(new ServiceException(-1, res.cause().getMessage()));
              }
            } else {
              msg.reply(res.result() == null ? null : res.result().toJson());
            }
          });
          break;
        }
        case "removeJob": {
          service.removeJob(json.getValue("id") == null ? null : (json.getLong("id").longValue()), createHandler(msg));
          break;
        }
        case "existsJob": {
          service.existsJob(json.getValue("id") == null ? null : (json.getLong("id").longValue()), createHandler(msg));
          break;
        }
        case "getJobLog": {
          service.getJobLog(json.getValue("id") == null ? null : (json.getLong("id").longValue()), createHandler(msg));
          break;
        }
        case "jobRangeByState": {
          service.jobRangeByState((java.lang.String) json.getValue("state"), json.getValue("from") == null ? null : (json.getLong("from").longValue()), json.getValue("to") == null ? null : (json.getLong("to").longValue()), (java.lang.String) json.getValue("order"), res -> {
            if (res.failed()) {
              if (res.cause() instanceof ServiceException) {
                msg.reply(res.cause());
              } else {
                msg.reply(new ServiceException(-1, res.cause().getMessage()));
              }
            } else {
              msg.reply(new JsonArray(res.result().stream().map(Job::toJson).collect(Collectors.toList())));
            }
          });
          break;
        }
        case "jobRangeByType": {
          service.jobRangeByType((java.lang.String) json.getValue("type"), (java.lang.String) json.getValue("state"), json.getValue("from") == null ? null : (json.getLong("from").longValue()), json.getValue("to") == null ? null : (json.getLong("to").longValue()), (java.lang.String) json.getValue("order"), res -> {
            if (res.failed()) {
              if (res.cause() instanceof ServiceException) {
                msg.reply(res.cause());
              } else {
                msg.reply(new ServiceException(-1, res.cause().getMessage()));
              }
            } else {
              msg.reply(new JsonArray(res.result().stream().map(Job::toJson).collect(Collectors.toList())));
            }
          });
          break;
        }
        case "jobRange": {
          service.jobRange(json.getValue("from") == null ? null : (json.getLong("from").longValue()), json.getValue("to") == null ? null : (json.getLong("to").longValue()), (java.lang.String) json.getValue("order"), res -> {
            if (res.failed()) {
              if (res.cause() instanceof ServiceException) {
                msg.reply(res.cause());
              } else {
                msg.reply(new ServiceException(-1, res.cause().getMessage()));
              }
            } else {
              msg.reply(new JsonArray(res.result().stream().map(Job::toJson).collect(Collectors.toList())));
            }
          });
          break;
        }
        case "cardByType": {
          service.cardByType((java.lang.String) json.getValue("type"), json.getString("state") == null ? null : io.vertx.blueprint.kue.queue.JobState.valueOf(json.getString("state")), createHandler(msg));
          break;
        }
        case "card": {
          service.card(json.getString("state") == null ? null : io.vertx.blueprint.kue.queue.JobState.valueOf(json.getString("state")), createHandler(msg));
          break;
        }
        case "completeCount": {
          service.completeCount((java.lang.String) json.getValue("type"), createHandler(msg));
          break;
        }
        case "failedCount": {
          service.failedCount((java.lang.String) json.getValue("type"), createHandler(msg));
          break;
        }
        case "inactiveCount": {
          service.inactiveCount((java.lang.String) json.getValue("type"), createHandler(msg));
          break;
        }
        case "activeCount": {
          service.activeCount((java.lang.String) json.getValue("type"), createHandler(msg));
          break;
        }
        case "delayedCount": {
          service.delayedCount((java.lang.String) json.getValue("type"), createHandler(msg));
          break;
        }
        case "getAllTypes": {
          service.getAllTypes(createListHandler(msg));
          break;
        }
        case "getIdsByState": {
          service.getIdsByState(json.getString("state") == null ? null : io.vertx.blueprint.kue.queue.JobState.valueOf(json.getString("state")), createListHandler(msg));
          break;
        }
        case "getWorkTime": {
          service.getWorkTime(createHandler(msg));
          break;
        }
        default: {
          throw new IllegalStateException("Invalid action: " + action);
        }
      }
    } catch (Throwable t) {
      msg.reply(new ServiceException(500, t.getMessage()));
      throw t;
    }
  }

  private <T> Handler<AsyncResult<T>> createHandler(Message msg) {
    return res -> {
      if (res.failed()) {
        if (res.cause() instanceof ServiceException) {
          msg.reply(res.cause());
        } else {
          msg.reply(new ServiceException(-1, res.cause().getMessage()));
        }
      } else {
        if (res.result() != null && res.result().getClass().isEnum()) {
          msg.reply(((Enum) res.result()).name());
        } else {
          msg.reply(res.result());
        }
      }
    };
  }

  private <T> Handler<AsyncResult<List<T>>> createListHandler(Message msg) {
    return res -> {
      if (res.failed()) {
        if (res.cause() instanceof ServiceException) {
          msg.reply(res.cause());
        } else {
          msg.reply(new ServiceException(-1, res.cause().getMessage()));
        }
      } else {
        msg.reply(new JsonArray(res.result()));
      }
    };
  }

  private <T> Handler<AsyncResult<Set<T>>> createSetHandler(Message msg) {
    return res -> {
      if (res.failed()) {
        if (res.cause() instanceof ServiceException) {
          msg.reply(res.cause());
        } else {
          msg.reply(new ServiceException(-1, res.cause().getMessage()));
        }
      } else {
        msg.reply(new JsonArray(new ArrayList<>(res.result())));
      }
    };
  }

  private Handler<AsyncResult<List<Character>>> createListCharHandler(Message msg) {
    return res -> {
      if (res.failed()) {
        if (res.cause() instanceof ServiceException) {
          msg.reply(res.cause());
        } else {
          msg.reply(new ServiceException(-1, res.cause().getMessage()));
        }
      } else {
        JsonArray arr = new JsonArray();
        for (Character chr : res.result()) {
          arr.add((int) chr);
        }
        msg.reply(arr);
      }
    };
  }

  private Handler<AsyncResult<Set<Character>>> createSetCharHandler(Message msg) {
    return res -> {
      if (res.failed()) {
        if (res.cause() instanceof ServiceException) {
          msg.reply(res.cause());
        } else {
          msg.reply(new ServiceException(-1, res.cause().getMessage()));
        }
      } else {
        JsonArray arr = new JsonArray();
        for (Character chr : res.result()) {
          arr.add((int) chr);
        }
        msg.reply(arr);
      }
    };
  }

  private <T> Map<String, T> convertMap(Map map) {
    return (Map<String, T>) map;
  }

  private <T> List<T> convertList(List list) {
    return (List<T>) list;
  }

  private <T> Set<T> convertSet(List list) {
    return new HashSet<T>((List<T>) list);
  }
}