/*

  * Copyright (c) 2007 David Holroyd

  */

 package uk.co.badgersinfoil.asxsd.components;

 import org.eclipse.xsd.XSDConcreteComponent;

 import org.eclipse.xsd.XSDElementDeclaration;

 import uk.co.badgersinfoil.asxsd.BasicMappingFunction;

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

 import uk.co.badgersinfoil.asxsd.TypeBuilder;

 import uk.co.badgersinfoil.asxsd.TypeDescriptor;

 import uk.co.badgersinfoil.asxsd.UnmarshalBuilder;

 import uk.co.badgersinfoil.asxsd.XSDUtils;

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

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

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

 public class ArrayElementDeclarationComponent extends AbstractMappingComponent {

         public TypeDescriptor createTypeDescriptor(CodegenContext context,

                                                 XSDConcreteComponent component)

         {

                 XSDElementDeclaration elementDecl = (XSDElementDeclaration)component;

                 XSDElementDeclaration listElement = XSDUtils.getElementIfContainerForList(elementDecl);

                 TypeDescriptor elementType = context.typeDescriptorFor(listElement);

                 String doc = "Elements of type {@link " + elementType.getTypeName()+"}";

                 return new TypeDescriptor(ASConstants.TYPE_ARRAY, true, doc, elementDecl);

         }

         public ASCompilationUnit createType(CodegenContext context,

                                             XSDConcreteComponent component)

         {

                 // no implementation (built in type)

                 return null;

         }

         public boolean willAccept(XSDConcreteComponent component) {

                 return component instanceof XSDElementDeclaration

                     && XSDUtils.getElementIfContainerForList((XSDElementDeclaration)component)!=null

                     && XSDUtils.isAnonymous(((XSDElementDeclaration)component).getType());

         }

         public void generateCode(CodegenContext context, final XSDConcreteComponent component) {

                 XSDElementDeclaration elementDecl = (XSDElementDeclaration)component;

                 CodegenRole role = context.getCurrentRole();

                 if (role == CodegenRole.MARSHAL) {

                         StatementContainer containingBlock = context.getCurrentMethodCode();

                         XSDElementDeclaration listElement = XSDUtils.getElementIfContainerForList(elementDecl);

                         String listName = "_"+context.variableNameFor(elementDecl);

                         containingBlock.addStmt("var "+listName+":XML = <"+elementDecl.getName()+"/>");

                         TypeDescriptor typeDesc = context.typeDescriptorFor(listElement);

                         String elementType = typeDesc.getTypeName();

                         String childVarName = listName+"_child";

                         String accessExpr = MarshalBuilder.getCurrentSourceExpr(context);

                         StatementContainer forEachLoop = containingBlock.newForEachIn("var "+childVarName+":"+elementType, accessExpr);

                         context.pushAttrScope();

                         context.setCurrentMethodCode(forEachLoop);

                         MarshalBuilder.setCurrentSourceExpr(context, childVarName);

                         MarshalBuilder.setCurrentTargetParentElementExpr(context, listName);

                         context.generateCode(listElement);

                         // switch back to the original block,

                         context.popAttrScope();

                         String targetParentExpr = MarshalBuilder.getCurrentTargetParentElementExpr(context);

                         containingBlock.addStmt(targetParentExpr+".appendChild("+listName+")");

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

                         context.generateCode(elementDecl.getType());

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

                         ASCompilationUnit unit = TypeBuilder.getCurrentTypeCompilationUnit(context);

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

                         TypeDescriptor typeDesc = context.typeDescriptorFor(elementDecl.getContainer());

                         ASField field = clazz.newField(context.variableNameFor(elementDecl.getResolvedElementDeclaration()), Visibility.PUBLIC, typeDesc.getTypeName());

                         field.setDescription(typeDesc.getDocumentation());                        

                 } else {

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

                 }

         }

         public MappingFunction createFunctionRef(CodegenContext context,

                                               XSDConcreteComponent component)

         {

                 XSDElementDeclaration elementDecl = (XSDElementDeclaration)component;

                 CodegenRole role = context.getCurrentRole();

                 if (role == CodegenRole.UNMARSHAL) {

                         UnmarshalBuilder builder = context.getUnmarshalBuilder();

                         ASCompilationUnit unit = builder.getClassForNamespace(elementDecl.getTargetNamespace());

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

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

                         String methodName = "unmarshal" + name;

                         String qname;

                         if (unit.getPackageName() != null) {

                                 qname = unit.getPackageName()+"."+clazz.getName()+"."+methodName;

                         } else {

                                 qname = clazz.getName()+"."+methodName;

                         }

                         return new BasicMappingFunction(qname);

                 }

                 return super.createFunctionRef(context, component);

         }

         public ASMethod createFunction(CodegenContext context,

                                        XSDConcreteComponent component)

         {

                 XSDElementDeclaration elementDecl = (XSDElementDeclaration)component;

                 CodegenRole role = context.getCurrentRole();

                 if (role == CodegenRole.UNMARSHAL) {

                         UnmarshalBuilder builder = context.getUnmarshalBuilder();

                         ASCompilationUnit unit = builder.getClassForNamespace(elementDecl.getTargetNamespace());

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

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

                         String methodName = "unmarshal" + name;

                         TypeDescriptor typeDesc = context.typeDescriptorFor(elementDecl);

                         ASMethod meth = clazz.newMethod(methodName, Visibility.PUBLIC, typeDesc.getTypeName());

                         ASArg arg = meth.addParam("thisElement", "XML");

                         String doc = "a <" + elementDecl.getName()+"/> element";

                         arg.setDescription(doc);

                         if (!elementDecl.isGlobal()) {

                                 meth.setVisibility(Visibility.PRIVATE);

                         }

                         meth.setStatic(true);

                         context.pushAttrScope();

                         context.setCurrentMethodCode(meth);

                         UnmarshalBuilder.setCurrentSourceExpr(context, arg.getName());

                         context.generateCode(elementDecl);

                         context.popAttrScope();

                         return meth;

                 }

                 return super.createFunction(context, component);

         }

         public String variableNameFor(CodegenContext context,

                                       XSDConcreteComponent component)

         {

                 XSDElementDeclaration elementDecl = (XSDElementDeclaration)component;

                 return context.toVariableName(elementDecl.getName());

         }

 }