package schedframe.resources.computing.description;

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

import schedframe.Parameters;
import schedframe.resources.ResourceTypeFactory;
import schedframe.resources.devices.Device;
import schedframe.resources.devices.DeviceFactory;
import schedframe.resources.devices.description.DeviceDescription;
import schedframe.resources.devices.description.PhysicalResourceDescription;
import schedframe.resources.units.ResourceUnit;
import schedframe.resources.units.ResourceUnitFactory;
import schedframe.resources.units.ResourceUnitName;
import schedframe.resources.utils.ResourceIdGenerator;
import schemas.ComputingResource;


public class ComputingResourceDescription extends PhysicalResourceDescription implements ExecutingResourceDescription {

	protected Map<ResourceUnitName, List<ResourceUnit>> resUnits;
	protected List<Device> devices;
	
	public ComputingResourceDescription(ComputingResource computingResource) {

		super(ResourceTypeFactory.createResourceType(computingResource.getClazz()));
		this.category = computingResource.getType();
		
		initId(computingResource);

		if (computingResource.getComputingResourceTypeChoiceSequence() != null) {
			initResourceUnits(computingResource.getComputingResourceTypeChoiceSequence().getResourceUnit());
			initProfiles(computingResource.getComputingResourceTypeChoiceSequence().getProfile());
			initLocation(computingResource.getComputingResourceTypeChoiceSequence().getLocation());
			initDevices(computingResource.getComputingResourceTypeChoiceSequence().getDevice());
			this.parameters = extractParameters(computingResource.getComputingResourceTypeChoiceSequence().getParameter());
		} else {
			initLoadProfile(null);
		}
	}

	private void initId(ComputingResource computingResource){
		this.id = computingResource.getName() != null ? computingResource.getName() : type.getName();
		if(computingResource.getCount() >= 1 || computingResource.getName() == null){
			this.id = id + "_" + String.valueOf(ResourceIdGenerator.getId(type.getName()));
		}
	}
	
	private void initResourceUnits(schemas.ResourceUnit[] resourceUnitCharacteristics) {
		for (int i = 0; i < resourceUnitCharacteristics.length; i++) {
			schemas.ResourceUnit resourceUnitCharacteristic = resourceUnitCharacteristics[i];
			ResourceUnit resourceUnit = ResourceUnitFactory.createUnit(resourceUnitCharacteristic.getClazz(), this.id,
					 Double.valueOf(resourceUnitCharacteristic.getAmount().getContent()).intValue(), 0);
			Parameters params = extractParameters(resourceUnitCharacteristic.getParameter());
			resourceUnit.init(params);
			addResourceUnit(resourceUnit);
		}
	}
	
	private void initDevices(schemas.Device[] dev) {
		if (dev != null){
			this.devices = new ArrayList<Device>();
			for(int i = 0; i < dev.length; i++){
				long devCount = dev[i].getCount() > 1 ? dev[i].getCount() : 1;
				for(int j = 0; j < devCount; j++){
					Device device =  DeviceFactory.createDevice(new DeviceDescription(dev[i]));
					this.devices.add(device);
				}
			}
		}
	}

	public String getCompResourceParameterValue(String name){
		return getParameters().get(name).get(0).getContent();
	}

	/*private Properties initProperties(schemas.Parameter[] parameters){
		Properties prop = new Properties();
		
		for(int i = 0; i < parameters.length; i++){
			schemas.Parameter parameter = parameters[i];
			List values = new ArrayList();
			if(parameter.getParameterTypeSequence().getProperty() != null)
			{
				Map<String, List<StringValueWithUnit>> properties = new HashMap<String, List<StringValueWithUnit>>();
				List<StringValueWithUnit> propValues = new ArrayList<StringValueWithUnit>();
				for(int j = 0; j < parameter.getParameterTypeSequence().getPropertyCount(); j++){
					schemas.Property property = parameter.getParameterTypeSequence().getProperty(j);
					for(int k = 0; k < property.getStringValueWithUnitCount(); k++){
						propValues.add(property.getStringValueWithUnit(k));
					}
					properties.put(property.getName(), propValues);
				}
				values.add(properties);
			}else {
				for(int j = 0; j < parameter.getStringValueWithUnitCount(); j++){
					values.add(parameter.getStringValueWithUnit(j));
				}
			}
			prop.put(parameter.getName(), values);
		}
		return prop;
	}*/


	public List<Device> getDevices() {
		return devices;
	}


	public void addResourceUnit(ResourceUnit unit) {
		if (this.resUnits == null)
			this.resUnits = new HashMap<ResourceUnitName, List<ResourceUnit>>(2);
		List<ResourceUnit> list = null;
		if (this.resUnits.containsKey(unit.getName())) {
			list = this.resUnits.get(unit.getName());
		} else {
			list = new ArrayList<ResourceUnit>(1);
			this.resUnits.put(unit.getName(), list);
		}
		list.add(unit);
	}
	
	public ResourceUnit getResourceUnit(ResourceUnitName unitName) throws NoSuchFieldException {
		return getResourceUnitList(unitName).get(0);
	}

	public List<ResourceUnit> getResourceUnitList(ResourceUnitName unitName) throws NoSuchFieldException {
		if (resUnits.containsKey(unitName))
			return resUnits.get(unitName);
		else
			throw new NoSuchFieldException("Resource unit " + unitName + " is not available in resource " + this.id);
	}

	public Collection<ResourceUnit> getResourceUnit() {
		if (resUnits == null)
			return null;
		List<ResourceUnit> values = new ArrayList<ResourceUnit>();
		Collection<List<ResourceUnit>> lists = resUnits.values();
		Iterator<List<ResourceUnit>> itr = lists.iterator();

		while (itr.hasNext()) {
			List<ResourceUnit> list = itr.next();
			values.addAll(list);
		}

		return values;
	}

	public Map<ResourceUnitName, List<ResourceUnit>> getResourceUnits() {
		return resUnits;
	}
}