/*

  * Copyright (c) 2007 David Holroyd

  */

 package uk.co.badgersinfoil.asxsd;

 import java.util.HashMap;

 import java.util.Map;

 import java.util.Stack;

 import org.eclipse.xsd.XSDConcreteComponent;

 import uk.co.badgersinfoil.metaas.ActionScriptFactory;

 import uk.co.badgersinfoil.metaas.ActionScriptProject;

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

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

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

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

 public class BaseCodegenContext implements CodegenContext {

         private MappingRegistry registry;

         private ActionScriptFactory factory;

         private ActionScriptProject project;

         private UnmarshalBuilder unmarshalBuilder;

         private MarshalBuilder marshalBuilder;

         private VariableNameGenerator varNameGen = new VariableNameGenerator();

         private Map attrs = new HashMap();

         private TypeBuilder typeBuilder;

         private Stack scopeStack = new Stack();

         private MappingFunctionStore functionStore = new MappingFunctionStore();

         private Map typeStore = new HashMap();

         private static final String KEY_ROLE = BaseCodegenContext.class.getName() + ".role";

         private static final String KEY_CODE = BaseCodegenContext.class.getName() + ".code";

         public BaseCodegenContext(MappingRegistry registry, ActionScriptFactory factory, ActionScriptProject project) {

                 this.registry = registry;

                 this.factory = factory;

                 this.project = project;

         }

         public ActionScriptProject getProject() {

                 return project;

         }

         public ActionScriptFactory getFactory() {

                 return factory;

         }

         public MappingRegistry getRegistry() {

                 return registry;

         }

         public TypeDescriptor typeDescriptorFor(XSDConcreteComponent component) {

                 MappingComponent mapComp = componentFor(component);

                 return mapComp.typeDescriptorFor(this, component);

         }

         public TypeDescriptor createTypeDescriptor(XSDConcreteComponent component) {

                 MappingComponent mapComp = componentFor(component);

                 pushAttrScope();

                 setCurrentRole(CodegenRole.TYPE);

                 TypeDescriptor result = mapComp.createTypeDescriptor(this, component);

                 popAttrScope();

                 return result;

         }

         public String createTypeNameFor(XSDConcreteComponent component) {

                 MappingComponent mapComp = componentFor(component);

                 String name = mapComp.createTypeNameFor(this, component);

                 // TODO: ensure name is unique within this context

                 return name;

         }

         public CodegenRole getCurrentRole() {

                 return (CodegenRole)getAttribute(KEY_ROLE);

         }

         public void setCurrentRole(CodegenRole role) {

                 setAttribute(KEY_ROLE, role);

         }

         public void generateCode(XSDConcreteComponent component) {

                 MappingComponent mapComp = componentFor(component);

                 mapComp.generateCode(this, component);

         }

         public MappingFunction functionFor(XSDConcreteComponent component) {

                 MappingComponent mapComp = componentFor(component);

                 return mapComp.functionFor(this, component);

         }

         public MappingFunction getOrCreateFunction(XSDConcreteComponent component) {

                 CodegenRole role = getCurrentRole();

                 MappingFunction convert = functionStore.get(role, component);

                 if (convert == null) {

 //                        pushAttrScope();

                         convert = createFunctionRef(component);

                         functionStore.put(role, component, convert);

                         // now that we've got a ref to the method in the map,

                         // its safe to generate the method body without the

                         // potential for infinite recursion,

                         ASMethod impl = createFunction(component);

                         convert.setImplementation(impl);

 //                        popAttrScope();

                 }

                 return convert;

         }

         public TypeDescriptor getOrCreateType(XSDConcreteComponent component) {

                 TypeDescriptor typeDesc = (TypeDescriptor)typeStore.get(component);

                 if (typeDesc == null) {

                         pushAttrScope();

                         typeDesc = createTypeDescriptor(component);

                         typeStore.put(component, typeDesc);

                         ASCompilationUnit unit = createType(component);

                         typeDesc.setImplementation(unit);

                         popAttrScope();

                 }

                 return typeDesc;

         }

         private ASCompilationUnit createType(XSDConcreteComponent component) {

                 MappingComponent mapComp = componentFor(component);

                 return mapComp.createType(this, component);

         }

         public StatementContainer getCurrentMethodCode() {

                 return (StatementContainer)getAttribute(KEY_CODE);

         }

         public void setCurrentMethodCode(StatementContainer code) {

                 setAttribute(KEY_CODE, code);

         }

         public MappingFunction createFunctionRef(XSDConcreteComponent component) {

                 MappingComponent mapComp = componentFor(component);

                 return mapComp.createFunctionRef(this, component);

         }

         public ASMethod createFunction(XSDConcreteComponent component) {

                 MappingComponent mapComp = componentFor(component);

                 return mapComp.createFunction(this, component);

         }

         public ASExpression createExpression(XSDConcreteComponent component) {

                 MappingComponent mapComp = componentFor(component);

                 return mapComp.createExpression(this, component);

         }

         private MappingComponent componentFor(XSDConcreteComponent component) {

                 if (component == null) {

                         throw new IllegalArgumentException("component must not be null");

                 }

                 return registry.mappingComponentFor(component);

         }

         public void setUnmarshalBuilder(UnmarshalBuilder unmarshalBuilder) {

                 this.unmarshalBuilder = unmarshalBuilder;

         }

         public UnmarshalBuilder getUnmarshalBuilder() {

                 return unmarshalBuilder;

         }

         public void setMarshalBuilder(MarshalBuilder marshalBuilder) {

                 this.marshalBuilder = marshalBuilder;

         }

         public MarshalBuilder getMarshalBuilder() {

                 return marshalBuilder;

         }

         public void setTypeBuilder(TypeBuilder typeBuilder) {

                 this.typeBuilder = typeBuilder;

         }

         public TypeBuilder getTypeBuilder() {

                 return typeBuilder;

         }

         public String variableNameFor(XSDConcreteComponent component) {

                 MappingComponent mapComp = componentFor(component);

                 return mapComp.variableNameFor(this, component);

         }

         public String toVariableName(String baseName) {

                 return varNameGen.fieldName(baseName);

         }

         public void setAttribute(String key, Object value) {

                 if (attrs.containsKey(key)) {

                         throw new IllegalArgumentException(key+" is already mapped to "+attrs.get(key));

                 }

                 attrs.put(key, value);

         }

         public Object getAttribute(String key) {

                 Map scope = attrs;

                 int count = scopeStack.size();

                 while (true) {

                         if (scope.containsKey(key)) {

                                 return scope.get(key);

                         }

                         if (count == 0) {

                                 return null;

                         }

                         scope = (Map)scopeStack.get(--count);

                 }

         }

         public void popAttrScope() {

                 attrs = (Map)scopeStack.pop();

         }

         public void pushAttrScope() {

                 scopeStack.push(attrs);

                 attrs = new HashMap();

         }

         public MappingFunctionStore getMappingFunctionStore() {

                 return functionStore;

         }

 }