/**
 * Copyright © 2016-2018 The Thingsboard Authors
 *
 * 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.
 */
package org.thingsboard.server.actors.shared;

import akka.actor.ActorContext;
import akka.actor.ActorRef;
import akka.actor.Scheduler;
import akka.event.LoggingAdapter;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import lombok.AllArgsConstructor;
import lombok.Data;
import org.thingsboard.server.actors.ActorSystemContext;
import org.thingsboard.server.common.data.plugin.ComponentDescriptor;
import org.thingsboard.server.common.data.plugin.ComponentType;
import org.thingsboard.server.extensions.api.component.*;
import scala.concurrent.ExecutionContextExecutor;
import scala.concurrent.duration.Duration;

import java.io.IOException;
import java.util.concurrent.TimeUnit;

public abstract class AbstractContextAwareMsgProcessor {

    protected final ActorSystemContext systemContext;
    protected final LoggingAdapter logger;
    protected final ObjectMapper mapper = new ObjectMapper();

    protected AbstractContextAwareMsgProcessor(ActorSystemContext systemContext, LoggingAdapter logger) {
        super();
        this.systemContext = systemContext;
        this.logger = logger;
    }

    protected ActorRef getAppActor() {
        return systemContext.getAppActor();
    }

    protected Scheduler getScheduler() {
        return systemContext.getScheduler();
    }

    protected ExecutionContextExecutor getSystemDispatcher() {
        return systemContext.getActorSystem().dispatcher();
    }

    protected void schedulePeriodicMsgWithDelay(ActorContext ctx, Object msg, long delayInMs, long periodInMs) {
        schedulePeriodicMsgWithDelay(ctx, msg, delayInMs, periodInMs, ctx.self());
    }

    protected void schedulePeriodicMsgWithDelay(ActorContext ctx, Object msg, long delayInMs, long periodInMs, ActorRef target) {
        logger.debug("Scheduling periodic msg {} every {} ms with delay {} ms", msg, periodInMs, delayInMs);
        getScheduler().schedule(Duration.create(delayInMs, TimeUnit.MILLISECONDS), Duration.create(periodInMs, TimeUnit.MILLISECONDS), target, msg, getSystemDispatcher(), null);
    }


    protected void scheduleMsgWithDelay(ActorContext ctx, Object msg, long delayInMs) {
        scheduleMsgWithDelay(ctx, msg, delayInMs, ctx.self());
    }

    protected void scheduleMsgWithDelay(ActorContext ctx, Object msg, long delayInMs, ActorRef target) {
        logger.debug("Scheduling msg {} with delay {} ms", msg, delayInMs);
        getScheduler().scheduleOnce(Duration.create(delayInMs, TimeUnit.MILLISECONDS), target, msg, getSystemDispatcher(), null);
    }

    protected <T extends ConfigurableComponent> T initComponent(JsonNode componentNode) throws Exception {
        ComponentConfiguration configuration = new ComponentConfiguration(
                componentNode.get("clazz").asText(),
                componentNode.get("name").asText(),
                mapper.writeValueAsString(componentNode.get("configuration"))
        );
        logger.info("Initializing [{}][{}] component", configuration.getName(), configuration.getClazz());
        ComponentDescriptor componentDescriptor = systemContext.getComponentService().getComponent(configuration.getClazz())
                .orElseThrow(() -> new InstantiationException("Component Not found!"));
        return initComponent(componentDescriptor, configuration);
    }

    protected <T extends ConfigurableComponent> T initComponent(ComponentDescriptor componentDefinition, ComponentConfiguration configuration)
            throws Exception {
        return initComponent(componentDefinition.getClazz(), componentDefinition.getType(), configuration.getConfiguration());
    }

    protected <T extends ConfigurableComponent> T initComponent(String clazz, ComponentType type, String configuration)
            throws Exception {
        Class<?> componentClazz = Class.forName(clazz);
        T component = (T) (componentClazz.newInstance());
        Class<?> configurationClazz;
        switch (type) {
            case FILTER:
                configurationClazz = ((Filter) componentClazz.getAnnotation(Filter.class)).configuration();
                break;
            case ACTION:
                configurationClazz = ((Action) componentClazz.getAnnotation(Action.class)).configuration();
                break;
            case PLUGIN:
                configurationClazz = ((Plugin) componentClazz.getAnnotation(Plugin.class)).configuration();
                break;
            default:
                throw new IllegalStateException("Component with type: " + type + " is not supported!");
        }
        component.init(decode(configuration, configurationClazz));
        return component;
    }

    public <C> C decode(String configuration, Class<C> configurationClazz) throws IOException, RuntimeException {
        logger.info("Initializing using configuration: {}", configuration);
        return mapper.readValue(configuration, configurationClazz);
    }

    @Data
    @AllArgsConstructor
    private static class ComponentConfiguration {
        private final String clazz;
        private final String name;
        private final String configuration;
    }

}
