/*

  * Copyright (c) 2007 David Holroyd

  */

 package uk.co.badgersinfoil.asxsd.components;

 import java.util.Iterator;

 import java.util.List;

 import org.eclipse.xsd.XSDAttributeGroupContent;

 import org.eclipse.xsd.XSDComplexTypeContent;

 import org.eclipse.xsd.XSDComplexTypeDefinition;

 import org.eclipse.xsd.XSDConcreteComponent;

 import org.eclipse.xsd.XSDElementDeclaration;

 import org.eclipse.xsd.XSDParticle;

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

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

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

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

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

 public class ComplexTypeComponent extends AbstractMappingComponent {

         TypeNameGenerator nameGen = new TypeNameGenerator();

         public TypeDescriptor createTypeDescriptor(CodegenContext context,

                                                 XSDConcreteComponent component)

         {

                 XSDComplexTypeDefinition complexType = (XSDComplexTypeDefinition)component;

                 context.pushAttrScope();

                 String docs = null;

                 String typeName = context.createTypeNameFor(complexType);

                 TypeDescriptor result = new TypeDescriptor(typeName, false, docs, component);

                 context.popAttrScope();

                 return result;

         }

         public TypeDescriptor typeDescriptorFor(CodegenContext context,

                                                 XSDConcreteComponent component)

         {

                 XSDComplexTypeDefinition complexType = (XSDComplexTypeDefinition)component;

                 if (XSDUtils.isAnonymous(complexType)) {

                         return context.typeDescriptorFor(complexType.getContainer());

                 }

                 return super.typeDescriptorFor(context, component);

         }

         public ASCompilationUnit createType(CodegenContext context,

                                          XSDConcreteComponent component)

         {

                 XSDComplexTypeDefinition complexType = (XSDComplexTypeDefinition)component;

                 String typeName = context.createTypeNameFor(complexType);

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

                 context.pushAttrScope();

                 TypeBuilder.setCurrentTypeCompilationUnit(context, unit);

                 context.setCurrentRole(CodegenRole.TYPE);

                 context.generateCode(complexType);

                 context.popAttrScope();

                 return unit;

         }

         public String createTypeNameFor(CodegenContext context,

                                         XSDConcreteComponent component)

         {

                 XSDComplexTypeDefinition typeDef = (XSDComplexTypeDefinition)component;

                 return context.getTypeBuilder().typeNameFor(typeDef);

         }

         public void generateCode(CodegenContext context,XSDConcreteComponent component) {

                 XSDComplexTypeDefinition complexType = (XSDComplexTypeDefinition)component;

                 CodegenRole role = context.getCurrentRole();

                 if (role == CodegenRole.UNMARSHAL) {

                         StatementContainer block = context.getCurrentMethodCode();

                         if (!XSDUtils.isAnonymous(complexType)) {

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

                                 TypeDescriptor typeDesc = context.typeDescriptorFor(complexType);

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

                         }

                         processComplexTypeBaseTypeUnmarshal(context, complexType);

                         processAllComplexTypeAttributesUnmarshal(context, complexType);

                         processAllComplexTypeElementsUnmarshal(context, complexType);

                         block.addStmt("return _result");

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

                         processComplexTypeBaseTypeMarshal(context, complexType);

                         processAllComplexTypeAttributesMarshal(context, complexType);

                         processAllComplexTypeElementsMarshal(context, complexType);

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

                         //ASClassType clazz = TypeBuilder.getCurrentType(context);

                         processComplexTypeBaseType(context, complexType);

                         processComplexTypeAnnotation(context, complexType);

                         processAllComplexTypeAttributes(context, complexType);

                         processContent(context, complexType);

                 } else {

                         super.generateCode(context, component);

                 }

         }

         private void processComplexTypeBaseTypeUnmarshal(CodegenContext context, XSDComplexTypeDefinition ctype) {

                 XSDTypeDefinition baseType = ctype.getBaseType();

                 if (isAllowedAsSuperclass(baseType)) {

                         // TODO: handle base class initialisation

                         UnmarshalBuilder.warn("Base class initialisation for "+baseType.getQName()+" (base class of "+ctype.getQName()+") not handled; sorry");

                 }

         }

         private void processAllComplexTypeAttributesUnmarshal(CodegenContext context, XSDComplexTypeDefinition ctype) {

                 List attrs= ctype.getAttributeContents();

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

                         XSDAttributeGroupContent attrContent = (XSDAttributeGroupContent)i.next();

                         context.generateCode(attrContent);

                 }

         }

         private void processAllComplexTypeElementsUnmarshal(CodegenContext context, XSDComplexTypeDefinition typeDef)

         {

                 XSDComplexTypeContent complexContent = typeDef.getContent();

                 if (complexContent == null) {

                         return;

                 }

                 if (complexContent instanceof XSDParticle) {

                         // TODO: test to see if there will really be elements to process?

                         //       or is presence of an XSDParticle enough?

                         StatementContainer block = context.getCurrentMethodCode();

                         block.addComment(" process child sequence elements,");

                         XSDParticle particle = (XSDParticle)complexContent;

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

                         block.addStmt("var _seq:int = 0");

                         context.pushAttrScope();

                         UnmarshalBuilder.setCurrentSourceExpr(context, "_children[_seq++]");

                         context.setAttribute("element-access-expression", "_children[_seq]");

                         context.generateCode(particle);

                         context.popAttrScope();

                 } else {

                         context.generateCode(complexContent);

                 }

         }

         private void processComplexTypeBaseTypeMarshal(CodegenContext context, XSDComplexTypeDefinition ctype) {

                 XSDTypeDefinition baseType = ctype.getBaseType();

                 if (isAllowedAsSuperclass(baseType)) {

                         // TODO: handle base class initialisation

                         MarshalBuilder.warn("Base class initialisation for "+baseType.getQName()+" (base class of "+ctype.getQName()+") not handled; sorry");

                 }

         }

         private void processAllComplexTypeAttributesMarshal(CodegenContext context, XSDComplexTypeDefinition ctype) {

                 List attrs = ctype.getAttributeContents();

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

                         XSDAttributeGroupContent attrContent = (XSDAttributeGroupContent)i.next();

                         context.generateCode(attrContent);

                 }

         }

         private void processAllComplexTypeElementsMarshal(CodegenContext context, XSDComplexTypeDefinition typeDef)

         {

                 XSDComplexTypeContent complexContent = typeDef.getContent();

                 if (complexContent != null) {

                         context.generateCode(complexContent);

                 }

         }

         private void processComplexTypeBaseType(CodegenContext context, XSDComplexTypeDefinition typeDef) {

                 XSDTypeDefinition baseType = typeDef.getBaseType();

                 if (isAllowedAsSuperclass(baseType)) {

                         ASClassType clazz = TypeBuilder.getCurrentType(context);

                         clazz.setSuperclass(nameGen.typeName(baseType));

                 }

         }

         private boolean isAllowedAsSuperclass(XSDTypeDefinition baseType) {

                 return !XSDUtils.isXSDAnyType(baseType)

                        && baseType instanceof XSDComplexTypeDefinition;

         }

         /**

          * turn attributes defined by the complexType into class properties

          */

         private void processAllComplexTypeAttributes(CodegenContext context, XSDComplexTypeDefinition typeDef)

         {

                 List attrs = typeDef.getAttributeContents();

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

                         XSDAttributeGroupContent attrContent = (XSDAttributeGroupContent)i.next();

                         context.generateCode(attrContent);

                 }

         }

         /**

          * add any annotation on the given complexType as the documentation

          * comment for the given AS class.

          */

         private void processComplexTypeAnnotation(CodegenContext context, XSDComplexTypeDefinition typeDef)

         {

                 String doc = DocUtils.findDocumentation(typeDef.getAnnotation());

                 if (doc != null) {

                         ASClassType clazz = TypeBuilder.getCurrentType(context);

                         clazz.setDescription(doc);

                 }

         }

         private void processContent(CodegenContext context,

                                     XSDComplexTypeDefinition typeDef)

         {

                 XSDComplexTypeContent content = typeDef.getContent();

                 if (content != null) {

                         context.generateCode(content);

                 }

         }

         public boolean willAccept(XSDConcreteComponent component) {

                 return component instanceof XSDComplexTypeDefinition;

         }

         public MappingFunction createFunctionRef(CodegenContext context,

                                                  XSDConcreteComponent component)

         {

                 XSDComplexTypeDefinition complexType = (XSDComplexTypeDefinition)component;

                 CodegenRole role = context.getCurrentRole();

                 String qname;

                 if (role == CodegenRole.UNMARSHAL) {

                         UnmarshalBuilder builder = context.getUnmarshalBuilder();

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

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

                         TypeDescriptor typeDesc = context.typeDescriptorFor(complexType);

                         String methodName = "unmarshal" + StringUtils.sanitize(complexType.getName());

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

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

                         } else {

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

                         }

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

                         MarshalBuilder builder = context.getMarshalBuilder();

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

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

                         String typeName = MarshalBuilder.xmlReturnTypeFor(complexType);

                         String methodName = builder.methodNameFor(complexType);

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

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

                         } else {

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

                         }

                 } else {

                         throw new IllegalArgumentException("role="+role);

                 }

                 return new BasicMappingFunction(qname);

         }

         public ASMethod createFunction(CodegenContext context,

                                        XSDConcreteComponent component)

         {

                 XSDComplexTypeDefinition complexType = (XSDComplexTypeDefinition)component;

                 CodegenRole role = context.getCurrentRole();

                 if (role == CodegenRole.UNMARSHAL) {

                         UnmarshalBuilder builder = context.getUnmarshalBuilder();

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

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

                         TypeDescriptor typeDesc = context.typeDescriptorFor(complexType);

                         String methodName = "unmarshal" + StringUtils.sanitize(complexType.getName());

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

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

                         String doc = "an element of type "+complexType.getURI();

                         arg.setDescription(doc);

                         meth.setStatic(true);

                         context.pushAttrScope();

                         UnmarshalBuilder.setCurrentSourceExpr(context, "thisElement");

                         context.setCurrentMethodCode(meth);

                         context.generateCode(complexType);

                         context.popAttrScope();

                         return meth;

                 }

                 if (role == CodegenRole.MARSHAL) {

                         MarshalBuilder builder = context.getMarshalBuilder();

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

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

                         String typeName = MarshalBuilder.xmlReturnTypeFor(complexType);

                         String methodName = builder.methodNameFor(complexType);

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

                         builder.buildMethodParams(meth, complexType);

                         meth.setStatic(true);

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

                         if (XSDUtils.isAnonymous(complexType)) {

                                 // TODO: move this bit to ElementDeclarationComponent?

                                 XSDElementDeclaration elementDecl = (XSDElementDeclaration)complexType.getContainer();

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

                         }

                         context.pushAttrScope();

                         MarshalBuilder.setCurrentTargetParentElementExpr(context, "_result");

                         MarshalBuilder.setCurrentSourceExpr(context, "thisObject");

                         context.setCurrentMethodCode(meth);

                         context.generateCode(complexType);

                         context.popAttrScope();

                         meth.addStmt("return _result");

                         return meth;

                 }

                 return super.createFunction(context, component);

         }

 }