/*

  * Copyright (c) 2007 David Holroyd

  */

 package uk.co.badgersinfoil.asxsd.components;

 import java.util.Iterator;

 import java.util.List;

 import org.eclipse.xsd.XSDCompositor;

 import org.eclipse.xsd.XSDConcreteComponent;

 import org.eclipse.xsd.XSDElementDeclaration;

 import org.eclipse.xsd.XSDModelGroup;

 import org.eclipse.xsd.XSDParticle;

 import org.eclipse.xsd.XSDParticleContent;

 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.metaas.ActionScriptFactory;

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

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

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

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

 public class ChoiceMappingComponent extends AbstractMappingComponent {

         public void generateCode(CodegenContext context,

                                  XSDConcreteComponent component)

         {

                 CodegenRole role = context.getCurrentRole();

                 if (role == CodegenRole.UNMARSHAL) {

                         XSDModelGroup modelGroup = (XSDModelGroup)component;

                         List particles = modelGroup.getParticles();

                         StatementContainer code = context.getCurrentMethodCode();

                         XSDParticle particle = (XSDParticle)modelGroup.getContainer();

                         code.addComment(" process choice,");

                         // TODO: could this be expressed as a switch-case rather than a sequence of ifs?

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

                                 XSDParticle part = (XSDParticle)i.next();

                                 XSDParticleContent partContent = part.getContent();

                                 StatementContainer choiceBlock = detectElementContentUnmarshal(context, partContent, code);

                                 context.pushAttrScope();

                                 context.setCurrentMethodCode(choiceBlock);

                                 context.generateCode(part);

                                 context.popAttrScope();

                         }

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

                         XSDModelGroup modelGroup = (XSDModelGroup)component;

                         List particles = modelGroup.getParticles();

                         StatementContainer code = context.getCurrentMethodCode();

                         code.addComment(" process choice,");

                         // TODO: detect an 'any' entry and handle after all others?

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

                                 XSDParticle part = (XSDParticle)i.next();

                                 XSDParticleContent partContent = part.getContent();

                                 StatementContainer choiceBlock = detectElementContentMarshal(context, partContent, code);

                                 context.pushAttrScope();

                                 context.setCurrentMethodCode(choiceBlock);

                                 context.generateCode(part);

                                 context.popAttrScope();

                         }

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

                         XSDModelGroup modelGroup = (XSDModelGroup)component;

                         List particles = modelGroup.getParticles();

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

                                 XSDParticle part = (XSDParticle)i.next();

                                 context.generateCode(part);

                         }

                 } else {

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

                 }

         }

         private StatementContainer detectElementContentMarshal(CodegenContext context, XSDParticleContent partContent, StatementContainer code) {

                 XSDElementDeclaration firstElement = findFirstElementDeclaration(partContent);

                 String sourceExpr = MarshalBuilder.getCurrentSourceExpr(context);

                 String propertyName = context.variableNameFor(firstElement);

                 return code.newIf(sourceExpr+"."+propertyName+" != null");

         }

         private static StatementContainer detectElementContentUnmarshal(CodegenContext context, XSDParticleContent partContent, StatementContainer code) {

                 context.pushAttrScope();

                 context.setCurrentRole(CodegenRole.UNMARSHAL_DETECT);

                 ASExpression detect = context.createExpression(partContent);

                 context.popAttrScope();

                 return code.newIf(detect);

         }

         private static XSDElementDeclaration findFirstElementDeclaration(XSDParticleContent particleContent) {

                 while (true) {

                         if (particleContent instanceof XSDElementDeclaration) {

                                 return (XSDElementDeclaration)particleContent;

                         }

                         if (particleContent instanceof XSDModelGroup) {

                                 XSDModelGroup modelGroup = (XSDModelGroup)particleContent;

                                 List particles = modelGroup.getParticles();

                                 if (particles.size() > 0) {

                                         XSDParticle part = (XSDParticle)particles.get(0);

                                         particleContent = part.getContent();

                                 }

                         } else {

                                 throw new IllegalArgumentException("unhandled, sorry: "+particleContent);

                         }

                 }

         }

         public String createTypeNameFor(CodegenContext context,

                                         XSDConcreteComponent component)

         {

                 return context.createTypeNameFor(component.getContainer()) + "Choice";

         }

         public TypeDescriptor createTypeDescriptor(CodegenContext context,

                                                    XSDConcreteComponent component)

         {

                 String typeName = createTypeNameFor(context, component);

                 String docs = null;

                 return new TypeDescriptor(typeName, false, docs, component);

         }

         public ASCompilationUnit createType(CodegenContext context,

                                          XSDConcreteComponent component)

         {

                 String typeName = createTypeNameFor(context, component);

                 ASCompilationUnit unit = context.getProject().newClass(typeName);

                 TypeBuilder.setCurrentTypeCompilationUnit(context, unit);

                 context.setCurrentRole(CodegenRole.TYPE);

                 context.generateCode(component);

                 return unit;

         }

         public boolean willAccept(XSDConcreteComponent component) {

                 if (component instanceof XSDModelGroup) {

                         XSDModelGroup modelGroup = (XSDModelGroup)component;

                         return modelGroup.getCompositor() == XSDCompositor.CHOICE_LITERAL;

                 }

                 return false;

         }

         public String variableNameFor(CodegenContext context,

                                       XSDConcreteComponent component)

         {

                 return "choice";

         }

         public MappingFunction createFunctionRef(CodegenContext context,

                                               XSDConcreteComponent component)

         {

                 XSDModelGroup modelGroup = (XSDModelGroup)component;

                 CodegenRole role = context.getCurrentRole();

                 if (role == CodegenRole.UNMARSHAL) {

                         UnmarshalBuilder builder = context.getUnmarshalBuilder();

                         ASCompilationUnit unit = builder.getClassForNamespace(modelGroup.getSchema().getTargetNamespace());

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

                         TypeDescriptor typeDesc = context.typeDescriptorFor(modelGroup);

                         String methodName = "unmarshal" + StringUtils.sanitize(localName(typeDesc));

                         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)

         {

                 XSDModelGroup modelGroup = (XSDModelGroup)component;

                 CodegenRole role = context.getCurrentRole();

                 if (role == CodegenRole.UNMARSHAL) {

                         UnmarshalBuilder builder = context.getUnmarshalBuilder();

                         ASCompilationUnit unit = builder.getClassForNamespace(modelGroup.getSchema().getTargetNamespace());

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

                         TypeDescriptor typeDesc = context.typeDescriptorFor(modelGroup);

                         String methodName = "unmarshal" + StringUtils.sanitize(localName(typeDesc));

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

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

                         meth.setStatic(true);

                         context.pushAttrScope();

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

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

                         UnmarshalBuilder.setCurrentSourceExpr(context, "thisElement");

                         context.setAttribute("element-access-expression", "thisElement");

                         context.setCurrentMethodCode(meth);

                         context.generateCode(modelGroup);

                         context.popAttrScope();

                         meth.newReturn("_result");

                         return meth;

                 }

                 return super.createFunction(context, component);

         }

         private String localName(TypeDescriptor typeDesc) {

                 String qname = typeDesc.getTypeName();

                 int pos = qname.lastIndexOf('.');

                 if (pos != -1) {

                         return qname.substring(pos + 1);

                 }

                 return qname;

         }

         public ASExpression createExpression(CodegenContext context,

                                              XSDConcreteComponent component)

         {

                 CodegenRole role = context.getCurrentRole();

                 XSDModelGroup modelGroup = (XSDModelGroup)component;

                 if (role == CodegenRole.UNMARSHAL_DETECT) {

                         List particles = modelGroup.getParticles();

                         ActionScriptFactory fact = context.getFactory();

                         if (particles.isEmpty()) {

                                 return fact.newExpression("false");

                         }

                         Iterator i = particles.iterator();

                         ASExpression detect = context.createExpression((XSDConcreteComponent)i.next());

                         while (i.hasNext()) {

                                 ASExpression rhs = context.createExpression((XSDConcreteComponent)i.next());

                                 detect = fact.newOrExpression(detect, rhs);

                         }

                         return detect;

                 }

                 if (role == CodegenRole.MARSHAL_DETECT) {

                         List particles = modelGroup.getParticles();

                         ActionScriptFactory fact = context.getFactory();

                         if (particles.isEmpty()) {

                                 return fact.newExpression("false");

                         }

                         Iterator i = particles.iterator();

                         ASExpression detect = context.createExpression((XSDConcreteComponent)i.next());

                         while (i.hasNext()) {

                                 ASExpression rhs = context.createExpression((XSDConcreteComponent)i.next());

                                 detect = fact.newOrExpression(detect, rhs);

                         }

                         return detect;

                 }

                 return super.createExpression(context, component);

         }

 }