org.eclipse.osbp.abstractstatemachine/src/org/eclipse/osbp/abstractstatemachine/AbstractDataProvider.java

package org.eclipse.osbp.abstractstatemachine;

import java.beans.BeanInfo;
import java.beans.IntrospectionException;
import java.beans.Introspector;
import java.beans.MethodDescriptor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Stack;

import org.eclipse.osbp.dsl.common.datatypes.IDto;
import org.eclipse.osbp.dsl.dto.lib.impl.DtoServiceAccess;
import org.eclipse.osbp.dsl.dto.lib.services.IDTOService;
import org.eclipse.osbp.dsl.dto.lib.services.Query;
import org.eclipse.osbp.dsl.dto.lib.services.filters.LCompare;
import org.eclipse.osbp.dsl.semantic.dto.LDto;
import org.eclipse.osbp.ecview.core.common.beans.ISlot;
import org.eclipse.osbp.ui.api.statemachine.IDataProvider;
import org.eclipse.osbp.ui.api.statemachine.IStateMachine;

@SuppressWarnings("restriction")
public abstract class AbstractDataProvider extends
		AbstractStateMachineParticipant implements IDataProvider,
		IDataProvider.Provider {

	protected Map<String, IDTOService<? extends IDto>> dtoServices = new HashMap<>();
	protected boolean ready;
	
	@Override
	public void setStatemachine(IStateMachine statemachine) {
		super.setStatemachine(statemachine);
		statemachine.registerDataProvider(this);
	}

	@Override
	public void initDatasource(String dtoAlias) {
		ISlot slot = viewContext.getBeanSlot(dtoAlias);
		if(slot == null) {
			LOGGER.error("cannot find alias "+dtoAlias+" in UI model. DTO therefore not accessible for DataProviders");
			return;
		}
		if (IDto.class.isAssignableFrom(slot.getValueType())) {
			@SuppressWarnings("unchecked")
			Class<IDto> type = (Class<IDto>) slot.getValueType();
			dtoServices.put(type.getSimpleName(),
					DtoServiceAccess.getService(type));
		} else {
			LOGGER.error(dtoAlias+" is not bound as DTO from UI model and therefore not accessible for DataProviders");
		}
	}

	public void initDatasourceFromDto(String dtoName) {
		for(String slotName:viewContext.getValueBeans().keySet()) {
			ISlot slot = viewContext.getBeanSlot(slotName);
			if (IDto.class.isAssignableFrom(slot.getValueType())) {
				@SuppressWarnings("unchecked")
				Class<IDto> type = (Class<IDto>) slot.getValueType();
				if(dtoName.equals(type.getSimpleName())) {
					dtoServices.put(type.getSimpleName(),
							DtoServiceAccess.getService(type));
					return;
				}
			}
		}
		LOGGER.error(dtoName+" is not bound from UI model and therefore not accessible for DataProviders");
	}

	@Override
	public Boolean find(IDataProvider.Provider listener, String dtoName,
			String fieldName, Object search) {
		return find(listener, dtoName, new Query(new LCompare.Equal(fieldName, search)));
	}
		
	@Override
	public Boolean find(IDataProvider.Provider listener, String dtoName, Query query) {
		Collection<? extends IDto> results = findDtoInstances(dtoName, query);
		if (results == null) {
			return false;
		}
		if (results.size() > 1) {
			LOGGER.error("find for " + dtoName
					+ " returned multiple values - first value is used");
		}
		if (results.isEmpty()) {
			LOGGER.error("find for " + dtoName + " returned no values");
		}
		try {
			Method method = setter(listener, dtoName, IDto.class);
			if(method == null) {
				return null;
			}
			if (results.isEmpty()) {
				method.invoke(listener, (IDto) null);
			} else {
				method.invoke(listener, (IDto) results.iterator().next());
			}
			return true;
		} catch (IllegalAccessException
				| IllegalArgumentException | InvocationTargetException e) {
			System.out.println(e);
			return null;
		}
	}

	protected Collection<? extends IDto> findDtoInstances(String dtoName, Query query) {
		if (!dtoServices.containsKey(dtoName)) {
			LOGGER.error(dtoName + " was not bound from ui model");
			return null;
		}
		IDTOService<? extends IDto> dtoService = dtoServices.get(dtoName);
		if (dtoService == null) {
			LOGGER.error(dtoName + " has no service registrated");
			return null;
		}
		Collection<? extends IDto> results;
		try {
			results = dtoService.find(query);
			if (results.size() > 1) {
				LOGGER.error("find for " + dtoName
						+ " returned multiple values - first value is used");
			}
			if (results.isEmpty()) {
				LOGGER.error("find for " + dtoName + " returned no values");
				return null;
			}
			return results;
		} catch (Exception e) {
			LOGGER.error("{}", e);
		}
		return null;
	}

	@Override
	public Boolean operation(IDataProvider.Provider listener, String name,
			Stack<Object> parameter) {
		try {
			Class<?> clz = listener.getClass();
			try {
				BeanInfo info = Introspector.getBeanInfo(clz);
				for (MethodDescriptor desc : info.getMethodDescriptors()) {
					if (desc.getName().equalsIgnoreCase(name)) {
						Method method = desc.getMethod();
						return (Boolean) method.invoke(listener, parameter);
					}
				}
			} catch (IntrospectionException e) {
				LOGGER.error("{}", e);
			}
			return null;
		} catch (IllegalAccessException
				| IllegalArgumentException | InvocationTargetException e) {
			return null;
		}
	}
	
	protected Method dispatchMethod(Provider listener, String methodName) {
		try {
			Class<?> clz = listener.getClass();
			try {
				BeanInfo info = Introspector.getBeanInfo(clz);
				for (MethodDescriptor desc : info.getMethodDescriptors()) {
					if (desc.getName().equalsIgnoreCase(methodName)) {
						return desc.getMethod();
					}
				}
			} catch (IntrospectionException e) {
				LOGGER.error("{}", e);
			}
		} catch (IllegalArgumentException e) {
			LOGGER.error("{}", e);
		}
		return null;
	}
	
	@Override
	public void addTo(Provider listener, String dtoName, String listName, IDto dto) {
		Method method = dispatchMethod(listener, "addTo"+dtoName+listName);
		if(method != null) {
			try {
				method.invoke(listener, dto);
			} catch (IllegalAccessException | IllegalArgumentException
					| InvocationTargetException e) {
				LOGGER.error("{}", e);
			}
		} else {
			LOGGER.error("method addTo"+dtoName+listName+" not generated");
		}
	}
	
	@Override
	public void removeFrom(Provider listener, String dtoName, String listName, IDto dto) {
		Method method = dispatchMethod(listener, "removeFrom"+dtoName+listName);
		if(method != null) {
			try {
				method.invoke(listener, dto);
			} catch (IllegalAccessException | IllegalArgumentException
					| InvocationTargetException e) {
				LOGGER.error("{}", e);
			}
		} else {
			LOGGER.error("method removeFrom"+dtoName+listName+" not generated");
		}
	}

	@Override
	public void update(Provider listener, String dtoName, IDto dto) {
		Method method = dispatchMethod(listener, "update"+dtoName);
		if(method != null) {
			try {
				method.invoke(listener, dto);
			} catch (IllegalAccessException | IllegalArgumentException
					| InvocationTargetException e) {
				LOGGER.error("{}", e);
			}
		} else {
			LOGGER.error("method update"+dtoName+" not generated");
		}
	}

	@Override
	public void delete(Provider listener, String dtoName, IDto dto) {
		Method method = dispatchMethod(listener, "delete"+dtoName);
		if(method != null) {
			try {
				method.invoke(listener, dto);
			} catch (IllegalAccessException | IllegalArgumentException
					| InvocationTargetException e) {
				LOGGER.error("{}", e);
			}
		} else {
			LOGGER.error("delete update"+dtoName+" not generated");
		}
	}
}