package de.fhdw.wtf.common.ast;
   
   import java.util.ArrayList;
   import java.util.Collection;
   import java.util.Collections;
   import java.util.HashMap;
   import java.util.Iterator;
   import java.util.List;
   import java.util.Map;
  
  import de.fhdw.wtf.common.ast.type.BaseType;
  import de.fhdw.wtf.common.ast.type.ClassType;
  import de.fhdw.wtf.common.ast.type.SumType;
  import de.fhdw.wtf.common.ast.type.Type;
  import de.fhdw.wtf.common.ast.visitor.GroupElementVisitor;
  import de.fhdw.wtf.common.constants.referencer.BaseTypeConstants;
  import de.fhdw.wtf.common.token.DummyToken;
  import de.fhdw.wtf.common.token.IdentifierToken;
  import de.fhdw.wtf.common.token.Token;
  
  /**
   * This class represents the root node of the abstract syntax tree. This node only contains groups, but does not need to
   * for generation.
   */
  public final class Model extends SyntaxObject {
  	
  	/**
  	 * BaseType Integer.
  	 */
  	private final BaseType integer;
  	
  	/**
  	 * BaseType String.
  	 */
  	private final BaseType string;
  	
  	/**
  	 * "BaseType" Anything. The Referencer fill this Sum. Anything could contain itself, the prototype of Anything not.
  	 */
  	private final SumType anything;
  	
  	/**
  	 * After analyzing the inheritance trees of this model. The responsible classes (regarding constructor calls) and
  	 * the super types which shall be instantiated by those classes will be stored here. This result is stored here as
  	 * it is needed by multiple task which's performances are based on it.
  	 */
  	private final Map<Type, List<Type>> constructorCallDependencies;
  	
  	/**
  	 * generated.
  	 */
  	private static final long serialVersionUID = 5098229960027033738L;
  	
  	/**
  	 * Constant for Line-Break.
  	 */
  	private static final String BREAK = " \n";
  	
  	/**
  	 * The groups of this model.
  	 */
  	private final Collection<Group> groups;
  	
  	/**
  	 * Private Constructor of {@link Model}.
  	 * 
  	 * @param group
  	 *            The groups of the model
  	 * @param firstToken
  	 *            firstToken
  	 * @param lastToken
  	 *            lastToken
  	 */
  	private Model(final Collection<Group> group, final Token firstToken, final Token lastToken) {
  		super(firstToken, lastToken);
  		this.groups = group;
  		this.anything = SumType.create(DummyToken.getInstance(), DummyToken.getInstance());
  		this.integer =
  				BaseType.create(
  						UnqualifiedName.create(IdentifierToken.create(
  								BaseTypeConstants.INTEGER_CONSTANT,
  								DummyToken.getDummyPosition())),
  						DummyToken.getInstance(),
  						DummyToken.getInstance());
  		this.string =
  				BaseType.create(
  						UnqualifiedName.create(IdentifierToken.create(
  								BaseTypeConstants.STRING_CONSTANT,
  								DummyToken.getDummyPosition())),
  						DummyToken.getInstance(),
  						DummyToken.getInstance());
  		this.constructorCallDependencies = new HashMap<>();
  	}
  	
  	/**
  	 * Creates a {@link Model}-Object.
  	 * 
  	 * @param firstToken
  	 *            firstToken
 	 * @param lastToken
 	 *            lastToken
 	 * @return The Model-Object.
 	 */
 	public static Model create(final Token firstToken, final Token lastToken) {
 		return new Model(new ArrayList<Group>(), firstToken, lastToken);
 	}
 	
 	/**
 	 * Creates a {@link Model}-Object.
 	 * 
 	 * @param firstToken
 	 *            firstToken
 	 * @return The Model-Object.
 	 */
 	public static Model create(final Token firstToken) {
 		return new Model(new ArrayList<Group>(), firstToken, null);
 	}
 	
 	/**
 	 * Adds a Group to contained collection of groups.
 	 * 
 	 * @param group
 	 *            : Group.
 	 */
 	public void addGroup(final Group group) {
 		this.groups.add(group);
 	}
 	
 	/**
 	 * Returns the local list. The list can't be modified with the operations for Collections.
 	 * 
 	 * @return the stream
 	 */
 	public Collection<Group> getGroups() {
 		return Collections.unmodifiableCollection(this.groups);
 	}
 	
 	@Override
 	public boolean equals(final Object o) {
 		if (o instanceof Model) {
 			boolean result = true;
 			final Model other = (Model) o;
 			result = result && this.getGroups().size() == other.getGroups().size();
 			if (result) {
 				final Group[] thisArray = this.getGroups().toArray(new Group[this.getGroups().size()]);
 				final Group[] otherArray = other.getGroups().toArray(new Group[other.getGroups().size()]);
 				for (int i = 0; i < this.getGroups().size(); i++) {
 					result = result && thisArray[i].equals(otherArray[i]);
 				}
 				return result;
 			}
 		}
 		return false;
 	}
 	
 	@Override
 	public int hashCode() {
 		int result = 0;
 		for (final Group group : this.getGroups()) {
 			result ^= group.hashCode();
 		}
 		return result;
 	}
 	
 	@Override
 	public String toString() {
 		final StringBuilder result = new StringBuilder();
 		result.append(de.fhdw.wtf.common.constants.parser.AstDescriptionConstants.MODEL_TO_STRING).append(BREAK);
 		final Iterator<Group> i = this.getGroups().iterator();
 		while (i.hasNext()) {
 			final Group current = i.next();
 			result.append(current).append(BREAK);
 		}
 		return result.toString();
 	}
 	
 	/**
 	 * Calculates lists of all classes and groups.
 	 * 
 	 * @return list of classes, list of groups
 	 */
 	public Tuple<Collection<ClassType>, Collection<Group>> calcAllGroupsAndClasses() {
 		final Collection<Group> allGroups = new ArrayList<>();
 		final Collection<ClassType> classes = new ArrayList<>();
 		for (final Group g : this.getGroups()) {
 			allGroups.add(g);
 			this.processGroupElementsForGroupsAndClasses(g, allGroups, classes);
 		}
 		return new Tuple<>(classes, allGroups);
 		
 	}
 	
 	/**
 	 * Fill the list of classes and groups with all classes and groups of the Group g.
 	 * 
 	 * @param g
 	 *            Group where the method searched
 	 * @param allGroups
 	 *            list, which fill this method with all groups of g
 	 * @param classes
 	 *            list, which fill this method with all classes of g
 	 */
 	void processGroupElementsForGroupsAndClasses(final Group g,
 			final Collection<Group> allGroups,
 			final Collection<ClassType> classes) {
 		final GroupElementVisitor v = new GroupElementVisitor() {
 			@Override
 			public void handle(final Group g2) {
 				allGroups.add(g2);
 				Model.this.processGroupElementsForGroupsAndClasses(g2, allGroups, classes);
 			}
 			
 			@Override
 			public void handle(final ClassType clss) {
 				classes.add(clss);
 			}
 		};
 		for (final GroupElement element : g.getGroupElements()) {
 			element.accept(v);
 		}
 	}
 	
 	/**
 	 * Return the Basetype Integer.
 	 * 
 	 * @return Integer
 	 */
 	public BaseType getInteger() {
 		return this.integer;
 	}
 	
 	/**
 	 * Return the Basetype String.
 	 * 
 	 * @return String
 	 */
 	public BaseType getString() {
 		return this.string;
 	}
 	
 	/**
 	 * Return the "BaseType" Anything.
 	 * 
 	 * @return Anything
 	 */
 	public SumType getAnything() {
 		return this.anything;
 	}
 	
 	/**
 	 * Adds the pair (responsibleType, supertypesToCall) to the constructorCallDependencies mapping.
 	 * 
 	 * @param responsibleType
 	 *            the key.
 	 * @param supertypesToCall
 	 *            the value.
 	 */
 	public void putConstructorCallDependency(final Type responsibleType, final List<Type> supertypesToCall) {
 		this.constructorCallDependencies.put(responsibleType, supertypesToCall);
 	}
 	
 	/**
 	 * Returns an unmodifiable version of the constructorCallDependencies map.
 	 * 
 	 * @return the constructorCallDependencies.
 	 */
 	public Map<Type, List<Type>> getConstructorCallDependencies() {
 		return Collections.unmodifiableMap(this.constructorCallDependencies);
 	}
 	
 }