EDIT

package eu.etaxonomy.cdm.io.xper;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import java.util.Set;

import java.util.UUID;

import org.apache.commons.lang.StringUtils;

import org.apache.log4j.Logger;

import org.springframework.stereotype.Component;

import org.springframework.transaction.TransactionStatus;

import eu.etaxonomy.cdm.api.service.ITermService;

import eu.etaxonomy.cdm.api.service.IVocabularyService;

import eu.etaxonomy.cdm.api.service.pager.Pager;

import eu.etaxonomy.cdm.common.CdmUtils;

import eu.etaxonomy.cdm.io.common.CdmIoBase;

import eu.etaxonomy.cdm.io.common.IoStateBase;

import eu.etaxonomy.cdm.model.common.CdmBase;

import eu.etaxonomy.cdm.model.common.DefinedTermBase;

import eu.etaxonomy.cdm.model.common.Language;

import eu.etaxonomy.cdm.model.common.Representation;

import eu.etaxonomy.cdm.model.common.TermVocabulary;

import eu.etaxonomy.cdm.model.common.UuidAndTitleCache;

import eu.etaxonomy.cdm.model.description.CategoricalData;

import eu.etaxonomy.cdm.model.description.Feature;

import eu.etaxonomy.cdm.model.description.FeatureNode;

import eu.etaxonomy.cdm.model.description.FeatureTree;

import eu.etaxonomy.cdm.model.description.MeasurementUnit;

import eu.etaxonomy.cdm.model.description.QuantitativeData;

import eu.etaxonomy.cdm.model.description.State;

import eu.etaxonomy.cdm.model.description.StateData;

import eu.etaxonomy.cdm.model.description.WorkingSet;

import eu.etaxonomy.cdm.model.taxon.TaxonBase;

import fr_jussieu_snv_lis.XPApp;

import fr_jussieu_snv_lis.Xper;

import fr_jussieu_snv_lis.IO.IExternalAdapter;

import fr_jussieu_snv_lis.base.Individual;

import fr_jussieu_snv_lis.base.Mode;

import fr_jussieu_snv_lis.base.Variable;

import fr_jussieu_snv_lis.utils.Utils;

@Component

public class CdmXperAdapter extends CdmIoBase implements IExternalAdapter{

	private static final Logger logger = Logger.getLogger(CdmXperAdapter.class);

	TransactionStatus tx;

	private CdmXperAdapter  adapter = this;

//	private CdmApplicationController cdmApplicationController;

	private CdmXperBaseControler baseController;

	private UUID uuidWorkingSet;

//	private WorkingSet workingSet; 

	//TODO preliminary

	//CONFIGURATION

	private boolean isLazyModes = false;

	private boolean isLazyIndMatrix = true;

	private boolean useSecInTaxonName = false;

	public CdmXperAdapter(){

		BaseCdm base = new BaseCdm();

		CdmXperBaseControler baseController = new CdmXperBaseControler(base, this);

		setBaseController(baseController);

	}

	public boolean startXper(UUID uuidWorkingSet){

		this.uuidWorkingSet = uuidWorkingSet;

		Thread t = new Thread() {

			public void run() {

				new Xper(adapter);

			}

		};

		System.out.println("xper2 start");

		t.start();

//		while(!XPApp.xperReady){

//			//TODO

//		}

//		System.out.println("xper2 started :::");

		return true;

	}

//************************* GETTER /SETTER **********************/	

	public void setBaseController(CdmXperBaseControler baseController) {

		this.baseController = baseController;

	}

	/* (non-Javadoc)

	 * @see fr_jussieu_snv_lis.IO.IExternalAdapter#getBaseController()

	 */

	public CdmXperBaseControler getBaseController() {

		return baseController;

	}

	public WorkingSet getWorkingSet() {

//		if (this.workingSet == null){

			WorkingSet workingSet = getWorkingSetService().find(uuidWorkingSet);

//		}

		return workingSet;

	}

	public WorkingSet getLanguage() {

//		if (this.workingSet == null){

			WorkingSet workingSet = getWorkingSetService().find(uuidWorkingSet);

//		}

		return workingSet;

	}

//*********************** METHODS **********************/	

	public void load(){

		loadFeatures();

		loadTaxa();

	}

