package org.simantics.xml.sax;

import java.io.FileNotFoundException;
import java.io.PrintWriter;
import java.io.StringWriter;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Set;

import javax.xml.namespace.QName;

import org.simantics.utils.datastructures.BijectionMap;
import org.simantics.xml.sax.SchemaConversionBase.Inheritance;
import org.simantics.xml.sax.SchemaConversionBase.RefType;
import org.simantics.xml.sax.SchemaObject.ObjectType;
import org.simantics.xml.sax.configuration.AttributeComposition;
import org.simantics.xml.sax.configuration.IDReference;
import org.w3._2001.xmlschema.Annotated;
import org.w3._2001.xmlschema.Attribute;
import org.w3._2001.xmlschema.AttributeGroup;
import org.w3._2001.xmlschema.Element;
import org.w3._2001.xmlschema.LocalComplexType;
import org.w3._2001.xmlschema.LocalSimpleType;
import org.w3._2001.xmlschema.NamedAttributeGroup;
import org.w3._2001.xmlschema.NamedGroup;
import org.w3._2001.xmlschema.Schema;
import org.w3._2001.xmlschema.SimpleType;

//public class OntologyGenerator extends SchemaConversionBase {
public class OntologyGenerator implements SchemaConversionComponent {
	SchemaConversionBase base;
	
	public OntologyGenerator(SchemaConverter converter, SchemaConversionBase base) {
		this.base = base;
		this.converter = converter;
		this.schema = base.schema;
		this.ontologyUri = base.ontologyURI;
		this.className = base.className;		
	}

	String ontRoot = "ONT.";
	String commentTag = "//";
	
	Schema schema;
	String ontologyUri;
	String className;
	
	SchemaConverter converter;
	
	PrintWriter writer = null;
	
	public void createOntology() throws FileNotFoundException {
		StringWriter stringWriter = null;
		if (converter.getOntologyFile() == null) {
			stringWriter = new StringWriter();
			writer = new PrintWriter(stringWriter);
		} else {
			writer = new PrintWriter(converter.getOntologyFile());
		}
	
		handle();
		
		writer.flush();
		writer.close();
		if (stringWriter != null)
			System.out.println(stringWriter.toString());
	}
	
	protected void handle() {
		ontRoot = converter.shortName;

		for (String s : converter.getHeader()) {
			writer.println(commentTag + " " + s);	
		}
		writer.println();
		writer.println("L0 = <http://www.simantics.org/Layer0-1.1>");
		writer.println("XML = <http://www.simantics.org/XML-1.0>");
		writer.println();
		if (converter.isPrimary()) {
		writer.println(ontRoot + " = <" + ontologyUri +"> : L0.Ontology");
		writer.println("   @L0.new");
		writer.println("   L0.HasResourceClass \"" + className +"\"");
		} else {
		writer.println(ontRoot + " = <" + ontologyUri +">");
		}
		writer.println();
		writer.println();
		
		ontRoot += ".";
		writer.println(ontRoot+"SimpleTypes : L0.Library");
		writer.println(ontRoot+"ComplexTypes : L0.Library");
		writer.println(ontRoot+"AttributeGroups : L0.Library");
		writer.println();
		writer.println(commentTag + " Interpreted from schema");
		writer.println();
			
		base.handle(this);
	}
		
	protected String getType(QName qtype, String rel) {
		String ontType = base.getL0TypeFromPrimitiveType(qtype);
		if (ontType != null)
			return ontType;
		else {
			if (base.isComplexTypeRef(qtype.getLocalPart()))
				return getName(base.getComplexType(qtype), rel);
			else if (base.isSimpleTypeRef(qtype.getLocalPart()))
				return getName(base.getSimpleType(qtype), rel);
			else if (base.isElementRef(qtype.getLocalPart()))
				return getName(base.getElement(qtype), rel);
		}
		throw new RuntimeException("Reference to unknown type " + qtype.getLocalPart());
	}
	
	public String getSimpleTypePrefix() {
		return "SimpleTypes.";
	}
	
	public String getComplexTypePrefix() {
		return "ComplexTypes.";
	}
	
	public String getAttributeGroupPrefix() {
		return "AttributeGroups.";
	}
	
