package org.kite9.diagram.builders;
   
   import java.lang.reflect.AnnotatedElement;
   import java.lang.reflect.Method;
   import java.util.ArrayList;
   import java.util.Collection;
   import java.util.Collections;
   import java.util.HashMap;
   import java.util.List;
  import java.util.Map;
  
  import org.kite9.diagram.adl.Arrow;
  import org.kite9.diagram.adl.Context;
  import org.kite9.diagram.adl.Diagram;
  import org.kite9.diagram.adl.Glyph;
  import org.kite9.diagram.adl.Key;
  import org.kite9.diagram.adl.KeyHelper;
  import org.kite9.diagram.adl.Link;
  import org.kite9.diagram.adl.LinkEndStyle;
  import org.kite9.diagram.adl.Symbol;
  import org.kite9.diagram.adl.TextLine;
  import org.kite9.diagram.annotation.K9OnDiagram;
  import org.kite9.diagram.builders.Relationship.RelationshipType;
  import org.kite9.diagram.builders.ValueHelper.ToEnd;
  import org.kite9.diagram.position.Direction;
  import org.kite9.diagram.primitives.Connected;
  import org.kite9.diagram.primitives.Contained;
  import org.kite9.diagram.primitives.Container;
  import org.kite9.diagram.primitives.DiagramElement;
  import org.kite9.framework.alias.Aliaser;
  import org.kite9.framework.common.HelpMethods;
  import org.kite9.framework.common.Kite9ProcessingException;
  import org.kite9.framework.model.ProjectModel;
  
  /***
   * Builds a diagram from a method. Each object from the java project may only be
   * represented once in the diagram.
   * 
   * @author robmoffat
   * 
   */
  public class DiagramBuilder {
  
      protected IdHelper idHelper = new IdHelper();
      protected ValueHelper typeHelper = new ValueHelper();
      protected KeyHelper kh = new KeyHelper();
      protected ProjectModel pm;
  
      private Aliaser a;
      private Method creator;
      private Diagram d;
      private Map<Object, DiagramElement> contents = new HashMap<Object, DiagramElement>();
  
      public DiagramBuilder(Aliaser a, Method creator, ProjectModel pm) {
  	this.a = a;
  	this.d = createRepresentation(getId(creator));
  	this.creator = creator;
  	this.pm = pm;
      }
  
      public ProjectModel getProjectModel() {
  	return pm;
      }
  
      public Diagram getDiagram() {
  	addKey();
  	return d;
      }
  
      public Diagram createRepresentation(String id) {
  	return new Diagram(id, new ArrayList<Contained>(), null);
      }
  
      private void addKey() {
  	Collection<Symbol> syms = kh.getUsedSymbols();
  	if (syms.size() > 0) {
  	    List<Symbol> ordered = new ArrayList<Symbol>(syms);
  	    Collections.sort(ordered);
  
  	    if (d.getKey() == null) {
  		Key k = new Key(null, null, ordered);
  		d.setKey(k);
  	    } else {
  		d.getKey().setSymbols(ordered);
  	    }
  
  	}
      }
  
      public DiagramBuilder withKeyText(String boldtext, String body) {
  	Key k = new Key(boldtext, body, null);
  	d.setKey(k);
  	return this;
      }
  
      public String getId(Object o) {
  	return idHelper.getId(o);
      }
  
     private Container getWithin(Object o, Relationship rel) {
 	if (o == null)
 	    return d;
 
 	DiagramElement within = contents.get(o);
 	if (within == null) {
 	    // no context to place the element in, so put in the diagram.
 	    return d;
 	}
 
 	if (rel instanceof HasRelationship) {
 	    if (within instanceof Container) {
 		return (Container) within;
 	    } else if (within instanceof Contained) {
 		return ((Contained) within).getContainer();
 	    } else {
 		throw new Kite9ProcessingException("Cannot find container for " + within);
 	    }
 	} else {
 	    // object must exist outside context
 	    if (within instanceof Contained) {
 		return ((Contained) within).getContainer();
 	    } else {
 		throw new Kite9ProcessingException("Cannot find container for " + within);
 	    }
 	}
     }
 
     /***
      * Looks for an existing diagram element, or returns a new glyph
      */
     private DiagramElement createGlyph(Object withinOb, Relationship rel, Object value, String stereo) {
 	Container within = getWithin(withinOb, rel);
 
 	DiagramElement out = contents.get(value);
 	if (out == null) {
 	    String id = idHelper.getId(value);
 	    String label = a.getObjectAlias(value);
 	    out = new Glyph(id, stereo, label, null, null);
 	    contents.put(value, out);
 	    within.getContents().add((Glyph) out);
 	    ((Glyph) out).setContainer(within);
 	}
 	return out;
     }
 
     private DiagramElement createContext(Object withinOb, Object value, Relationship rel, boolean border, Direction d) {
 	Container within = getWithin(withinOb, rel);
 
 	DiagramElement out = contents.get(value);
 	if (out == null) {
 	    String id = idHelper.getId(value);
 	    String label = a.getObjectAlias(value);
 	    out = new Context(id, null, border, new TextLine(label), d);
 	    contents.put(value, out);
 	    within.getContents().add((Context) out);
 	    ((Context) out).setContainer(within);
 	}
 	return out;
     }
 
     private DiagramElement createArrow(Object withinOb, Object value, Relationship rel) {
 	Container within = getWithin(withinOb, rel);
 
 	DiagramElement out = contents.get(value);
 	if (out == null) {
 	    String id = idHelper.getId(value);
 	    String label = a.getObjectAlias(value);
 	    out = new Arrow(id, label);
 	    contents.put(value, out);
 	    within.getContents().add((Arrow) out);
 	    ((Arrow) out).setContainer(within);
 	}
 	return out;
     }
 
     public Format asGlyphs() {
 	return new Format() {
 	    public void write(Object context, Relationship key, Object value) {
 		ToEnd te = typeHelper.setupToEnd(value, a);
 		DiagramElement ctxEl = contents.get(context);
 		String stereo = a.getObjectTypeAlias(te.to);
 		DiagramElement valueEl = createGlyph(context, key, te.to, stereo);
 		checkAddRelationshipLink((Connected) ctxEl, (Connected) valueEl, key, te, context);
 	    }
 	};
     }
 
     public Format asGlyphs(final String withStereotype) {
 	return new Format() {
 	    public void write(Object context, Relationship key, Object value) {
 		ToEnd te = typeHelper.setupToEnd(value, a);
 		DiagramElement ctxEl = contents.get(context);
 		DiagramElement valueEl = createGlyph(context, key, te.to, withStereotype);
 		checkAddRelationshipLink((Connected) ctxEl, (Connected) valueEl, key, te, context);
 	    }
 	};
     }
 
     public Format asContexts() {
 	return asContexts(true, null);
     }
 
     public Format asContexts(final boolean border, final Direction d) {
 	return new Format() {
 	    public void write(Object context, Relationship key, Object value) {
 		ToEnd te = typeHelper.setupToEnd(value, a);
 		DiagramElement ctxEl = contents.get(context);
 		DiagramElement valueEl = createContext(context, te.to, key, border, d);
 		checkAddRelationshipLink((Connected) ctxEl, (Connected) valueEl, key, te, context);
 	    }
 	};
     }
 
     public Format asArrows() {
 	return new Format() {
 	    public void write(Object context, Relationship key, Object value) {
 		ToEnd te = typeHelper.setupToEnd(value, a);
 		DiagramElement ctxEl = contents.get(context);
 		DiagramElement valueEl = createArrow(context, te.to, key);
 		checkAddRelationshipLink((Connected) ctxEl, (Connected) valueEl, key, te, context);
 	    }
 	};
     }
 
     protected void checkAddRelationshipLink(Connected ctxEl, Connected valueEl, Relationship key, ToEnd te, Object ctx) {
 	if (ctxEl == null) {
 	    // at the diagram level, so no link needed.
 	    return;
 	}
 
 	// if there is containment, a relationship is already implied
 	if ((ctxEl instanceof Container) && (((Container) ctxEl).getContents().contains(valueEl))) {
 	    return;
 	}
 
 	// otherwise, we need to set one up
 	if ((ctxEl instanceof Arrow) && (valueEl instanceof Arrow)) {
 	    throw new Kite9ProcessingException("Can't currently handle connecting two arrows " + ctxEl + " " + valueEl);
 	}
 
 	// check for passive relationships. we need to spin those around
 	if (key.getType() == RelationshipType.PASSIVE) {
 	    key = key.getActiveRelationship();
 	    Connected temp = valueEl;
 	    valueEl = ctxEl;
 	    ctxEl = temp;
 	}
 
 	LinkEndStyle objectEndStyle = key.getType() == RelationshipType.ACTIVE ? LinkEndStyle.ARROW : null;
 
 	String keyAlias = a.getObjectAlias(key);
 	String textPart = typeHelper.generateArrowLabel(te);
 	String alias = keyAlias + ((textPart.length() > 0) ? ": " + textPart : "");
 	if (ctxEl instanceof Arrow) {
 	    if (!ctxEl.isConnectedDirectlyTo(valueEl))
 		new Link(ctxEl, valueEl, null, null, null, new TextLine(alias), null);
 	} else if (valueEl instanceof Arrow) {
 	    if (!ctxEl.isConnectedDirectlyTo(valueEl))
 		new Link(valueEl, ctxEl, null, null, null, new TextLine(alias), null);
 	} else {
 	    // tied stuff
 	    SubjectBinding<Object> t = new SubjectBinding<Object>(ctx, key);
 	    DiagramElement arrowde = createArrow(ctx, t, key);
 	    if (arrowde instanceof Connected) {
 		Connected arrow = (Connected) arrowde;
 		if (!ctxEl.isConnectedDirectlyTo(arrow))
 		    new Link(ctxEl, arrow);
 		if (!arrow.isConnectedDirectlyTo(valueEl))
 		    new Link(arrow, valueEl, null, null, objectEndStyle, new TextLine(textPart), null);
 	    } else {
 		throw new Kite9ProcessingException("Item already exists on diagram, but is not an arrow: " + t);
 	    }
 	}
     }
 
     public Format asTextLines(final boolean keyAsSymbol) {
 	return new Format() {
 	    public void write(Object context, Relationship key, Object value) {
 		DiagramElement conEl = contents.get(context);
 		ToEnd te = typeHelper.setupToEnd(value, a);
 		String alias = a.getObjectAlias(te.to);
 		String fullText = typeHelper.generateTextLineLabel(te, alias);
 		String keyAlias = a.getObjectAlias(key);
 
 		if (conEl instanceof Glyph) {
 		    // add a text line to the glyph
 		    TextLine tl;
 
 		    if (keyAsSymbol) {
 			Symbol out = kh.createSymbol(keyAlias, null);
 			tl = new TextLine(alias, HelpMethods.createList(out));
 		    } else {
 			tl = new TextLine(keyAlias + ": " + fullText, null);
 		    }
 
 		    contents.put(value, tl);
 
 		    ((Glyph) conEl).getText().add(tl);
 		} else if (conEl instanceof TextLine) {
 		    // add further information to the text line
 		    TextLine tl = (TextLine) conEl;
 
 		    String text = tl.getText();
 		    text += ", " + keyAlias + ": " + fullText;
 		    tl.setText(text);
 
 		    contents.put(value, tl);
 		} else {
 		    throw new Kite9ProcessingException("Text line can only be added to existing text lines or glpyhs: "
 			    + conEl);
 		}
 	    }
 	};
     }
 
     public Format asSymbols() {
 	return new Format() {
 
 	    public void write(Object context, Relationship key, Object value) {
 		DiagramElement de = contents.get(context);
 		ToEnd te = typeHelper.setupToEnd(value, a);
 		String alias = a.getObjectAlias(te.to);
 		alias = typeHelper.generateTextLineLabel(te, alias);
 		String keyAlias = a.getObjectAlias(key);
 		Symbol out = kh.createSymbol(keyAlias + ": " + alias, alias);
 		if (de instanceof TextLine) {
 		    ((TextLine) de).getSymbols().add(out);
 		} else if (de instanceof Glyph) {
 		    ((Glyph) de).getSymbols().add(out);
 		} else if (de instanceof Context) {
 		    Context ctx = (Context) de;
 		    if (ctx.getLabel() == null) {
 			ctx.setLabel(new TextLine("", HelpMethods.createList(out)));
 		    } else {
 			((TextLine) ctx.getLabel()).getSymbols().add(out);
 		    }
 		} else {
 		    throw new Kite9ProcessingException("No glyph/text line/context to add the symbol to");
 		}
 	    }
 
 	};
     }
 
     public ClassBuilder withClasses(Class<?>... forClasses) {
 	List<Tie<? extends Object, Class<?>>> ties = new ArrayList<Tie<? extends Object, Class<?>>>(forClasses.length);
 	for (Class<?> c : forClasses) {
 	    ties.add(new Tie<Object, Class<?>>(null, null, c));
 	}
 	ClassBuilder ch = new ClassBuilder(ties, pm);
 	return ch;
     }
 
     public PackageBuilder withPackages(Package... packages) {
 	List<Tie<? extends Object, Package>> ties = new ArrayList<Tie<? extends Object, Package>>(packages.length);
 	for (Package p : packages) {
 	    ties.add(new Tie<Object, Package>(null, null, p));
 	}
 	PackageBuilder ch = new PackageBuilder(ties, pm);
 	return ch;
     }
 
     public PackageBuilder withPackages(Class<?>... packagesForClasses) {
 	List<Tie<? extends Object, Package>> ties = new ArrayList<Tie<? extends Object, Package>>(
 		packagesForClasses.length);
 	for (Class<?> c : packagesForClasses) {
 	    ties.add(new Tie<Object, Package>(null, null, c.getPackage()));
 	}
 	PackageBuilder ch = new PackageBuilder(ties, pm);
 	return ch;
     }
 
     /***
      * Filters methods, fields, inner classes to just the ones with a K9
      * annotation.
      */
     public Filter<AnnotatedElement> onlyAnnotated() {
 	return new Filter<AnnotatedElement>() {
 	    public boolean accept(AnnotatedElement o) {
 		K9OnDiagram on = null;
 		if (o instanceof AnnotatedElement) {
 		    AnnotatedElement ae = (AnnotatedElement) o;
 		    on = ae.getAnnotation(K9OnDiagram.class);
 		}
 
 		if (on != null) {
 		    if ((on.on().length == 0))
 			return true;
 
 		    for (Class<?> on1 : on.on()) {
 			if (on1.equals(creator.getDeclaringClass())) {
 			    return true;
 			}
 		    }
 		}
 
 		return false;
 	    }
 	};
     }
 
     /***
      * Filters classes to just the ones mentioned in the arguments
      */
     public Filter<Class<?>> only(final Class<?>... classes) {
 	return new Filter<Class<?>>() {
 
 	    public boolean accept(Class<?> o) {
 		for (Class<?> class1 : classes) {
 		    if (class1.equals(o))
 			return true;
 		}
 
 		return false;
 	    }
 	};
     }
 }