package org.simantics.xml.sax;

import java.io.File;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import javax.xml.namespace.QName;

import org.simantics.xml.sax.SchemaConversionBase.RefType;
import org.simantics.xml.sax.SchemaConversionBase.TypeEntry;
import org.w3._2001.xmlschema.AttributeGroupRef;
import org.w3._2001.xmlschema.Element;
import org.w3._2001.xmlschema.Schema;

//public abstract class JavaGenerator extends SchemaConversionBase{
public abstract class JavaGenerator implements SchemaConversionComponent {

	String commentTag = "//";
	
	Schema schema;
	String ontologyClassName;
	String ontologyUri;
	SchemaConverter converter;
	SchemaConversionBase base;
	
	List<String> ruleClassNames = new ArrayList<String>();
	
	String ontShort = "ONT"; 
	String name;
	
	File importParserDir;
	String elementPackageName;
	
	Map<SchemaObject, FileWriter> writers = new HashMap<SchemaObject, ImporterGenerator.FileWriter>();
	
	public JavaGenerator(SchemaConverter converter, SchemaConversionBase base) {
		this.converter = converter;
		this.base = base;
		
		this.schema = base.schema;
		this.ontologyClassName = base.className;
		this.ontologyUri = base.ontologyURI;
		this.converter = converter;
		this.name = converter.name;
		ontShort = converter.shortName;
		ontShort +=".";
	}
	
	
	protected PrintWriter createFile(File file) throws IOException {
		if (!file.exists())
			file.createNewFile();
		PrintWriter writer = new PrintWriter(file);
		for (String s : converter.getHeader()) {
			writer.println(commentTag + " " + s);	
		}
		writer.println();
		return writer;
	}
	
	protected String getValueGetterMethod(TypeEntry binding,String name) {
		if (binding == null)
			return name+".getValue()";
		return binding.getValueGetterMethod(name);
	}
	
	protected String getValueGetter(TypeEntry binding,String name) {
		if (binding == null)
			return name;
		return binding.getValueGetter(name);
	}
	
	protected String getValueGetter(TypeEntry binding) {
		if (binding == null)
			return "value";
		return binding.getValueGetter();
	}
	
	@Override
	public String getComplexTypePrefix() {
		return "ComplexTypes_";
	}	
	
	@Override
	public String getAttributeGroupPrefix() {
		return "AttributeGroups_";
	}
	
	@Override
	public void handleChoice(SchemaObject parent, SchemaElement indicator, List<SchemaElement> elements, String name) {

		for (SchemaElement e : elements) {
			Element localElement = e.getElement();
			if (localElement.getName() != null) {
				QName refType = localElement.getType();
				if (refType != null)
					//handleIndicator(parent, indicator, e, false, name, refType);
					handleIndicator(parent, indicator, e, name, RefType.Type);
			} else if (localElement.getRef() != null) {
				//QName refType = localElement.getRef();
				//handleIndicator(parent, indicator, e, true, name, refType);
				handleIndicator(parent, indicator, e, name, RefType.Reference);
			}
		}
		
	}
	
	protected String getOntologyImport() {
		return this.ontologyClassName+" " +ontShort.substring(0, 3)+" = "+this.ontologyClassName+".getInstance(graph);";
	}
	
	protected static class FileWriter {
		public PrintWriter writer;
		
		public PrintWriter delayedWriter;
		public PrintWriter delayedWriter2;
	}
	
	protected  FileWriter getWriter(SchemaObject obj) {
		SchemaObject s = obj;
		while (s != null) {
			FileWriter fw = writers.get(s);
			if (fw != null)
				return fw;
			s = s.getParent();
		}
		return null;
	}
	
	@Override
	public String getName(SchemaObject obj) {
		if (obj.getParent() == null) {
			switch (obj.getType()) {
			case COMPLEX_TYPE:
				return getComplexTypePrefix()+obj.getName();
			case ELEMENT:
				return obj.getName();
			case ATTRIBUTE_GROUP:
				return getAttributeGroupPrefix()+obj.getName();
			case SIMPLE_TYPE:
				return 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();
				if (prev.getObj() instanceof AttributeGroupRef)
					o = null;
			}
			name = name.substring(0, name.length()-1);
			switch (prev.getType()) {
			case COMPLEX_TYPE:
				return getComplexTypePrefix()+name;
			case ELEMENT:
				return name;
			case ATTRIBUTE_GROUP:
				return getAttributeGroupPrefix()+name;
			case SIMPLE_TYPE:
				return name;
			}
		}
		throw new RuntimeException();
		
	}
	