	public String handleChoice(SchemaObject parent, SchemaElement indicator, java.util.List<SchemaElement> elements, String name) {
		boolean single = true;
		for (SchemaElement e : elements) {
			if (e.getRestriction().many()) {
				single = false;
				break;
			}
		}
		String relationName = getName(parent)+".has"+name;
		writer.print(relationName);
		writer.print(" <R XML.hasElement");
		writer.println();
		
		if (!single) {
			String elementListType = getName(parent) + "." + name + "_List";
			writer.println(elementListType + " <T XML.ElementList");
			writer.println(relationName + "_List <R XML.hasElementList : L0.FunctionalRelation");
			writer.println("   --> " + elementListType);
		}
		
		return relationName;
	};
	
	
	
	@Override
	public void handleIndicator(SchemaObject parent, SchemaElement indicator, SchemaElement element, String refName, RefType refType, String baseRelationName) {
		if (refType != RefType.Element) {
			QName referenceType = null;
			if (refType == RefType.Type) {
				referenceType = element.getElement().getType();
				//refName = element.getElement().getName()
				SchemaObject eObj = base.getElement(element.getElement());//base.elements.get(element.getElement());
				if (refName == null)
					refName = eObj.getName();
			} else {
				referenceType = element.getElement().getRef();
				if (refName == null)
					refName = referenceType.getLocalPart();
			}
			String type = base.getL0TypeFromPrimitiveType(referenceType);
			SchemaObject obj = null;
			if (type == null) {
				obj = base.getWithName(referenceType);
				writer.print(getName(parent)+".has"+refName + " <R XML.hasElement <R " +  getName(obj,"has"));
				if (baseRelationName != null) writer.print(" <R " + baseRelationName);
				writer.println();
			} else {
				writer.print(getName(parent)+".has"+refName + " <R XML.hasElement");
				if (baseRelationName != null) writer.print(" <R " + baseRelationName);
				writer.println();
				writer.println("   --> " + getType(referenceType, ""));
			}
			
			if (base.useElementList(parent, indicator,element, refType == RefType.Reference, refName, referenceType)) {
				
				if (type == null) {
					writer.println(getName(parent)+"."+refName + "List <T XML.ElementList");
					writer.println(getName(parent)+".has"+refName + "_List <R " +  getName(obj,"has")+"_List : L0.FunctionalRelation");
				} else {
					writer.println(getName(parent)+"."+refName + "_List <T XML.ElementList");
					writer.println(getName(parent)+".has"+refName + "_List <R XML.hasElementList : L0.FunctionalRelation");	
				}
			}
		} else {
			Element attrs = element.getElement();
			SchemaObject obj = base.getWithObj(parent, attrs);
			if (refName == null)
				refName = obj.getName();
			
			writer.print(getName(parent)+".has"+refName + " <R " + getName(obj,"has"));
			if (baseRelationName != null) writer.print(" <R " + baseRelationName);
			writer.println();
			writer.println("   --> " + getName(obj));
			if (base.useElementList(parent, indicator,element, false, refName, new QName(obj.getName()))) {
				writer.println(getName(parent)+"."+refName + "_List <T XML.ElementList");
				writer.println(getName(parent)+".has"+refName + "_List <R " +  getName(obj,"has")+"_List : L0.FunctionalRelation");
			}
		}
		
	}
	
	@Override
	public void handleIndicator(SchemaObject parent, SchemaElement indicator, SchemaElement any) {
		
	}
	
	@Override
	public void handle(SchemaObject parent, NamedGroup attribute) {
		// TODO Auto-generated method stub
		
	}
		
	@Override
	public void handle(SchemaObject parent, Attribute attribute) {
		String name = attribute.getName();
		QName primitiveType = attribute.getType();
		LocalSimpleType simpleType = attribute.getSimpleType();
		QName ref = attribute.getRef();
		
		String relationName;
		String relationType;
		if (name != null) {
			relationName = ontRoot+"has"+name;
			if (parent != null)
				relationName = getName(parent)+".has"+name;
			relationType = "XML.hasAttribute";
		}
		else if (ref != null && parent != null) {
			relationName = getName(parent)+".has"+ref.getLocalPart();
			relationType = ontRoot+"has"+ref.getLocalPart();
		} else {
			throw new RuntimeException();
		}
		boolean id = false;
		String ontType = null;
		if (primitiveType != null) {
			ontType = base.getL0TypeFromPrimitiveType(primitiveType);
			if (ontType != null) {
				id = base.getTypeEntry(primitiveType).id;
				if (id)
					relationType = "XML.hasID";
			} else {
				
			}
		} else if (simpleType != null){
//			Restriction restriction = simpleType.getRestriction();
//			if (restriction == null || simpleType.getUnion() != null || simpleType.getName() != null || simpleType.getId() != null)
//				throw new RuntimeException();
//			QName base = restriction.getBase();
			QName base = this.base.getSimpleTypeBase(simpleType);
			
			
			ontType = this.base.getL0TypeFromPrimitiveType(base);
			
//			for (Object facetWrap : restriction.getFacets()) {
//				JAXBElement<?> element = (JAXBElement<?>)facetWrap;
//				QName elementName = element.getName();
//				Facet facet = (Facet)element.getValue();	
//			}
		}
			
		
		
		writer.println(relationName+ " <R " + relationType + ": L0.FunctionalRelation");
		if (id) {
			// no need to add range restriction
		} else if (ontType != null) {
			writer.println("   --> " + ontType);
		} else if (primitiveType != null) {
			writer.println("   <R " + getType(primitiveType, "has"));
		}
	}
	
