package uk.co.badgersinfoil.asxsd.components;

 import org.eclipse.xsd.XSDConcreteComponent;

 import org.eclipse.xsd.XSDElementDeclaration;

 import uk.co.badgersinfoil.asxsd.CodegenContext;

 import uk.co.badgersinfoil.asxsd.CodegenRole;

 import uk.co.badgersinfoil.asxsd.MappingFunction;

 import uk.co.badgersinfoil.asxsd.MarshalBuilder;

 import uk.co.badgersinfoil.asxsd.TypeDescriptor;

 import uk.co.badgersinfoil.asxsd.UnmarshalBuilder;

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

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

 public class ElementDeclarationReferenceComponent extends AbstractMappingComponent {

         public void generateCode(CodegenContext context,

                                  XSDConcreteComponent component)

         {

                 XSDElementDeclaration resolvedElementDecl = resolve(component);

                 CodegenRole role = context.getCurrentRole();

                 if (role == CodegenRole.UNMARSHAL) {

                         StatementContainer block = context.getCurrentMethodCode();

                         String accessExpr = UnmarshalBuilder.getCurrentSourceExpr(context);

                         MappingFunction conv = context.functionFor(resolvedElementDecl);

                         block.addStmt("return "+conv.appliedTo(accessExpr));

                 } else if (role == CodegenRole.MARSHAL) {

                         StatementContainer block = context.getCurrentMethodCode();

                         String accessExpr = MarshalBuilder.getCurrentSourceExpr(context);

                         String targetParentExpr = MarshalBuilder.getCurrentTargetParentElementExpr(context);

                         MappingFunction conv = context.functionFor(resolvedElementDecl);

                         String converted = conv.appliedTo(accessExpr);

                         block.addStmt(targetParentExpr+".appendChild("+converted+")");

                 } else if (role == CodegenRole.TYPE) {

                         context.generateCode(resolve(component));

                 } else {

                         throw new RuntimeException(getClass().getName()+" does not suppport operation generateCodeFor(role="+role+")");

                 }

         }

         public TypeDescriptor typeDescriptorFor(CodegenContext context,

                                                 XSDConcreteComponent component)

         {

                 return context.typeDescriptorFor(resolve(component));

         }

         public MappingFunction functionFor(CodegenContext context, XSDConcreteComponent component) {

                 return context.functionFor(resolve(component));

         }

         public String variableNameFor(CodegenContext context,

                                       XSDConcreteComponent component)

         {

                 return context.variableNameFor(resolve(component));

         }

         public ASExpression createExpression(CodegenContext context,

                                              XSDConcreteComponent component)

         {

                 return context.createExpression(resolve(component));

         }

         private static XSDElementDeclaration resolve(XSDConcreteComponent elementDeclaration) {

                 return ((XSDElementDeclaration)elementDeclaration).getResolvedElementDeclaration();

         }

         public boolean willAccept(XSDConcreteComponent component) {

                 return component instanceof XSDElementDeclaration

                     && ((XSDElementDeclaration)component).isElementDeclarationReference();

         }

 }