	// Load the featureTree with the UUID

	public void loadFeatures() {

		logger.warn("load features start");

		TransactionStatus tx = startTransaction();

		FeatureTree featureTree = getWorkingSet().getDescriptiveSystem();

		getFeatureTreeService().saveOrUpdate(featureTree);

		if (featureTree != null) {

			loadFeatureNode(featureTree.getRoot(), -1);

		}else{

			logger.warn("No feature tree available");

		}

		commitTransaction(tx);

		logger.warn("load features end :::");

	}

	/**

	 * Recursive methode to load FeatureNode and all its children

	 * 

	 * @param featureNode

	 * @param indiceParent

	 */

	public void loadFeatureNode(FeatureNode featureNode, int indiceParent){

		List<FeatureNode> featureList = featureNode.getChildren();

		adaptFeatureListToVariableList(indiceParent, featureList);

	}

	/**

	 * @param indiceParent

	 * @param featureList

	 */

	public void adaptFeatureListToVariableList(int indiceParent, List<FeatureNode> featureList) {

//		List<Variable> result = new ArrayList<Variable>(featureList.size()); 

		for(FeatureNode child : featureList){

			boolean alreadyExist = false;

			Variable variable = adaptFeatureNodeToVariable(child);

			//?? TODO

			List<Variable> vars = XPApp.getCurrentBase().getVariables();

			for(Variable var : vars){

				if(var.getName().equals(variable.getName()))

					alreadyExist = true;

			}

			if(!alreadyExist && (child.getFeature().isSupportsCategoricalData() || child.getFeature().isSupportsQuantitativeData())){

				XPApp.getCurrentBase().addVariable(variable);

//				result.add(variable);

				if(child.getFeature().isSupportsCategoricalData()){

					// Add states to the feature

					if (! isLazyModes){

						addModesToVariable(child, variable);

					}

				}

				if(indiceParent != -1 && XPApp.getCurrentBase().getVariableAt(indiceParent) != null){

//				if(indiceParent != -1 && result.get(indiceParent) != null){

					variable.addMother((XPApp.getCurrentBase().getVariableAt(indiceParent -1)));

//					variable.addMother(result.get(indiceParent -1 ));

				}

				adaptFeatureListToVariableList(variable.getIndexInt(), child.getChildren());

			}else{

				adaptFeatureListToVariableList(indiceParent, child.getChildren());

			}

		}

		return;

	}

	/**

	 * @param child

	 * @param variable

	 */

	private void addModesToVariable(FeatureNode child, Variable variable) {

		Set<TermVocabulary<State>> termVocabularySet = child.getFeature().getSupportedCategoricalEnumerations();

		for(TermVocabulary<State> termVocabulary : termVocabularySet){

			for(State state : termVocabulary.getTerms()){

				Mode mode = adaptStateToMode(state);

				variable.addMode(mode);

			}

		}

	}

	/**

	 * @param child

	 * @return

	 */

	private Variable adaptFeatureNodeToVariable(FeatureNode child) {

		Variable variable = new Variable(child.getFeature().getLabel());

		variable.setUuid(child.getFeature().getUuid());

		if (child.getFeature().isSupportsQuantitativeData()){

			// Specify the character type (numerical)

			variable.setType(Utils.numType);

		}else if (child.getFeature().isSupportsCategoricalData()){

			variable.setType(Utils.catType);

		}

		return variable;

	}

// ******************** STATE - MODE ***********************************/

	private Mode adaptStateToMode(State state) {

		Mode result =  new Mode(state.getLabel());

		result.setUuid(state.getUuid());

		return result;	

	}

	public State adaptModeToState(Mode mode) {

		State state = State.NewInstance(mode.getDescription(), mode.getName(), null);

		mode.setUuid(state.getUuid());

		return state;

	}

// ******************** TAXON - INDIVIDUAL ***********************************/

	/**

	 * @param taxonBase

	 * @return

	 */

