/*
 * 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.
 */
package org.apache.sling.distribution.component.impl;


import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.apache.felix.scr.annotations.Activate;
import org.apache.felix.scr.annotations.Component;
import org.apache.felix.scr.annotations.Property;
import org.apache.felix.scr.annotations.PropertyUnbounded;
import org.apache.felix.scr.annotations.Service;
import org.apache.sling.distribution.agent.impl.ForwardDistributionAgentFactory;
import org.apache.sling.distribution.agent.impl.PrivilegeDistributionRequestAuthorizationStrategy;
import org.apache.sling.distribution.agent.impl.QueueDistributionAgentFactory;
import org.apache.sling.distribution.agent.impl.ReverseDistributionAgentFactory;
import org.apache.sling.distribution.agent.impl.SimpleDistributionAgentFactory;
import org.apache.sling.distribution.agent.impl.SyncDistributionAgentFactory;
import org.apache.sling.distribution.packaging.impl.exporter.AgentDistributionPackageExporterFactory;
import org.apache.sling.distribution.packaging.impl.exporter.LocalDistributionPackageExporterFactory;
import org.apache.sling.distribution.packaging.impl.exporter.RemoteDistributionPackageExporterFactory;
import org.apache.sling.distribution.packaging.impl.importer.LocalDistributionPackageImporterFactory;
import org.apache.sling.distribution.packaging.impl.importer.RemoteDistributionPackageImporterFactory;
import org.apache.sling.distribution.serialization.impl.vlt.VaultDistributionPackageBuilderFactory;
import org.apache.sling.distribution.transport.impl.UserCredentialsDistributionTransportSecretProvider;
import org.apache.sling.distribution.trigger.impl.DistributionEventDistributeDistributionTriggerFactory;
import org.apache.sling.distribution.trigger.impl.JcrEventDistributionTriggerFactory;
import org.apache.sling.distribution.trigger.impl.PersistedJcrEventDistributionTriggerFactory;
import org.apache.sling.distribution.trigger.impl.ResourceEventDistributionTriggerFactory;
import org.apache.sling.distribution.trigger.impl.ScheduledDistributionTriggerFactory;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import static java.lang.String.format;
import static org.apache.sling.commons.osgi.PropertiesUtil.*;
import static org.apache.sling.distribution.component.impl.DistributionComponentKind.*;

@Service(value = DistributionComponentFactoryMap.class)
@Component(metatype = false)
public class DistributionComponentFactoryMap {

    private final Logger log = LoggerFactory.getLogger(getClass());

    private static final String[] MAPPING_AGENT_DEFAULT = {
            format("simple:%s", SimpleDistributionAgentFactory.class.getName()),
            format("sync:%s", SyncDistributionAgentFactory.class.getName()),
            format("forward:%s", ForwardDistributionAgentFactory.class.getName()),
            format("reverse:%s", ReverseDistributionAgentFactory.class.getName()),
            format("queue:%s", QueueDistributionAgentFactory.class.getName()) };

    private static final String[] MAPPING_IMPORTER_DEFAULT = {
            format("local:%s", LocalDistributionPackageImporterFactory.class.getName()),
            format("remote:%s", RemoteDistributionPackageImporterFactory.class.getName()) };

    private static final String[] MAPPING_EXPORTER_DEFAULT = {
            format("local:%s", LocalDistributionPackageExporterFactory.class.getName()),
            format("remote:%s", RemoteDistributionPackageExporterFactory.class.getName()),
            format("agent:%s", AgentDistributionPackageExporterFactory.class.getName()) };

    private static final String[] MAPPING_QUEUE_PROVIDER_DEFAULT = {
            format("simple:%s", SimpleDistributionAgentFactory.class.getName()),
            format("sync:%s", SyncDistributionAgentFactory.class.getName()),
            format("forward:%s", ForwardDistributionAgentFactory.class.getName()),
            format("reverse:%s", ReverseDistributionAgentFactory.class.getName()),
            format("queue:%s", QueueDistributionAgentFactory.class.getName()) };

    private static final String[] MAPPING_QUEUE_STRATEGY_DEFAULT = {
            format("simple:%s", SimpleDistributionAgentFactory.class.getName()),
            format("sync:%s", SyncDistributionAgentFactory.class.getName()),
            format("forward:%s", ForwardDistributionAgentFactory.class.getName()),
            format("reverse:%s", ReverseDistributionAgentFactory.class.getName()),
            format("queue:%s", QueueDistributionAgentFactory.class.getName()) };

    private static final String[] MAPPING_TRANSPORT_SECRET_PROVIDER_DEFAULT = {
            format("user:%s", UserCredentialsDistributionTransportSecretProvider.class.getName()) };

    private static final String[] MAPPING_PACKAGE_BUILDER_DEFAULT = {
            format("filevlt:%s", VaultDistributionPackageBuilderFactory.class.getName()),
            format("jcrvlt:%s", VaultDistributionPackageBuilderFactory.class.getName()) };

    private static final String[] MAPPING_REQUEST_AUTHORIZATION_DEFAULT = {
            format("privilege:%s", PrivilegeDistributionRequestAuthorizationStrategy.class.getName()) };

