/*

  * Copyright (c) 2007 David Holroyd

  */

 package uk.co.badgersinfoil.asxsd.components;

 import org.eclipse.xsd.XSDConcreteComponent;

 import org.eclipse.xsd.XSDElementDeclaration;

 import org.eclipse.xsd.XSDSimpleTypeDefinition;

 import org.eclipse.xsd.XSDTypeDefinition;

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

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

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

 public class ArrayTypeDeclarationComponent extends AbstractMappingComponent {

         public TypeDescriptor createTypeDescriptor(CodegenContext context,

                                                 XSDConcreteComponent component)

         {

                 XSDTypeDefinition typeDef = (XSDTypeDefinition)component;

                 XSDElementDeclaration listElement = XSDUtils.getElementIfContainerForList(typeDef);

                 TypeDescriptor elementType = context.typeDescriptorFor(listElement);

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

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

         }

         public ASCompilationUnit createType(CodegenContext context,

                                             XSDConcreteComponent component)

         {

                 // built in implementation

                 return null;

         }

         public boolean willAccept(XSDConcreteComponent component) {

                 return component instanceof XSDTypeDefinition

                     && XSDUtils.getElementIfContainerForList((XSDTypeDefinition)component)!=null;

         }

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

                 CodegenRole role = context.getCurrentRole();

                 if (role == CodegenRole.TYPE) {

                         ASClassType clazz = TypeBuilder.getCurrentType(context);

                         clazz.setDescription("Gah!  This type should not have been generated");

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

                         StatementContainer block = context.getCurrentMethodCode();

                         block.addStmt("default xml namespace = NAMESPACE");

                         XSDElementDeclaration listElement = XSDUtils.getElementIfContainerForList((XSDTypeDefinition)component);

                         String elementType = context.typeDescriptorFor(listElement).getTypeName();

                         String fieldAccess = "_result";

                         String childVarName = "_child";

                         StatementContainer loop = block.newForEachIn("var "+childVarName+":"+elementType, "thisObject");

                         String access = "_"+context.variableNameFor(listElement);

                         loop.addStmt("var "+access + ":XML = <"+listElement.getName()+"/>");

                         if (listElement.getType() instanceof XSDSimpleTypeDefinition) {

                                 MappingFunction conv = context.functionFor(listElement);

                                 String converted = conv.appliedTo(childVarName);

                                 loop.addStmt(access + ".appendChild("+converted+")");

                                 loop.addStmt(fieldAccess + ".appendChild("+access+")");

                         } else {

                                 MappingFunction conv = context.functionFor(listElement);

                                 String converted = conv.appliedTo(access + ", " + childVarName);

                                 loop.addStmt(converted);

                                 loop.addStmt(fieldAccess + ".appendChild("+access+")");

                         }

                         block.addStmt("return _result");

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

                         StatementContainer block = context.getCurrentMethodCode();

                         block.addStmt("default xml namespace = NAMESPACE");

                         TypeDescriptor typeDesc = context.createTypeDescriptor(component);

                         block.addStmt("var _result:"+typeDesc.getTypeName()+" = new "+typeDesc.getTypeName()+"()");

                         XSDElementDeclaration listElement = XSDUtils.getElementIfContainerForList((XSDTypeDefinition)component);

                         block.addStmt("var _children:XMLList = thisElement.elements()");

                         StatementContainer loop = block.newForEachIn("var _child:XML", "_children");

                         MappingFunction conv = context.functionFor(listElement);

                         String access;

                         if (listElement.getType() instanceof XSDSimpleTypeDefinition) {

                                 access = "_child.text()";

                         } else {

                                 access = "_child";

                         }

                         String converted = conv.appliedTo(access);

                         loop.addStmt("_result.push("+converted+")");

                         block.addStmt("return _result");

                 } else {

                         throw new IllegalArgumentException(getClass().getName() + " does not support generateCode(role="+role+")");

                 }

         }

         public MappingFunction createFunctionRef(CodegenContext context,

                                                  XSDConcreteComponent component)

         {

                 XSDTypeDefinition typeDef = (XSDTypeDefinition)component;

                 CodegenRole role = context.getCurrentRole();

                 if (role == CodegenRole.MARSHAL) {

                         MarshalBuilder builder = context.getMarshalBuilder();

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

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

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

                         String methodName = "marshal" + name;

                         String qname;

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

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

                         } else {

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

                         }

                         return new BasicMappingFunction(qname);

                 }

                 if (role == CodegenRole.UNMARSHAL) {

                         UnmarshalBuilder builder = context.getUnmarshalBuilder();

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

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

                         String name = StringUtils.sanitize(typeDef.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)

         {

                 XSDTypeDefinition typeDef = (XSDTypeDefinition)component;

                 CodegenRole role = context.getCurrentRole();

                 if (role == CodegenRole.MARSHAL) {

                         MarshalBuilder builder = context.getMarshalBuilder();

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

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

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

                         String methodName = "marshal" + name;

                         TypeDescriptor typeDesc = context.typeDescriptorFor(typeDef);

                         ASMethod meth = clazz.newMethod(methodName, Visibility.PUBLIC, "XML");

                         ASArg resultArg = meth.addParam("_result", "XML");

                         ASArg arg = meth.addParam("thisObject", typeDesc.getTypeName());

                         meth.setStatic(true);

                         context.pushAttrScope();

                         context.setCurrentMethodCode(meth);

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

                         context.generateCode(typeDef);

                         context.popAttrScope();

                         return meth;

                 }

                 if (role == CodegenRole.UNMARSHAL) {

                         UnmarshalBuilder builder = context.getUnmarshalBuilder();

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

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

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

                         String methodName = "unmarshal" + name;

                         TypeDescriptor typeDesc = context.typeDescriptorFor(typeDef);

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

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

                         String doc = "a element of type "+typeDef.getURI();

                         arg.setDescription(doc);

                         meth.setStatic(true);

                         context.pushAttrScope();

                         context.setCurrentMethodCode(meth);

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

                         context.generateCode(typeDef);

                         context.popAttrScope();

                         return meth;

                 }

                 return super.createFunction(context, component);

         }

 }