	public Individual adaptTaxonToIndividual(TaxonBase taxonBase) {

		String name = useSecInTaxonName? taxonBase.getTitleCache() : taxonBase.getName().getTitleCache();

		Individual individual = new Individual(name);

		individual.setUuid(taxonBase.getUuid());

		return individual;

	}

// ******************************** ******************************************/	

//    // OLD

//	// Load all the taxa and 1 description

//	public void loadTaxaAndDescription() {

//		logger.warn("load taxa start");

//		//fill all variables with empty lists

//

//		

//		TransactionStatus tx = startTransaction();

//		

//		getWorkingSet().getDescriptions();

//		

//		logger.warn("load taxa from CDM");

//		List<TaxonBase> taxonList = getTaxonService().list(Taxon.class , null, null, null, null);

//		

//		for(TaxonBase taxonBase : taxonList){

//			if (XPApp.getCurrentBase() != null) {

//				

//				// Add a image to the taxon

//				BaseObjectResource bor = new BaseObjectResource(new XPResource("http://www.cheloniophilie.com/Images/Photos/Chelonia-mydas/tortue-marine.JPG"));

//                individual.addResource(bor); 

//                

//				// Add an empty description

//                

//                loadDescription(individual, taxonBase);

//                

//			}

//		}

//		commitTransaction(tx);

//		logger.warn("load taxa end :::");

//	}

	/**

	 * Load taxa and convert to individuals.

	 * Loads the 

	 *  - uuid

	 *  - name

	 *  - varModMatrix, 

	 *  - varNumValuesMatrix

	 *  - varComment (TODO)

	 *  - varUnknown (TODO)

	 */

	public void loadTaxa(){

		//categorical data

		logger.warn("load categorical data");

		Map<UuidAndTitleCache, Map<UUID, Set<CategoricalData>>> categoricalData = getCategoricalData();

		handleCategoricalData(categoricalData);

		logger.warn("load categorical data :::");

		//quantitative data

		logger.warn("load quantitative data");

		Map<UuidAndTitleCache, Map<UUID, Set<QuantitativeData>>> quantitativeData = getQuantitativeData();

		handleQuantitativeData(quantitativeData);

		logger.warn("load quantitative data :::");

		//TODO

		//descriptions with no data

		//TODO varComment

		//TODO varUnknown

		//TODO Resources

//		TODO private String index;

//		TODO private String description;

	}

	/**

	 * @return

	 */

	private Map<UuidAndTitleCache, Map<UUID, Set<CategoricalData>>> getCategoricalData() {

		Map<UuidAndTitleCache, Map<UUID, Set<CategoricalData>>> data = getWorkingSetService().getTaxonFeatureDescriptionElementMap(

				CategoricalData.class, uuidWorkingSet, null, null, null, null);

		return data;

	}

	private Map<UuidAndTitleCache, Map<UUID, Set<QuantitativeData>>> getQuantitativeData() {

		Map<UuidAndTitleCache, Map<UUID, Set<QuantitativeData>>> data = getWorkingSetService().getTaxonFeatureDescriptionElementMap(

				QuantitativeData.class, uuidWorkingSet, null, null, null, null);

		return data;

	}

	private void handleCategoricalData(Map<UuidAndTitleCache, Map<UUID, Set<CategoricalData>>> categoricalData) {

		for (UuidAndTitleCache taxon : categoricalData.keySet()){

			Map<UUID, Set<CategoricalData>> variableMap = categoricalData.get(taxon);

			Individual individual = getIndividualByUuidAndTitleCache(taxon);

			handleCategoricalData(variableMap, individual);

		}

	}

	private void handleQuantitativeData(Map<UuidAndTitleCache, Map<UUID, Set<QuantitativeData>>> quantitativeData) {

		for (UuidAndTitleCache taxon : quantitativeData.keySet()){

			Map<UUID, Set<QuantitativeData>> variableMap = quantitativeData.get(taxon);

			Individual individual = getIndividualByUuidAndTitleCache(taxon);

			handleQuantitativeData(variableMap, individual);

		}

	}

	private void handleCategoricalData(Map<UUID, Set<CategoricalData>> variableMap, Individual individual) {

		for (UUID featureUuid : variableMap.keySet()){

			Variable variable = baseController.findVariableByUuid(featureUuid);

			if (variable != null){

				for (CategoricalData categorical : variableMap.get(featureUuid)) {

					// create a list of xper Mode corresponding

					List<Mode> modesList = variable.getModes();

					List<StateData> stateDataList = categorical.getStates();

					for (StateData state : stateDataList) {

						for (Mode mode : modesList) {

							if (state.getState().getUuid().equals(mode.getUuid())) {

								// Add state to the Description

								individual.addModeMatrix(variable, mode);

							}

						}

					}

				}

			}else{

				logger.warn("Variable not found for uuid " +  featureUuid.toString());

			}

		}

	}