    private static final String[] MAPPING_TRIGGER_DEFAULT = {
            format("resourceEvent:%s", ResourceEventDistributionTriggerFactory.class.getName()),
            format("scheduledEvent:%s", ScheduledDistributionTriggerFactory.class.getName()),
            format("distributionEvent:%s", DistributionEventDistributeDistributionTriggerFactory.class.getName()),
            format("persistedJcrEvent:%s", PersistedJcrEventDistributionTriggerFactory.class.getName()),
            format("jcrEvent:%s", JcrEventDistributionTriggerFactory.class.getName()) };


    @Property(unbounded = PropertyUnbounded.ARRAY)
    private static final String MAPPING_AGENT = "mapping.agent";

    @Property(unbounded = PropertyUnbounded.ARRAY)
    private static final String MAPPING_IMPORTER = "mapping.importer";

    @Property(unbounded = PropertyUnbounded.ARRAY)
    private static final String MAPPING_EXPORTER = "mapping.exporter";

    @Property(unbounded = PropertyUnbounded.ARRAY)
    private static final String MAPPING_QUEUE_PROVIDER = "mapping.queueProvider";

    @Property(unbounded = PropertyUnbounded.ARRAY)
    private static final String MAPPING_QUEUE_STRATEGY = "mapping.queueStrategy";

    @Property(unbounded = PropertyUnbounded.ARRAY)
    private static final String MAPPING_TRANSPORT_SECRET_PROVIDER = "mapping.transportSecretProvider";

    @Property(unbounded = PropertyUnbounded.ARRAY)
    private static final String MAPPING_PACKAGE_BUILDER = "mapping.packageBuilder";

    @Property(unbounded = PropertyUnbounded.ARRAY)
    private static final String MAPPING_REQUEST_AUTHORIZATION = "mapping.requestAuthorization";

    @Property(unbounded = PropertyUnbounded.ARRAY)
    private static final String MAPPING_TRIGGER = "mapping.trigger";

    private final Map<DistributionComponentKind, Map<String, String>> mapping =
            new HashMap<DistributionComponentKind, Map<String, String>>();

    @Activate
    protected void activate(Map<String, Object> config) {
        mapping.put(AGENT, parse(toStringArray(config.get(MAPPING_AGENT)), MAPPING_AGENT_DEFAULT));
        mapping.put(IMPORTER, parse(toStringArray(config.get(MAPPING_IMPORTER)), MAPPING_IMPORTER_DEFAULT));
        mapping.put(EXPORTER, parse(toStringArray(config.get(MAPPING_EXPORTER)), MAPPING_EXPORTER_DEFAULT));
        mapping.put(QUEUE_PROVIDER, parse(toStringArray(config.get(MAPPING_QUEUE_PROVIDER)), MAPPING_QUEUE_PROVIDER_DEFAULT));
        mapping.put(QUEUE_STRATEGY, parse(toStringArray(config.get(MAPPING_QUEUE_STRATEGY)), MAPPING_QUEUE_STRATEGY_DEFAULT));
        mapping.put(TRANSPORT_SECRET_PROVIDER, parse(toStringArray(config.get(MAPPING_TRANSPORT_SECRET_PROVIDER)), MAPPING_TRANSPORT_SECRET_PROVIDER_DEFAULT));
        mapping.put(PACKAGE_BUILDER, parse(toStringArray(config.get(MAPPING_PACKAGE_BUILDER)), MAPPING_PACKAGE_BUILDER_DEFAULT));
        mapping.put(REQUEST_AUTHORIZATION, parse(toStringArray(config.get(MAPPING_REQUEST_AUTHORIZATION)), MAPPING_REQUEST_AUTHORIZATION_DEFAULT));
        mapping.put(TRIGGER, parse(toStringArray(config.get(MAPPING_TRIGGER)), MAPPING_TRIGGER_DEFAULT));
    }

    String getType(DistributionComponentKind kind, @NotNull String factoryPid) {
        Map<String,String> entries = getEntries(kind);
        for (Map.Entry<String, String> entry : entries.entrySet()) {
            if (factoryPid.equals(entry.getValue())) {
                return entry.getKey();
            }
        }
        return null;
    }

    String getFactoryPid(DistributionComponentKind kind, String type) {
        return getEntries(kind).get(type);
    }

    List<String> getFactoryPids(DistributionComponentKind kind) {
        return new ArrayList<String>(getEntries(kind).values());
    }

    //

    private Map<String,String> parse(@Nullable String[] mappings, @NotNull String[] defaultMappings) {
        Map<String,String> parsed = new HashMap<String, String>();
        parsed.putAll(parse(defaultMappings));
        if (mappings != null) {
            parsed.putAll(parse(mappings));
        }
        return parsed;
    }

    private Map<String,String> parse(@NotNull String[] mappings) {
        Map<String, String> map = new HashMap<String, String>();
        for (String mapping : mappings) {
            String[] chunks = mapping.split(":");
            if (chunks.length != 2) {
                log.info(format("Skipping invalid mapping entry %s", mapping));
            } else {
                map.put(chunks[0], chunks[1]);
            }
        }
        return map;
    }

    private Map<String,String> getEntries(DistributionComponentKind kind) {
        Map<String,String> entries = mapping.get(kind);
        if (entries == null) {
            throw new IllegalArgumentException(format("No mapping for components kind %s", kind));
        }
        return entries;
    }
}