package com.thalesgroup.cheddar.MARTE2cheddar;

import java.io.*;
import java.util.*;

import org.eclipse.core.resources.IFile;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.emf.common.util.URI;
import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.emf.ecore.resource.ResourceSet;
import org.eclipse.emf.ecore.resource.impl.ResourceSetImpl;

import cheddar.DependencyElement;
import cheddar.Library.to_from_type_kind;

import com.ibm.jvm.util.ByteArrayOutputStream;

/**
 * This class offers functionnalities to improve a cheddar model :
 * - Pretty precedency graph drawing
 * - (nothing more)
 * 
 * <copyright>
 * Thales MARTE to Cheddar (Copyright (c) THALES 2007 All rights reserved) is free software; you can redistribute itand/or modify
 * it under the terms of the Eclipse Public License as published in http://www.eclipse.org/legal/epl-v10.html
 *
 * Thales MARTE to Cheddar is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied
 * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the Eclipse Public License for more details.
 * </copyright>
 * 
 * @author Nicolas Vienne
 * @version 0.0.3, 09/2007
 *
 */
public class CheddarImprover {

	public static void improve(IFile infile) throws IOException, CoreException {
		ResourceSet resourceSet = new ResourceSetImpl();
		URI fileURI = URI.createFileURI(infile.getRawLocation().toString());
		Resource resource = resourceSet.getResource(fileURI, true);
		
		improve(resource);
		
		ByteArrayOutputStream baos = new ByteArrayOutputStream();
		resource.save(baos, Collections.EMPTY_MAP);
		infile.setContents(new ByteArrayInputStream(baos.toByteArray()),
				true, false, new NullProgressMonitor());
	}
	
	public static void improve(Resource resource) {
		for (Object o : resource.getContents()) {
			if (o instanceof cheddar.Root) {
				cheddar.Root root = (cheddar.Root) o;
				HashMap<cheddar.DependencyElement, to_from_type_kind> DependencyTypeMap = new HashMap<cheddar.DependencyElement, to_from_type_kind>();
				HashMap<cheddar.DependencyElement, List<cheddar.DependencyElement>> enfants = new HashMap<cheddar.DependencyElement, List<cheddar.DependencyElement>>();
								for (Object i : root.getDependency()) {
					if (i instanceof cheddar.dependency) {
						cheddar.dependency d = (cheddar.dependency) i;

						if (!DependencyTypeMap.containsKey(d.getFrom())) {
							DependencyTypeMap
									.put(d.getFrom(), d.getFrom_type());
						}
						if (!DependencyTypeMap.containsKey(d.getTo())) {
							DependencyTypeMap.put(d.getTo(), d.getTo_type());
						}

						if (!enfants.containsKey(d.getFrom())) {
							ArrayList<cheddar.DependencyElement> l = new ArrayList<cheddar.DependencyElement>();
							l.add(d.getTo());
							enfants.put(d.getFrom(), l);
						} else {
							enfants.get(d.getFrom()).add(d.getTo());
						}
						if (!enfants.containsKey(d.getTo())) {
							ArrayList<cheddar.DependencyElement> l = new ArrayList<cheddar.DependencyElement>();
							enfants.put(d.getTo(), l);
						}
					}
				}

				ObjectTree<DependencyElement> ot = new ObjectTree<DependencyElement>(
						enfants);
				ot.findRoots();
				ot.run();
				Map<DependencyElement, ObjectPosition> positions = ot
						.getPositions();
				for (DependencyElement e : positions.keySet()) {
					ObjectPosition t = positions.get(e);
					to_from_type_kind tftk = DependencyTypeMap.get(e);

					if (tftk == to_from_type_kind.BUFFER_LITERAL) {
						cheddar.buffer obj = (cheddar.buffer) e;
						obj.setX(t.x);
						obj.setY(t.y + t.dy / 2);
					}

					if (tftk == to_from_type_kind.MESSAGE_LITERAL) {
						cheddar.message obj = (cheddar.message) e;
						obj.setX(t.x);
						obj.setY(t.y + t.dy / 2);
					}

					if (tftk == to_from_type_kind.TASK_LITERAL) {
						cheddar.task obj = (cheddar.task) e;
						obj.setX(t.x);
						obj.setY(t.y + t.dy / 2);
					}
				}
			}
		}
	}
}