	private void handleQuantitativeData(Map<UUID, Set<QuantitativeData>> variableMap, Individual individual) {

		for (UUID featureUuid : variableMap.keySet()){

			Variable variable = baseController.findVariableByUuid(featureUuid);

			if (variable != null){

				for (QuantitativeData qdCDM : variableMap.get(featureUuid)){

					fr_jussieu_snv_lis.base.QuantitativeData qdXper = adaptQdCdm2QdXper(qdCDM);

					individual.addNumMatrix(variable, qdXper);

				}

			}else{

				logger.warn("Variable not found for uuid " +  featureUuid.toString());

			}

		}

	}

	/**

	 * @param qdCDM

	 * @return

	 */

	private fr_jussieu_snv_lis.base.QuantitativeData adaptQdCdm2QdXper(

			QuantitativeData qdCDM) {

		fr_jussieu_snv_lis.base.QuantitativeData qdXper = new fr_jussieu_snv_lis.base.QuantitativeData();

		if (qdCDM.getMax() != null){

			qdXper.setMax(new Double(qdCDM.getMax()));

		}

		if (qdCDM.getMin() != null){

			qdXper.setMin(new Double(qdCDM.getMin()));

		}

		if (qdCDM.getTypicalLowerBoundary() != null){

			qdXper.setUmethLower(new Double(qdCDM

					.getTypicalLowerBoundary()));

		}

		if (qdCDM.getTypicalUpperBoundary() != null){

			qdXper.setUmethUpper(new Double(qdCDM

					.getTypicalUpperBoundary()));

		}

		if (qdCDM.getAverage() != null){

			qdXper.setMean(new Double(qdCDM.getAverage()));

		}

		if (qdCDM.getStandardDeviation() != null){

			qdXper.setSd(new Double(qdCDM.getStandardDeviation()));

		}

		if (qdCDM.getSampleSize() != null){

			qdXper.setNSample(new Integer(Math.round(qdCDM.getSampleSize())));

		}

		return qdXper;

	}

	private Individual getIndividualByUuidAndTitleCache(UuidAndTitleCache taxon) {

		Individual result = this.getBaseController().findIndividualByName(taxon.getTitleCache());

		if (result == null){

			result= new Individual(taxon.getTitleCache());

			result.setUuid(taxon.getUuid());

			this.getBaseController().addIndividual(result);

		}

		return result;

	}

//	// Create a workingSet if not exist

//	public void createWorkingSet(){

//		

//		if(getWorkingSetService().list(WorkingSet.class, null, null, null, null).size() <= 0){

//			WorkingSet ws = WorkingSet.NewInstance();

//			

//			UUID featureTreeUUID = UUID.fromString("47eda782-89c7-4c69-9295-e4052ebe16c6");

//			List<String> featureTreeInit = Arrays.asList(new String[]{"root.children.feature.representations"});

//			

//			FeatureTree featureTree = getFeatureTreeService().load(featureTreeUUID, featureTreeInit);

//			ws.setDescriptiveSystem(featureTree);

//			

//			List<TaxonBase> taxonList = getTaxonService().list(Taxon.class , null, null, null, null);

//			for(TaxonBase taxonBase : taxonList){

//				Pager<TaxonDescription> taxonDescriptionPager = getDescriptionService().getTaxonDescriptions((Taxon)taxonBase, null, null, null, 0, Arrays.asList(new String[]{"elements.states", "elements.feature"} ));

//				List<TaxonDescription> taxonDescriptionList = taxonDescriptionPager.getRecords();

//				TaxonDescription taxonDescription = taxonDescriptionList.get(0);

//				ws.addDescription(taxonDescription);

//				System.out.println(taxonDescription.getUuid());

//			}

//			

//			getWorkingSetService().save(ws);

//		}

//	}

// ************************************ SAVE *************************************/	

	@Override

	public void save() {

		List<Variable> vars = XPApp.getCurrentBase().getVariables();

		saveFeatureTree(vars);

		saveFeatures(vars);

	}