	@Override
	public void handleAttributes(SchemaObject simpleTypeObj) {
//		SchemaObject parent = simpleTypeObj.getParent();
//		SimpleType simpleType = simpleTypeObj.getSimpleType();
//		Restriction restriction = simpleType.getRestriction();
//		QName base = restriction.getBase();
//		String ontType = getL0TypeFromPrimitiveType(base);
	}
	
	@Override
	public void handle(SchemaObject parent, AttributeGroup attributeGroup) {
		if (parent == null) {
			NamedAttributeGroup group = (NamedAttributeGroup)attributeGroup;
			writer.println(ontRoot+getAttributeGroupPrefix()+group.getName()+ " <T XML.AttributeGroup");
			SchemaObject obj = new SchemaObject(parent,attributeGroup);
			for (Annotated annotated : group.getAttributeOrAttributeGroup()) {
				if (annotated instanceof Attribute) {
					//handle(getAttributeGroupPrefix()+group.getName(),(Attribute)annotated);
					handle(obj,(Attribute)annotated);
				} else if (annotated instanceof AttributeGroup) {
					handle(obj,(AttributeGroup)annotated);
					//throw new RuntimeException("Cannot handle nested attribute groups");
				}
			}
		} else {
			writer.println(getName(parent) +" L0.Inherits " + ontRoot + getAttributeGroupPrefix() + attributeGroup.getRef().getLocalPart());
		}
		
	}
	
	@Override
	public void handleAttributeComposition(SchemaObject parent, AttributeComposition composition, BijectionMap<org.simantics.xml.sax.configuration.Attribute, Annotated> attributes) {
		Attribute compositionAttribute = new Attribute();
		compositionAttribute.setName(composition.getName());
		QName type = new QName(SchemaConversionBase.CONVERSION_NS, composition.getType());
		compositionAttribute.setType(type);
		handle(parent, compositionAttribute);
	}
	
	@Override
	public void handleSimpleType(SchemaObject parent, SchemaObject simpleTypeObj) {
		SimpleType simpleType = simpleTypeObj.getSimpleType();
		String name = simpleType.getName();
		
		org.w3._2001.xmlschema.List list = simpleType.getList();
		if (list != null) {
			// TODO : process restriction in lists
			String relationName = getName(simpleTypeObj, "has");
			writer.println(relationName+ " <R XML.hasAttribute : L0.FunctionalRelation");
			
			String ontType = base.getL0Type(new QName(SchemaConversionBase.SCHEMA_NS, "string"));
			writer.println("   --> " + ontType);
		} else {
			QName base = this.base.getSimpleTypeBase(simpleType);
			writer.println(getName(simpleTypeObj) + " <T " + getType(base, ""));
			
			String relationName = getName(simpleTypeObj, "has");
			
			writer.println(relationName+ " : L0.FunctionalRelation");
			writer.println("   --> " + getName(simpleTypeObj));
			
//			Restriction restriction = simpleType.getRestriction();
//			if (restriction != null) {
//				
//				QName base = restriction.getBase();
//				String ontType = getL0Type(base);
//				writer.println("   --> " + ontType);
//			} else if (simpleType.getId() != null) {
//				throw new RuntimeException(simpleType.getName() + " restriction error");
//			} else if (simpleType.getUnion() != null) {
//				Union union = simpleType.getUnion();
//				String ontType = null;
//				if (union.getMemberTypes().size() > 0) {
//					for (QName type : union.getMemberTypes()) {
//						String sType = null;
//						TypeEntry entry = getTypeEntry(type);
//						if (entry == null) {
//							SchemaObject obj = simpleTypeName.get(type.getLocalPart());
//							Inheritance inheritance = new Inheritance("");
//							getAtomicTypeInheritance(type, obj, inheritance);
//							sType = inheritance.atomicType.l0Type;
//						} else {
//							sType = entry.l0Type;
//						}
//						if (ontType == null)
//							ontType = sType;
//						else if (!ontType.equals(sType))
//							throw new RuntimeException(simpleType.getName() + " union has incompatible member types");
//					}
//				} else {
//					if (union.getSimpleType().size() == 0)
//						throw new RuntimeException(simpleType.getName() + " union error");
//					for (SimpleType s : union.getSimpleType()) {
//						if (restriction == null)
//							restriction = s.getRestriction();
//						else  {
//							Restriction r = s.getRestriction();
//							if (!r.getBase().equals(restriction.getBase()))
//								throw new RuntimeException(simpleType.getName() + " union has incompatible restriction bases");
//						}
//					}
//					QName base = restriction.getBase();
//					ontType = getL0Type(base);
//				}
//				writer.println("   --> " + ontType);
//			} else {
//				throw new RuntimeException(simpleType.getName() + " restriction error");
//			}
			
		}
	}
	
