/**
 * 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.apache.aries.cdi.container.internal.util;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.stream.Collectors;

import org.osgi.service.cdi.runtime.dto.ActivationDTO;
import org.osgi.service.cdi.runtime.dto.ComponentDTO;
import org.osgi.service.cdi.runtime.dto.ComponentInstanceDTO;
import org.osgi.service.cdi.runtime.dto.ConfigurationDTO;
import org.osgi.service.cdi.runtime.dto.ContainerDTO;
import org.osgi.service.cdi.runtime.dto.ExtensionDTO;
import org.osgi.service.cdi.runtime.dto.ReferenceDTO;
import org.osgi.service.cdi.runtime.dto.template.ActivationTemplateDTO;
import org.osgi.service.cdi.runtime.dto.template.ComponentTemplateDTO;
import org.osgi.service.cdi.runtime.dto.template.ConfigurationTemplateDTO;
import org.osgi.service.cdi.runtime.dto.template.ContainerTemplateDTO;
import org.osgi.service.cdi.runtime.dto.template.ExtensionTemplateDTO;
import org.osgi.service.cdi.runtime.dto.template.ReferenceTemplateDTO;

public class DTOs {

	private DTOs() {
		// no instances
	}

	public static ContainerDTO copy(ContainerDTO original, boolean clear) {
		try {
			if (cache.get().containsKey(original)) {
				return (ContainerDTO)cache.get().get(original);
			}
			ContainerDTO copy = copy0(original);
			return (ContainerDTO)cache.get().computeIfAbsent(original, p -> copy);
		}
		finally {
			if (clear)
				cache.remove();
		}
	}

	static ContainerDTO copy0(ContainerDTO original) {
		ContainerDTO copy = new ContainerDTO();
		copy.bundle = original.bundle;
		copy.changeCount = original.changeCount;
		copy.errors = new ArrayList<>(original.errors);
		copy.template = copy(original.template, false);
		copy.extensions = copy(original.extensions);
		copy.components = copy(original.components);
		return copy;
	}

	static ExtensionDTO copy(ExtensionDTO original) {
		if (cache.get().containsKey(original)) {
			return (ExtensionDTO)cache.get().get(original);
		}
		ExtensionDTO copy = copy0(original);
		return (ExtensionDTO)cache.get().computeIfAbsent(original, p -> copy);
	}

	static ExtensionDTO copy0(ExtensionDTO original) {
		ExtensionDTO copy = new ExtensionDTO();
		copy.service = original.service;
		copy.template = copy(original.template);
		return copy;
	}

	static ComponentDTO copy(ComponentDTO original) {
		if (cache.get().containsKey(original)) {
			return (ComponentDTO)cache.get().get(original);
		}
		ComponentDTO copy = copy0(original);
		return (ComponentDTO)cache.get().computeIfAbsent(original, p -> copy);
	}

	static ComponentDTO copy0(ComponentDTO original) {
		ComponentDTO copy = new ComponentDTO();
		copy.enabled = original.enabled;
		copy.instances = copy(original.instances);
		copy.template = copy(original.template);
		return copy;
	}

	static ComponentInstanceDTO copy(ComponentInstanceDTO original) {
		if (cache.get().containsKey(original)) {
			return (ComponentInstanceDTO)cache.get().get(original);
		}
		ComponentInstanceDTO copy = copy0(original);
		return (ComponentInstanceDTO)cache.get().computeIfAbsent(original, p -> copy);
	}

	static ComponentInstanceDTO copy0(ComponentInstanceDTO original) {
		ComponentInstanceDTO copy = new ComponentInstanceDTO();
		copy.activations = copy(original.activations);
		copy.configurations = copy(original.configurations);
		copy.properties = original.properties == null ? null : new HashMap<>(original.properties);
		copy.references = copy(original.references);
		return copy;
	}

	static ActivationDTO copy(ActivationDTO original) {
		if (cache.get().containsKey(original)) {
			return (ActivationDTO)cache.get().get(original);
		}
		ActivationDTO copy = copy0(original);
		return (ActivationDTO)cache.get().computeIfAbsent(original, p -> copy);
	}

	static ActivationDTO copy0(ActivationDTO original) {
		ActivationDTO copy = new ActivationDTO();
		copy.errors = new ArrayList<>(original.errors);
		copy.service = original.service;
		copy.template = copy(original.template);
		return copy;
	}

	static ConfigurationDTO copy(ConfigurationDTO original) {
		if (cache.get().containsKey(original)) {
			return (ConfigurationDTO)cache.get().get(original);
		}
		ConfigurationDTO copy = copy0(original);
		return (ConfigurationDTO)cache.get().computeIfAbsent(original, p -> copy);
	}

	static ConfigurationDTO copy0(ConfigurationDTO original) {
		ConfigurationDTO copy = new ConfigurationDTO();
		copy.properties = original.properties == null ? null : new HashMap<>(original.properties);
		copy.template = copy(original.template);
		return copy;
	}

	static ReferenceDTO copy(ReferenceDTO original) {
		if (cache.get().containsKey(original)) {
			return (ReferenceDTO)cache.get().get(original);
		}
		ReferenceDTO copy = copy0(original);
		return (ReferenceDTO)cache.get().computeIfAbsent(original, p -> copy);
	}

	static ReferenceDTO copy0(ReferenceDTO original) {
		ReferenceDTO copy = new ReferenceDTO();
		copy.matches = new ArrayList<>(original.matches);
		copy.minimumCardinality = original.minimumCardinality;
		copy.targetFilter = original.targetFilter;
		copy.template = copy(original.template);
		return copy;
	}

	public static ContainerTemplateDTO copy(ContainerTemplateDTO original, boolean clear) {
		try {
			if (cache.get().containsKey(original)) {
				return (ContainerTemplateDTO)cache.get().get(original);
			}
			ContainerTemplateDTO copy = copy0(original);
			return (ContainerTemplateDTO)cache.get().computeIfAbsent(original, p -> copy);
		}
		finally {
			if (clear)
				cache.remove();
		}
	}

	static ContainerTemplateDTO copy0(ContainerTemplateDTO original) {
		ContainerTemplateDTO copy = new ContainerTemplateDTO();
		copy.components = copy(original.components);
		copy.extensions = copy(original.extensions);
		copy.id = original.id;
		return copy;
	}

	static ComponentTemplateDTO copy(ComponentTemplateDTO original) {
		if (cache.get().containsKey(original)) {
			return (ComponentTemplateDTO)cache.get().get(original);
		}
		ComponentTemplateDTO copy = copy0(original);
		return (ComponentTemplateDTO)cache.get().computeIfAbsent(original, p -> copy);
	}

	static ComponentTemplateDTO copy0(ComponentTemplateDTO original) {
		ComponentTemplateDTO copy = new ComponentTemplateDTO();
		copy.activations = copy(original.activations);
		copy.beans = new ArrayList<>(original.beans);
		copy.configurations = copy(original.configurations);
		copy.name = original.name;
		copy.properties = original.properties == null ? null : new HashMap<>(original.properties);
		copy.references = copy(original.references);
		copy.type = original.type;
		return copy;
	}

	static ExtensionTemplateDTO copy(ExtensionTemplateDTO original) {
		if (cache.get().containsKey(original)) {
			return (ExtensionTemplateDTO)cache.get().get(original);
		}
		ExtensionTemplateDTO copy = copy0(original);
		return (ExtensionTemplateDTO)cache.get().computeIfAbsent(original, p -> copy);
	}

	static ExtensionTemplateDTO copy0(ExtensionTemplateDTO original) {
		ExtensionTemplateDTO copy = new ExtensionTemplateDTO();
		copy.serviceFilter = original.serviceFilter;
		return copy;
	}

	static ActivationTemplateDTO copy(ActivationTemplateDTO original) {
		if (cache.get().containsKey(original)) {
			return (ActivationTemplateDTO)cache.get().get(original);
		}
		ActivationTemplateDTO copy = copy0(original);
		return (ActivationTemplateDTO)cache.get().computeIfAbsent(original, p -> copy);
	}

	static ActivationTemplateDTO copy0(ActivationTemplateDTO original) {
		ActivationTemplateDTO copy = new ActivationTemplateDTO();
		copy.properties = original.properties == null ? null : new HashMap<>(original.properties);
		copy.scope = original.scope;
		copy.serviceClasses = new ArrayList<>(original.serviceClasses);
		return copy;
	}

	static ConfigurationTemplateDTO copy(ConfigurationTemplateDTO original) {
		if (cache.get().containsKey(original)) {
			return (ConfigurationTemplateDTO)cache.get().get(original);
		}
		ConfigurationTemplateDTO copy = copy0(original);
		return (ConfigurationTemplateDTO)cache.get().computeIfAbsent(original, p -> copy);
	}

	static ConfigurationTemplateDTO copy0(ConfigurationTemplateDTO original) {
		ConfigurationTemplateDTO copy = new ConfigurationTemplateDTO();
		copy.maximumCardinality = original.maximumCardinality;
		copy.pid = original.pid;
		copy.policy = original.policy;
		return copy;
	}

	static ReferenceTemplateDTO copy(ReferenceTemplateDTO original) {
		if (cache.get().containsKey(original)) {
			return (ReferenceTemplateDTO)cache.get().get(original);
		}
		ReferenceTemplateDTO copy = copy0(original);
		return (ReferenceTemplateDTO)cache.get().computeIfAbsent(original, p -> copy);
	}

	static ReferenceTemplateDTO copy0(ReferenceTemplateDTO original) {
		ReferenceTemplateDTO copy = new ReferenceTemplateDTO();
		copy.maximumCardinality = original.maximumCardinality;
		copy.minimumCardinality = original.minimumCardinality;
		copy.name = original.name;
		copy.policy = original.policy;
		copy.policyOption = original.policyOption;
		copy.serviceType = original.serviceType;
		copy.targetFilter = original.targetFilter;
		return copy;
	}

	@SuppressWarnings("unchecked")
	static <T> T copy(T original) {
		if (original instanceof ActivationDTO) {
			return (T)copy((ActivationDTO)original);
		}
		else if (original instanceof ActivationTemplateDTO) {
			return (T)copy((ActivationTemplateDTO)original);
		}
		else if (original instanceof ComponentDTO) {
			return (T)copy((ComponentDTO)original);
		}
		else if (original instanceof ComponentInstanceDTO) {
			return (T)copy((ComponentInstanceDTO)original);
		}
		else if (original instanceof ComponentTemplateDTO) {
			return (T)copy((ComponentTemplateDTO)original);
		}
		else if (original instanceof ConfigurationDTO) {
			return (T)copy((ConfigurationDTO)original);
		}
		else if (original instanceof ConfigurationTemplateDTO) {
			return (T)copy((ConfigurationTemplateDTO)original);
		}
		else if (original instanceof ContainerDTO) {
			return (T)copy((ContainerDTO)original);
		}
		else if (original instanceof ContainerTemplateDTO) {
			return (T)copy((ContainerTemplateDTO)original);
		}
		else if (original instanceof ExtensionDTO) {
			return (T)copy((ExtensionDTO)original);
		}
		else if (original instanceof ExtensionTemplateDTO) {
			return (T)copy((ExtensionTemplateDTO)original);
		}
		else if (original instanceof ReferenceDTO) {
			return (T)copy((ReferenceDTO)original);
		}
		else if (original instanceof ReferenceTemplateDTO) {
			return (T)copy((ReferenceTemplateDTO)original);
		}

		return null;
	}

	static <T> List<T> copy(List<T> original) {
		return original.stream().map(t -> copy(t)).collect(Collectors.toList());
	}

	private static final ThreadLocal<Map<Object, Object>> cache =
		ThreadLocal.withInitial(() -> new ConcurrentHashMap<>());

}