	private void saveFeatureTree(List<Variable> vars) {

		logger.warn("Save feature tree  not yet implemented");

	}

	/**

	 * @param vars

	 */

	private void saveFeatures(List<Variable> vars) {

		tx = startTransaction();

		for (Variable variable : vars){

			Feature feature = getFeature(variable);

			if (Utils.numType.equals(variable.getType())){

				saveNumericalFeature(variable, feature);

			}else if (Utils.catType.equals(variable.getType())){

				saveCategoricalFeature(variable, feature);

			}else{

				logger.warn("variable type undefined");

			}

		}

		commitTransaction(tx);

	}

	/**

	 * @param variable

	 * @return

	 */

	public Feature getFeature(Variable variable) {

		UUID uuid = variable.getUuid();

		ITermService termService = getTermService();

		DefinedTermBase<?> term = termService.find(uuid);

		Feature feature = CdmBase.deproxy(term, Feature.class);

		return feature;

	}

	private void saveCategoricalFeature(Variable variable, Feature feature) {

		ITermService termService = getTermService();

		IVocabularyService vocService = getVocabularyService();

		if (feature == null){

			saveNewFeature(variable, termService, vocService);

		}else{

			if (isChanged(feature, variable)){

				feature.setLabel(variable.getName());

				termService.save(feature);

			}else{

				logger.info("No change for variable: " + variable.getName());

			}

			HashMap<UUID, State> allStates = getAllSupportedStates(feature);

			for (Mode mode : variable.getModes()){

				State state = allStates.get(mode.getUuid());

				if (state == null){

					saveNewState(mode, feature);

				}else{

					allStates.remove(state.getUuid());

					if (modeHasChanged(mode, state)){

						String stateDescription = null;

						String stateLabel = mode.getName();

						String stateAbbrev = null;

						Language lang = Language.DEFAULT();

						Representation rep = state.getRepresentation(lang);

						rep.setLabel(stateLabel);

						termService.saveOrUpdate(state);

//						State state = State.NewInstance(stateDescription, stateLabel, stateAbbrev);

//						termService.save(state);

//						voc.addTerm(state);

//						vocService.save(voc);

					}

				}

			}

			for (State state : allStates.values()){

				logger.warn("There is a state to delete: " + feature.getLabel() + "-" + state.getLabel());

				for (TermVocabulary<State> voc :feature.getSupportedCategoricalEnumerations()){

					voc.removeTerm(state);

				}

			}

		}

	}

	private boolean modeHasChanged(Mode mode, State state) {

		if (CdmUtils.nullSafeEqual(mode.getName(), state.getLabel())){

			return false;

		}else{

			return true;

		}

	}

	public void saveNewState(Mode mode, Feature feature) {

		TransactionStatus ta = startTransaction();

		ITermService termService = getTermService();

		IVocabularyService vocService = getVocabularyService();

		termService.saveOrUpdate(feature);

		int numberOfVocs = feature.getSupportedCategoricalEnumerations().size();

		TermVocabulary<State> voc;

		if (numberOfVocs <= 0){

			//new voc

			String vocLabel = "Vocabulary for feature " + feature.getLabel();

			String vocDescription = vocLabel + ". Automatically created by Xper.";

			String vocAbbrev = null;

			String termSourceUri = null;

			voc = TermVocabulary.NewInstance(vocDescription, vocLabel, vocAbbrev, termSourceUri);

		}else if (numberOfVocs == 1){

			voc = feature.getSupportedCategoricalEnumerations().iterator().next();

		}else{

			//numberOfVocs > 1

			//FIXME preliminary

			logger.warn("Multiple supported vocabularies not yet correctly implemented");

			voc = feature.getSupportedCategoricalEnumerations().iterator().next();

		}

		saveNewModeToVoc(termService, vocService, voc, mode);

		commitTransaction(ta);

	}

	/**

	 * @param variable

	 * @param termService

	 * @param vocService

	 */

