/*

  * 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.XSDSchema;

 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.ASField;

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

 public class UnmarshalBuilder {

         static final String KEY_UNMARSHAL_CURRENT_METHOD_CODE = "uk.co.badgersinfoil.asxsd.unmarshal.currentMethod.code";

         static final String KEY_UNMARSHAL_CURRENT_SOURCE_EXPR = "uk.co.badgersinfoil.asxsd.unmarshal.currentSource.expr";

         private Map converterClassesByNamespace = new HashMap();

         private ActionScriptProject project;

         private CodegenContext context;

         public UnmarshalBuilder(ActionScriptProject project, CodegenContext context) {

                 this.project = project;

                 this.context = context;

         }

         public void processSchema(XSDSchema schema) {

                 List types = schema.getTypeDefinitions();

                 context.pushAttrScope();

                 context.setCurrentRole(CodegenRole.UNMARSHAL);

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

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

                         if (typeDef instanceof XSDComplexTypeDefinition) {

                                 XSDComplexTypeDefinition ctype = (XSDComplexTypeDefinition)typeDef;

                                 context.functionFor(ctype);

                         }

                 }

 //                List elements = schema.getElementDeclarations();

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

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

 //                        conversionMethodFor(elementDecl);

 //                }

                 context.popAttrScope();

         }

         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(converterClassNameForNamespace(namespace));

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

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

                 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_UNMARSHAL_CURRENT_SOURCE_EXPR);

                 if (result == null) {

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

                 }

                 return result;

         }

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

                 context.setAttribute(KEY_UNMARSHAL_CURRENT_SOURCE_EXPR, expr);

         }

         public static void warn(String msg) {

                 System.err.println(msg);

         }

         public String converterClassNameForNamespace(String uri) {

                 return StringUtils.toPackageName(uri)+".Unmarshaler";

         }

 }