/*******************************************************************************
 * Copyright (c) 2012, 2014 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 * 
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/

package org.eclipse.osgi.internal.framework;

import java.lang.reflect.Array;
import java.util.*;
import org.osgi.dto.DTO;
import org.osgi.framework.*;
import org.osgi.framework.dto.*;
import org.osgi.framework.startlevel.BundleStartLevel;
import org.osgi.framework.startlevel.FrameworkStartLevel;
import org.osgi.framework.startlevel.dto.BundleStartLevelDTO;
import org.osgi.framework.startlevel.dto.FrameworkStartLevelDTO;
import org.osgi.framework.wiring.*;
import org.osgi.framework.wiring.dto.*;
import org.osgi.resource.dto.*;

public class DTOBuilder {
	private final Map<BundleRevision, BundleRevisionDTO> resources;
	private final Map<BundleWiring, BundleWiringDTO.NodeDTO> wiringnodes;

	private DTOBuilder() {
		resources = new IdentityHashMap<BundleRevision, BundleRevisionDTO>();
		wiringnodes = new IdentityHashMap<BundleWiring, BundleWiringDTO.NodeDTO>();
	}

	public static BundleDTO newBundleDTO(Bundle bundle) {
		if (bundle == null) {
			return null;
		}
		BundleDTO dto = new BundleDTO();
		dto.id = bundle.getBundleId();
		dto.lastModified = bundle.getLastModified();
		dto.state = bundle.getState();
		dto.symbolicName = bundle.getSymbolicName();
		dto.version = bundle.getVersion().toString();
		return dto;
	}

	public static BundleStartLevelDTO newBundleStartLevelDTO(Bundle b, BundleStartLevel bsl) {
		if (bsl == null) {
			return null;
		}
		BundleStartLevelDTO dto = new BundleStartLevelDTO();
		dto.bundle = b.getBundleId();
		dto.activationPolicyUsed = bsl.isActivationPolicyUsed();
		dto.persistentlyStarted = bsl.isPersistentlyStarted();
		dto.startLevel = bsl.getStartLevel();
		return dto;
	}

	public static BundleRevisionDTO newBundleRevisionDTO(BundleRevision revision) {
		BundleRevisionDTO dto = new DTOBuilder().getBundleRevisionDTO(revision);
		return dto;
	}

	private int getResourceId(BundleRevision revision) {
		BundleRevisionDTO dto = getBundleRevisionDTO(revision);
		if (dto == null) {
			return 0;
		}
		return dto.id;
	}

	private BundleRevisionDTO getBundleRevisionDTO(BundleRevision revision) {
		if (revision == null) {
			return null;
		}
		BundleRevisionDTO dto = resources.get(revision);
		if (dto != null) {
			return dto;
		}
		dto = new BundleRevisionDTO();
		dto.id = identifier(revision);
		resources.put(revision, dto);
		dto.bundle = revision.getBundle().getBundleId();
		dto.symbolicName = revision.getSymbolicName();
		dto.type = revision.getTypes();
		dto.version = revision.getVersion().toString();
		dto.capabilities = getListCapabilityDTO(revision.getDeclaredCapabilities(null));
		dto.requirements = getListRequirementDTO(revision.getDeclaredRequirements(null));
		return dto;
	}

	private List<CapabilityDTO> getListCapabilityDTO(List<BundleCapability> caps) {
		if (caps == null) {
			return null;
		}
		List<CapabilityDTO> dtos = newList(caps.size());
		for (BundleCapability cap : caps) {
			dtos.add(getCapabilityDTO(cap));
		}
		return dtos;
	}

	private CapabilityDTO getCapabilityDTO(BundleCapability cap) {
		if (cap == null) {
			return null;
		}
		CapabilityDTO dto = new CapabilityDTO();
		dto.id = identifier(cap);
		dto.namespace = cap.getNamespace();
		dto.resource = getResourceId(cap.getRevision());
		dto.attributes = newAttributesMapDTO(cap.getAttributes());
		dto.directives = newDirectivesMapDTO(cap.getDirectives());
		return dto;
	}

	private List<CapabilityRefDTO> getListCapabilityRefDTO(List<BundleCapability> caps) {
		if (caps == null) {
			return null;
		}
		List<CapabilityRefDTO> dtos = newList(caps.size());
		for (BundleCapability cap : caps) {
			dtos.add(getCapabilityRefDTO(cap));
		}
		return dtos;
	}

	private CapabilityRefDTO getCapabilityRefDTO(BundleCapability cap) {
		if (cap == null) {
			return null;
		}
		CapabilityRefDTO dto = new CapabilityRefDTO();
		dto.capability = identifier(cap);
		dto.resource = getResourceId(cap.getRevision());
		return dto;
	}

	private List<RequirementDTO> getListRequirementDTO(List<BundleRequirement> reqs) {
		if (reqs == null) {
			return null;
		}
		List<RequirementDTO> dtos = newList(reqs.size());
		for (BundleRequirement req : reqs) {
			dtos.add(getRequirementDTO(req));
		}
		return dtos;
	}

	private RequirementDTO getRequirementDTO(BundleRequirement req) {
		if (req == null) {
			return null;
		}
		RequirementDTO dto = new RequirementDTO();
		dto.id = identifier(req);
		dto.namespace = req.getNamespace();
		dto.resource = getResourceId(req.getRevision());
		dto.attributes = newAttributesMapDTO(req.getAttributes());
		dto.directives = newDirectivesMapDTO(req.getDirectives());
		return dto;
	}

	private List<RequirementRefDTO> getListRequirementRefDTO(List<BundleRequirement> reqs) {
		if (reqs == null) {
			return null;
		}
		List<RequirementRefDTO> dtos = newList(reqs.size());
		for (BundleRequirement req : reqs) {
			dtos.add(getRequirementRefDTO(req));
		}
		return dtos;
	}

	private RequirementRefDTO getRequirementRefDTO(BundleRequirement req) {
		if (req == null) {
			return null;
		}
		RequirementRefDTO dto = new RequirementRefDTO();
		dto.requirement = identifier(req);
		dto.resource = getResourceId(req.getRevision());
		return dto;
	}

	public static BundleRevisionDTO[] newArrayBundleRevisionDTO(BundleRevisions revisions) {
		if (revisions == null) {
			return null;
		}
		List<BundleRevision> revs = revisions.getRevisions();
		final int size = revs.size();
		BundleRevisionDTO[] dtos = new BundleRevisionDTO[size];
		for (int i = 0; i < size; i++) {
			dtos[i] = new DTOBuilder().getBundleRevisionDTO(revs.get(i));
		}
		return dtos;
	}

	public static BundleWiringDTO newBundleWiringDTO(BundleRevision revision) {
		if (revision == null) {
			return null;
		}
		BundleWiringDTO dto = new DTOBuilder().getBundleWiringDTO(revision.getWiring());
		return dto;
	}

	private BundleWiringDTO getBundleWiringDTO(BundleWiring wiring) {
		if (wiring == null) {
			return null;
		}
		BundleWiringDTO dto = new BundleWiringDTO();
		dto.bundle = wiring.getBundle().getBundleId();
		dto.root = getWiringId(wiring);
		dto.nodes = new HashSet<BundleWiringDTO.NodeDTO>(wiringnodes.values());
		dto.resources = new HashSet<BundleRevisionDTO>(resources.values());
		return dto;
	}

	private int getWiringId(BundleWiring wiring) {
		BundleWiringDTO.NodeDTO dto = getBundleWiringNodeDTO(wiring);
		if (dto == null) {
			return 0;
		}
		return dto.id;
	}

	private BundleWiringDTO.NodeDTO getBundleWiringNodeDTO(BundleWiring wiring) {
		if (wiring == null) {
			return null;
		}
		BundleWiringDTO.NodeDTO dto = wiringnodes.get(wiring);
		if (dto != null) {
			return dto;
		}
		dto = new BundleWiringDTO.NodeDTO();
		dto.id = identifier(wiring);
		wiringnodes.put(wiring, dto);
		dto.current = wiring.isCurrent();
		dto.inUse = wiring.isInUse();
		dto.resource = getResourceId(wiring.getRevision());
		dto.capabilities = getListCapabilityRefDTO(wiring.getCapabilities(null));
		dto.requirements = getListRequirementRefDTO(wiring.getRequirements(null));
		dto.providedWires = getListBundleWireDTO(wiring.getProvidedWires(null));
		dto.requiredWires = getListBundleWireDTO(wiring.getRequiredWires(null));
		return dto;
	}

	private List<WireDTO> getListBundleWireDTO(List<BundleWire> wires) {
		if (wires == null) {
			return null;
		}
		List<WireDTO> dtos = newList(wires.size());
		for (BundleWire wire : wires) {
			dtos.add(getBundleWireDTO(wire));
		}
		return dtos;
	}

	private BundleWireDTO getBundleWireDTO(BundleWire wire) {
		if (wire == null) {
			return null;
		}
		BundleWireDTO dto = new BundleWireDTO();
		dto.capability = getCapabilityRefDTO(wire.getCapability());
		dto.requirement = getRequirementRefDTO(wire.getRequirement());
		dto.provider = getResourceId(wire.getProvider());
		dto.requirer = getResourceId(wire.getRequirer());
		dto.providerWiring = getWiringId(wire.getProviderWiring());
		dto.requirerWiring = getWiringId(wire.getRequirerWiring());
		return dto;
	}

	public static BundleWiringDTO[] newArrayBundleWiringDTO(BundleRevisions revisions) {
		if (revisions == null) {
			return null;
		}
		List<BundleRevision> revs = revisions.getRevisions();
		final int size = revs.size();
		List<BundleWiringDTO> dtos = new ArrayList<BundleWiringDTO>(size);
		for (int i = 0; i < size; i++) {
			BundleWiring wiring = revs.get(i).getWiring();
			if (wiring != null) {
				dtos.add(new DTOBuilder().getBundleWiringDTO(wiring)); // use new DTOBuilder for each wiring dto
			}
		}
		return dtos.toArray(new BundleWiringDTO[dtos.size()]);
	}

	public static FrameworkDTO newFrameworkDTO(BundleContext systemBundleContext, Map<String, String> configuration) {
		FrameworkDTO dto = new FrameworkDTO();
		dto.properties = asProperties(configuration);
		if (systemBundleContext == null) {
			dto.bundles = newList(0);
			dto.services = newList(0);
			return dto;
		}
		Bundle[] bundles = systemBundleContext.getBundles();
		int size = bundles == null ? 0 : bundles.length;
		List<BundleDTO> bundleDTOs = newList(size);
		for (int i = 0; i < size; i++) {
			bundleDTOs.add(newBundleDTO(bundles[i]));
		}
		dto.bundles = bundleDTOs;
		try {
			ServiceReference<?>[] references = systemBundleContext.getAllServiceReferences(null, null);
			size = references == null ? 0 : references.length;
			List<ServiceReferenceDTO> refDTOs = newList(size);
			for (int i = 0; i < size; i++) {
				ServiceReferenceDTO serviceRefDTO = getServiceReferenceDTO(references[i]);
				if (serviceRefDTO != null) {
					refDTOs.add(serviceRefDTO);
				}
			}
			dto.services = refDTOs;
		} catch (InvalidSyntaxException e) {
			dto.services = newList(0);
		}
		return dto;
	}

	@SuppressWarnings("unchecked")
	private static Map<String, Object> asProperties(Map<String, ?> m) {
		return (Map<String, Object>) m;
	}

	private static ServiceReferenceDTO getServiceReferenceDTO(ServiceReference<?> ref) {
		if (ref == null) {
			return null;
		}
		Bundle b = ref.getBundle();
		if (b == null) {
			// service has been unregistered
			return null;
		}
		ServiceReferenceDTO dto = new ServiceReferenceDTO();
		dto.bundle = b.getBundleId();
		String[] keys = ref.getPropertyKeys();
		Map<String, Object> properties = newMap(keys.length);
		for (String k : keys) {
			Object v = ref.getProperty(k);
			if (Constants.SERVICE_ID.equals(k)) {
				dto.id = ((Long) v).longValue();
			}
			properties.put(k, mapValue(v));
		}
		dto.properties = properties;
		Bundle[] using = ref.getUsingBundles();
		final int length = (using == null) ? 0 : using.length;
		long[] usingBundles = new long[length];
		for (int i = 0; i < length; i++) {
			usingBundles[i] = using[i].getBundleId();
		}
		dto.usingBundles = usingBundles;
		return dto;
	}

	public static FrameworkStartLevelDTO newFrameworkStartLevelDTO(FrameworkStartLevel fsl) {
		if (fsl == null) {
			return null;
		}
		FrameworkStartLevelDTO dto = new FrameworkStartLevelDTO();
		dto.initialBundleStartLevel = fsl.getInitialBundleStartLevel();
		dto.startLevel = fsl.getStartLevel();
		return dto;
	}

	public static ServiceReferenceDTO[] newArrayServiceReferenceDTO(ServiceReference<?>[] references) {
		if (references == null) {
			return null;
		}
		final int length = references.length;
		List<ServiceReferenceDTO> refDTOs = new ArrayList<ServiceReferenceDTO>(length);
		for (int i = 0; i < length; i++) {
			ServiceReferenceDTO dto = getServiceReferenceDTO(references[i]);
			if (dto != null) {
				refDTOs.add(dto);
			}
		}
		return refDTOs.toArray(new ServiceReferenceDTO[refDTOs.size()]);
	}

	private static Object mapValue(Object v) {
		if ((v == null)
				|| v instanceof Number
				|| v instanceof Boolean
				|| v instanceof Character
				|| v instanceof String
				|| v instanceof DTO) {
			return v;
		}
		if (v instanceof Map) {
			Map<?, ?> m = (Map<?, ?>) v;
			Map<Object, Object> map = newMap(m.size());
			for (Map.Entry<?, ?> e : m.entrySet()) {
				map.put(mapValue(e.getKey()), mapValue(e.getValue()));
			}
			return map;
		}
		if (v instanceof List) {
			List<?> c = (List<?>) v;
			List<Object> list = newList(c.size());
			for (Object o : c) {
				list.add(mapValue(o));
			}
			return list;
		}
		if (v instanceof Set) {
			Set<?> c = (Set<?>) v;
			Set<Object> set = newSet(c.size());
			for (Object o : c) {
				set.add(mapValue(o));
			}
			return set;
		}
		if (v.getClass().isArray()) {
			final int length = Array.getLength(v);
			final Class<?> componentType = mapComponentType(v.getClass().getComponentType());
			Object array = Array.newInstance(componentType, length);
			for (int i = 0; i < length; i++) {
				Array.set(array, i, mapValue(Array.get(v, i)));
			}
			return array;
		}
		return String.valueOf(v);
	}

	private static Class<?> mapComponentType(Class<?> componentType) {
		if (componentType.isPrimitive()
				|| componentType.isArray()
				|| Object.class.equals(componentType)
				|| Number.class.isAssignableFrom(componentType)
				|| Boolean.class.isAssignableFrom(componentType)
				|| Character.class.isAssignableFrom(componentType)
				|| String.class.isAssignableFrom(componentType)
				|| DTO.class.isAssignableFrom(componentType)) {
			return componentType;
		}
		if (Map.class.isAssignableFrom(componentType)) {
			return Map.class;
		}
		if (List.class.isAssignableFrom(componentType)) {
			return List.class;
		}
		if (Set.class.isAssignableFrom(componentType)) {
			return Set.class;
		}
		return String.class;
	}

	private static <E> List<E> newList(int size) {
		return new ArrayList<E>(size);
	}

	private static <E> Set<E> newSet(int size) {
		return new HashSet<E>(size);
	}

	private static <K, V> Map<K, V> newMap(int size) {
		return new HashMap<K, V>(size);
	}

	/**
	 * Assumes the input map is always <String,String>.
	 */
	private static Map<String, String> newDirectivesMapDTO(Map<String, String> map) {
		Map<String, String> dto = new HashMap<String, String>(map);
		return dto;
	}

	/**
	 * Assumes the input map always has String keys and the values are of types:
	 * String, Version, Long, Double or List of the previous types. Lists are copied
	 * and Version objects are converted to String objects.
	 */
	private static Map<String, Object> newAttributesMapDTO(Map<String, Object> map) {
		Map<String, Object> dto = new HashMap<String, Object>(map);
		/* Lists are copied and Version objects are converted to String objects. */
		for (Map.Entry<String, Object> entry : dto.entrySet()) {
			Object value = entry.getValue();
			if (value instanceof Version) {
				entry.setValue(String.valueOf(value));
				continue;
			}
			if (value instanceof List) {
				List<Object> newList = new ArrayList<Object>((List<?>) value);
				for (ListIterator<Object> iter = newList.listIterator(); iter.hasNext();) {
					Object element = iter.next();
					if (element instanceof Version) {
						iter.set(String.valueOf(element));
					}
				}
				entry.setValue(newList);
				continue;
			}
		}
		return dto;
	}

	private static int identifier(Object o) {
		return System.identityHashCode(o);
	}
}