	public String getName(SchemaObject obj, String rel) {
		if (obj.getParent() == null) {
			switch (obj.getType()) {
			case COMPLEX_TYPE:
				return getComplexTypePrefix()+rel+obj.getName();
			case ELEMENT:
				return rel+obj.getName();
			case ATTRIBUTE_GROUP:
				return getAttributeGroupPrefix()+rel+obj.getName();
			case SIMPLE_TYPE:
				return 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 getComplexTypePrefix()+rel+name;
			case ELEMENT:
				return rel+name;
			case ATTRIBUTE_GROUP:
				return getAttributeGroupPrefix()+rel+name;
			case SIMPLE_TYPE:
				return rel+name;
			}
		}
		throw new RuntimeException();
	}
	
	
	
	protected void writeClass(PrintWriter writer,boolean abst, String elementId, String className, String baseClass, List<String> interfaces) {
		writer.println("@SuppressWarnings(\"unused\")");
		writer.print("public " +(abst ? "abstract " : "") + "class " + className + " extends "+baseClass);
		if (interfaces.size() > 0) {
			writer.print(" implements ");
			for (int i = 0; i < interfaces.size(); i++) {
				writer.print(interfaces.get(i));
				if (i < interfaces.size() -1 )
					writer.print(",");
			}
		}
		writer.println("{");
		writer.println();
		writer.println("   @Override");
		writer.println("   public java.lang.String getElementId() {");
		if (elementId != null)
		writer.println("      return \""+elementId+"\";");
		else // complex types cannot be parsed directly with name/id reference.
		writer.println("      return null;");
		writer.println("   }");
		writer.println();
	}
	
	
	protected abstract void createReferenceIndicator(SchemaObject parent, RefType referenceType, String refName, String objectName, String primaryClassName, String secondaryClassName, boolean useElementList, boolean useOriginalList);
	protected abstract void createPrimitiveIndicator(SchemaObject parent, String refName, String binding);
	protected abstract void createElementIndicator(SchemaObject parent, boolean useElementList, String refName, String className, boolean useOriginalList);
	
	@Override
	public void handleIndicator(SchemaObject parent, SchemaElement indicator, SchemaElement element, String refName, RefType referenceType) {
		String objectName;
		if (referenceType != RefType.Element) {
			QName refType;
			if (referenceType == RefType.Type) {
				refType = element.getElement().getType();
				if (refName == null)
					refName = element.getElement().getName();
				objectName = element.getElement().getName();
			} else {
				refType = element.getElement().getRef();
				if (refName == null)
					refName = refType.getLocalPart();
				objectName = refType.getLocalPart();
			}
			
			String binding = this.base.getBindingFromPrimitiveType(refType);
			if (binding == null) {
				SchemaObject refElement = this.base.elementName.get(refType.getLocalPart());
				SchemaObject refComplexType = this.base.complexTypeName.get(refType.getLocalPart());
	
				// prefer element reference over complex type reference
				String primaryClassName = null;
				String secondaryClassName = null;
				if (refElement != null)
					primaryClassName = getName(refElement);
				else
					primaryClassName = getName(refComplexType);
				
				if (refComplexType != null) {
					secondaryClassName = getName(refComplexType);
				} else {
					secondaryClassName = getName(refElement);
				}
				boolean useElementList = this.base.useElementList(parent, indicator,element, referenceType == RefType.Reference, refName, refType);
				boolean useOriginalList = this.base.useOriginalList(parent, indicator,element, referenceType == RefType.Reference, refName, refType);
				createReferenceIndicator(parent, referenceType, refName, objectName, primaryClassName, secondaryClassName, useElementList, useOriginalList);
			} else {
				createPrimitiveIndicator(parent, refName, binding);
			}
		} else {
			Element attrs= element.getElement();
			SchemaObject obj = this.base.getWithObj(parent, attrs);
			
			String className = getName(obj);
			if (refName == null)
				refName = attrs.getName();
			
			boolean useElementList = this.base.useElementList(parent, indicator,element, false, refName, new QName(obj.getName()));
			boolean useOriginalList = this.base.useOriginalList(parent, indicator,element, false, refName, new QName(obj.getName()));
			createElementIndicator(parent, useElementList, refName, className, useOriginalList);
		}
	}

}