/*

  * Copyright (c) 2006-2007 David Holroyd

  */

 package uk.co.badgersinfoil.asxsd;

 import java.util.HashMap;

 import java.util.Iterator;

 import java.util.List;

 import java.util.Map;

 import org.eclipse.xsd.XSDComplexTypeDefinition;

 import org.eclipse.xsd.XSDElementDeclaration;

 import org.eclipse.xsd.XSDNamedComponent;

 import org.eclipse.xsd.XSDSchema;

 import org.eclipse.xsd.XSDSimpleTypeDefinition;

 import org.eclipse.xsd.XSDTypeDefinition;

 import uk.co.badgersinfoil.metaas.ActionScriptProject;

 import uk.co.badgersinfoil.metaas.ActionScriptFactory;

 import uk.co.badgersinfoil.metaas.dom.ASClassType;

 import uk.co.badgersinfoil.metaas.dom.ASCompilationUnit;

 import uk.co.badgersinfoil.metaas.dom.ASConstants;

 import uk.co.badgersinfoil.metaas.dom.ASField;

 import uk.co.badgersinfoil.metaas.dom.ASMethod;

 import uk.co.badgersinfoil.metaas.dom.Visibility;

 public class MarshalBuilder {

         static final String KEY_MARSHAL_CURRENT_METHOD_CODE = "uk.co.badgersinfoil.asxsd.marshal.currentMethod.code";

         static final String KEY_MARSHAL_CURRENT_SOURCE_EXPR = "uk.co.badgersinfoil.asxsd.marshal.currentSource.expr";

         static final String KEY_MARSHAL_CURRENT_TARGET_PARENTELEMENT_EXPR = "uk.co.badgersinfoil.asxsd.marshal.currentTargetParentElement.expr";

         private Map converterClassesByNamespace = new HashMap();

         private ActionScriptProject project;

         private CodegenContext context;

         public MarshalBuilder(ActionScriptProject project, CodegenContext context) {

                 this.project = project;

                 this.context = context;

         }

         public void processSchema(XSDSchema schema) {

                 List types = schema.getTypeDefinitions();

                 context.pushAttrScope();

                 context.setCurrentRole(CodegenRole.MARSHAL);

                 for (Iterator i = types.iterator(); i.hasNext(); ) {

                         XSDTypeDefinition typeDef = (XSDTypeDefinition)i.next();

                         if (typeDef instanceof XSDComplexTypeDefinition) {

                                 XSDComplexTypeDefinition ctype = (XSDComplexTypeDefinition)typeDef;

 //                                conversionMethodFor(ctype);

                                 context.functionFor(ctype);

                         }

                 }

 //                List elements = schema.getElementDeclarations();

 //                for (Iterator i = elements.iterator(); i.hasNext(); ) {

 //                        XSDElementDeclaration elementDecl = (XSDElementDeclaration)i.next();

 //                        conversionMethodFor(elementDecl);

 //                }

                 context.popAttrScope();

         }

         public void buildMethodParams(ASMethod meth, XSDElementDeclaration elementDecl) {

                 TypeDescriptor typeDesc = context.typeDescriptorFor(elementDecl);

                 if (elementDecl.getType() instanceof XSDComplexTypeDefinition) {

                         meth.addParam("thisObject", typeDesc.getTypeName());

                 } else {

                         meth.addParam("thisValue", typeDesc.getTypeName());

                 }

         }

         public void buildMethodParams(ASMethod meth, XSDTypeDefinition typeDef) {

                 TypeDescriptor typeDesc = context.typeDescriptorFor(typeDef);

                 if (typeDef instanceof XSDComplexTypeDefinition) {

                         meth.addParam("_result", "XML");

                         meth.addParam("thisObject", typeDesc.getTypeName());

                 } else {

                         meth.addParam("thisValue", typeDesc.getTypeName());

                 }

         }

         public String methodNameFor(XSDTypeDefinition typeDef) {

                 String stub;

                 if (XSDUtils.isAnonymous(typeDef)) {

                         XSDNamedComponent container = (XSDNamedComponent)typeDef.getContainer();

                         stub = container.getName();

                 } else {

                         stub = typeDef.getName();

                 }

                 return "marshal" + StringUtils.sanitize(stub);

         }

         public String methodNameFor(XSDElementDeclaration elementDecl) {

                 String name = StringUtils.sanitize(elementDecl.getName());

                 return "marshal" + name;

         }

         public static String xmlReturnTypeFor(XSDTypeDefinition typeDef) {

                 if (typeDef instanceof XSDComplexTypeDefinition) {

                         return "XML";

                 }

                 if (typeDef instanceof XSDSimpleTypeDefinition) {

                         return ASConstants.TYPE_STRING;

                 }

                 throw new IllegalArgumentException(typeDef.getClass().getName());

         }

         public ASCompilationUnit getClassForNamespace(String namespace) {

                 ASCompilationUnit result = (ASCompilationUnit)converterClassesByNamespace.get(namespace);

                 if (result == null) {

                         result = createClassForNamespace(namespace);

                         converterClassesByNamespace.put(namespace, result);

                 }

                 return result;

         }

         private ASCompilationUnit createClassForNamespace(String namespace) {

                 ASCompilationUnit cu = project.newClass((StringUtils.toPackageName(namespace)+".Marshaler"));

                 ASClassType clazz = (ASClassType)cu.getType();

                 clazz.setDescription("Automatically generated functions for turning Objects into XML");

                 ASField ns = clazz.newField("NAMESPACE", Visibility.PUBLIC, "Namespace");

                 ns.setConst(true);

                 ns.setStatic(true);

                 ns.setInitializer("new Namespace("+ActionScriptFactory.str(namespace)+")");

                 return cu;

         }

         public static String getCurrentSourceExpr(CodegenContext context) {

                 String result = (String)context.getAttribute(KEY_MARSHAL_CURRENT_SOURCE_EXPR);

                 if (result == null) {

                         throw new IllegalStateException("no source expression defined");

                 }

                 return result;

         }

         public static void setCurrentSourceExpr(CodegenContext context, String expr) {

                 context.setAttribute(KEY_MARSHAL_CURRENT_SOURCE_EXPR, expr);

         }

         public static String getCurrentTargetParentElementExpr(CodegenContext context) {

                 return (String)context.getAttribute(KEY_MARSHAL_CURRENT_TARGET_PARENTELEMENT_EXPR);

         }

         public static void setCurrentTargetParentElementExpr(CodegenContext context, String expr) {

                 context.setAttribute(KEY_MARSHAL_CURRENT_TARGET_PARENTELEMENT_EXPR, expr);

         }

         public static void warn(String msg) {

                 System.err.println(msg);

         }

 }