	@Override
	public void handleComplexType(SchemaObject topLevelComplexType) {
		String name = getName(topLevelComplexType);
//		if (topLevelComplexType.getName().equals("Reference"))
//			System.out.println();
		
//		String baseType = "XML.ComplexType";
//
//		QName base = getComplexTypeBase(topLevelComplexType.getComplexType());
//		if (base != null) {
//			baseType = getType(base);
//		}
//		base = getSimpleTypeBase(topLevelComplexType.getSimpleType());
//		if (base != null) {
//			baseType = getType(base);
//		}
		Inheritance inheritance = base.getInheritance(topLevelComplexType);
		
//		writer.println(name+ " <T "+baseType);
		
		// Type definition
		if (inheritance.additionalClass != null) {
		writer.println(name+ " <T " + inheritance.baseClass + " <T " + inheritance.additionalClass);
	    } else if (inheritance.atomicType != null){
	    writer.println(name+ " <T " + inheritance.baseClass + " <T " + inheritance.atomicType.l0Type);
	    } else {
		writer.println(name+ " <T " + inheritance.baseClass);
		}
		writer.println(name + "_List <T XML.ElementList");
		
		// Access relations
		String relationName = getName(topLevelComplexType,"has");
		writer.println(relationName+ " <R XML.hasComplexType");
		writer.println("   --> " + name);
		writer.println(relationName+ "_List <R XML.hasElementList");
		writer.println("   --> " + name + "_List");
		writer.println();
		
		// Attributes 
//		if (!baseType.equals(inheritance.baseClass))
//			System.out.println();
		//super.handleComplexType(topLevelComplexType);
		base.handleComplexTypeAttributes(topLevelComplexType);
		base.handleComplexTypeExtension(topLevelComplexType);
		base.handleExtensionAttributes(topLevelComplexType);
		writer.println();
	}
	
	@Override
	public void handleElement(SchemaObject elementObj) {
		Element element = elementObj.getElement();
		String name = getName(elementObj);//element.getName();
		
		if ("Text".equals(name))
			System.out.println();
		
		String type = "XML.Element";
		Set<String> types = new LinkedHashSet<String>();
		if (element.getType() != null) {
			types.add(getType(element.getType(), ""));
		}
		QName base = this.base.getElementBase(element);
		if (base != null) {
			if (base.getNamespaceURI().equals(SchemaConversionBase.SCHEMA_NS)) {
				String l0Type = this.base.getL0Type(base);
				if (l0Type == null)
					throw new RuntimeException("Cannot get L0 type for " + base.getLocalPart());
				types.add(l0Type);
			} else if (this.base.isElementRef(base.getLocalPart()))
				types.add(ontRoot+base.getLocalPart());
			else
				types.add(ontRoot+getComplexTypePrefix()+base.getLocalPart());
		}
		QName substitution = element.getSubstitutionGroup();
		if (substitution != null) {
			if (this.base.isElementRef(substitution.getLocalPart()))
				types.add(ontRoot+substitution.getLocalPart());
			else
				types.add( ontRoot+getComplexTypePrefix()+substitution.getLocalPart());
		}
		for (String t : types) {
			type += " <T " + t;
		}

		String relationName =  getName(elementObj,"has");//ontRoot+"has"+name;
//		if (elementObj.getParent() != null) {
//			//relationName = ontRoot+getComplexTypePrefix()+"has"+name.substring(getComplexTypePrefix().length());
//			relationName = ontRoot+getName(elementObj.getParent()) + "has"+element.getName();
//		}
		writer.println(relationName+ " <R XML.hasElement");
		writer.println(relationName+ "_List <R XML.hasElementList");
		
		writer.println(name+ " <T "+type);
		
		LocalComplexType complexType = element.getComplexType();
		LocalSimpleType simpleType = element.getSimpleType();
		
		if (complexType != null) {
			SchemaObject complexTypeObj = this.base.getComplexType(complexType);
			this.base.handleElementComplexTypeAttributes(complexTypeObj);
			this.base.handleComplexTypeExtension(complexTypeObj);
		} else if (simpleType != null) {
			SchemaObject simpleTypeObj = this.base.getSimpleType(simpleType);
			this.base.handleElementSimpleTypeAttributes(simpleTypeObj);
		}
		
		List<IDReference> references = this.base.getIDReferences(element);
	
		for (IDReference ref : references) {
			writer.println(name+"."+ref.getReference().getName()+ " <R XML.hasReference");
		}
		
		writer.println();
	}
	