	private void saveNewFeature(Variable variable, ITermService termService,

			IVocabularyService vocService) {

		Feature feature;

		//new feature

		String description = null;

		String label = variable.getName();

		String labelAbbrev = null;

		feature = Feature.NewInstance(description, label, labelAbbrev);

		variable.setUuid(feature.getUuid());

		termService.save(feature);

		//new voc

		String vocDescription = null;

		String vocLabel = "Vocabulary for feature " + label;

		String vocAbbrev = null;

		String termSourceUri = null;

		TermVocabulary<State> voc = TermVocabulary.NewInstance(vocDescription, vocLabel, vocAbbrev, termSourceUri);

		for (Mode mode:variable.getModes()){

			saveNewModeToVoc(termService, vocService, voc, mode);

		}

		feature.addSupportedCategoricalEnumeration(voc);

		termService.saveOrUpdate(feature);

	}

	/**

	 * @param termService

	 * @param vocService

	 * @param voc

	 * @param mode

	 */

	private void saveNewModeToVoc(ITermService termService, IVocabularyService vocService, TermVocabulary<State> voc, Mode mode) {

		State state = adaptModeToState(mode);

		termService.save(state);

		voc.addTerm(state);

		vocService.saveOrUpdate(voc);

	}

	private HashMap<UUID, State> getAllSupportedStates(Feature feature) {

		HashMap<UUID, State> result = new HashMap<UUID,State>();

		Set<TermVocabulary<State>> vocs = feature.getSupportedCategoricalEnumerations();

		for (TermVocabulary<State> voc : vocs){

			for (State state : voc.getTerms()){

				result.put(state.getUuid(), state);

			}

		}

		return result;

	}

	private boolean isChanged(Feature feature, Variable variable) {

		//preliminary

		return ! variable.getName().equals(feature.getLabel());

	}

	private void saveNumericalFeature(Variable variable, Feature feature) {

//		IVocabularyService vocService = getVocabularyService();

		String variableUnit = variable.getUnit();

		Set<MeasurementUnit> units = feature.getRecommendedMeasurementUnits();

		//preliminary

		if (StringUtils.isBlank(variableUnit) ){

			//unit is empty

			if (!units.isEmpty()){

				feature.getRecommendedMeasurementUnits().clear();

			}

		}else{

			// unit is not empty

			boolean unitExists = false;

			for (MeasurementUnit measurementUnit: units){

				//TODO ??

				String labelOfUnit = measurementUnit.getLabel();

				if (variableUnit.equals(labelOfUnit)){

					unitExists = true;

					break;

				}

			}

			if (! unitExists){

				units.clear();

				MeasurementUnit existingUnit = findExistingUnit(variableUnit);

				if (existingUnit == null){

					String unitDescription = null;

					String unitLabel = variableUnit;

					String labelAbbrev = null;

					MeasurementUnit newUnit = MeasurementUnit.NewInstance(unitDescription, unitLabel, labelAbbrev);

					getTermService().save(newUnit);

					UUID defaultMeasurmentUnitVocabularyUuid = UUID.fromString("3b82c375-66bb-4636-be74-dc9cd087292a");

					TermVocabulary voc = getVocabularyService().find(defaultMeasurmentUnitVocabularyUuid);

					if (voc == null){

						logger.warn("Could not find MeasurementService vocabulary");

					}else{

						voc.addTerm(newUnit);

						getVocabularyService().saveOrUpdate(voc);

					}

					existingUnit = newUnit;

				}

				feature.addRecommendedMeasurementUnit(existingUnit);

			}

		}

	}

	private MeasurementUnit findExistingUnit(String variableUnit) {

		Pager<MeasurementUnit> existingUnits = getTermService().findByRepresentationText(variableUnit, MeasurementUnit.class, null, null);

		for (MeasurementUnit exUnit : existingUnits.getRecords()){

			if (variableUnit.equals(exUnit.getLabel())){

				return exUnit;

			}

		}

		return null;

	}

// ************************** Override ********************************/	

	@Override

	protected boolean doInvoke(IoStateBase state) {

		//not needed

		return false;

	}

	@Override

	protected boolean doCheck(IoStateBase state) {

		//not needed

		return false;

	}

	@Override

	protected boolean isIgnore(IoStateBase state) {

		//not needed

		return false;

	}

	@Override

	public String toString() {

		String ws = uuidWorkingSet == null ?"-" : uuidWorkingSet.toString();

		return "CdmXperAdapter (" + ws + ")";

	}

}