	@Override
	public String getBaseClass(ObjectType type) {
		if (type == ObjectType.ELEMENT)
			return "XML.Element";
		if (type == ObjectType.COMPLEX_TYPE)
			return "XML.ComplexType";
		throw new RuntimeException("ObjectType " + type + " has no base class");
	}
	
	@Override
	public String getName(SchemaObject obj) {
		if (obj.getParent() == null) {
			switch (obj.getType()) {
			case COMPLEX_TYPE:
				return ontRoot+getComplexTypePrefix()+obj.getName();
			case ELEMENT:
				return ontRoot+obj.getName();
			case ATTRIBUTE_GROUP:
				return ontRoot+getAttributeGroupPrefix()+obj.getName();
			case SIMPLE_TYPE:
				return ontRoot+getSimpleTypePrefix()+obj.getName();
			}
		} else {
			SchemaObject o = obj;
			SchemaObject prev = null;
			String name = "";
			while (o != null){
				if (o.getName() != null)
					name = o.getName()+"."+name;
				prev = o;
				o = o.getParent();
			}
			name = name.substring(0, name.length()-1);
			switch (prev.getType()) {
			case COMPLEX_TYPE:
				return ontRoot+getComplexTypePrefix()+name;
			case ELEMENT:
				return ontRoot+name;
			case ATTRIBUTE_GROUP:
				return ontRoot+getAttributeGroupPrefix()+name;
			case SIMPLE_TYPE:
				return ontRoot+getSimpleTypePrefix()+name;
			}
		}
		throw new RuntimeException();
		
	}
	
	public String getName(SchemaObject parent, SchemaElement e, String rel) {
		QName ref = e.getElement().getRef();
		if (ref != null) {
			return converter.getShortName(ref.getNamespaceURI()) + rel + ref.getLocalPart();
		}
		else {
			return getName(parent, "") + "." + rel + e.getElement().getName();
		}
	}
	
	public String getName(SchemaObject obj, String rel) {
		if (obj.getParent() == null) {
			switch (obj.getType()) {
			case COMPLEX_TYPE:
				return ontRoot+getComplexTypePrefix()+rel+obj.getName();
			case ELEMENT:
				return ontRoot+rel+obj.getName();
			case ATTRIBUTE_GROUP:
				return ontRoot+getAttributeGroupPrefix()+rel+obj.getName();
			case SIMPLE_TYPE:
				return ontRoot+getSimpleTypePrefix()+rel+obj.getName();
			}
		} else {
			SchemaObject o = obj;
			SchemaObject prev = null;
			String name = "";
			while (o != null){
				if (o.getName() != null)
					name = o.getName()+"."+name;
				prev = o;
				o = o.getParent();
			}
			name = name.substring(0, name.length()-1);
			switch (prev.getType()) {
			case COMPLEX_TYPE:
				return ontRoot+getComplexTypePrefix()+rel+name;
			case ELEMENT:
				return ontRoot+rel+name;
			case ATTRIBUTE_GROUP:
				return ontRoot+getAttributeGroupPrefix()+rel+name;
			case SIMPLE_TYPE:
				return ontRoot+getSimpleTypePrefix()+rel+name;
			}
		}
		throw new RuntimeException();
		
	}
	
	
}