/*

  * Copyright (c) 2007 David Holroyd

  */

 package uk.co.badgersinfoil.asxsd.components;

 import org.eclipse.xsd.XSDConcreteComponent;

 import org.eclipse.xsd.XSDNamedComponent;

 import org.eclipse.xsd.XSDSimpleTypeDefinition;

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

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

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

 public abstract class AbstractSimpleTypeComponent extends AbstractMappingComponent {

         public TypeDescriptor typeDescriptorFor(CodegenContext context,

                                                 XSDConcreteComponent component)

         {

                 XSDSimpleTypeDefinition simpleType = (XSDSimpleTypeDefinition)component;

                 return typeDescriptorFor(context, simpleType);

         }

         protected TypeDescriptor typeDescriptorFor(CodegenContext context,

                                                    XSDSimpleTypeDefinition simpleType)

         {

                 return super.typeDescriptorFor(context, simpleType);

         }

         public TypeDescriptor createTypeDescriptor(CodegenContext context,

                                                 XSDConcreteComponent component)

         {

                 XSDSimpleTypeDefinition simpleType = (XSDSimpleTypeDefinition)component;

                 return createTypeDescriptor(context, simpleType);

         }

         public ASCompilationUnit createType(CodegenContext context,

                                             XSDConcreteComponent component)

         {

                 return null;

         }

         public void generateCode(CodegenContext context,

                                  XSDConcreteComponent component)

         {

                 CodegenRole role = context.getCurrentRole();

                 if (role == CodegenRole.UNMARSHAL) {

                         StatementContainer block = context.getCurrentMethodCode();

                         MappingFunction fn = context.functionFor(component);

                         String converted = fn.appliedTo("thisValue");

                         block.addStmt("return "+converted);

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

                         StatementContainer block = context.getCurrentMethodCode();

                         MappingFunction fn = context.functionFor(component);

                         String converted = fn.appliedTo("thisValue");

                         block.addStmt("return "+converted);

                 } else {

                         super.generateCode(context, component);

                 }

         }

         protected abstract TypeDescriptor createTypeDescriptor(CodegenContext context,

                                                             XSDSimpleTypeDefinition simpleType);

         public MappingFunction createFunctionRef(CodegenContext context,

                                               XSDConcreteComponent component)

         {

                 XSDSimpleTypeDefinition simpleType = (XSDSimpleTypeDefinition)component;

                 CodegenRole role = context.getCurrentRole();

                 if (role == CodegenRole.UNMARSHAL) {

                         UnmarshalBuilder builder = context.getUnmarshalBuilder();

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

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

                         String methodName = unmarshalMethodNameFor(simpleType);

                         String qname;

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

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

                         } else {

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

                         }

                         return new BasicMappingFunction(qname);

                 }

                 if (role == CodegenRole.MARSHAL) {

                         MarshalBuilder builder = context.getMarshalBuilder();

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

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

                         String methodName = builder.methodNameFor(simpleType);

                         String qname;

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

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

                         } else {

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

                         }

                         return new BasicMappingFunction(qname);

                 }

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

         }

         private String unmarshalMethodNameFor(XSDSimpleTypeDefinition simpleType) {

                 String stub;

                 if (XSDUtils.isAnonymous(simpleType)) {

                         XSDNamedComponent container = (XSDNamedComponent)simpleType.getContainer();

                         stub = container.getName();

                 } else {

                         stub = simpleType.getName();

                 }

                 return "unmarshal" + StringUtils.sanitize(stub);

         }

         public ASMethod createFunction(CodegenContext context,

                                        XSDConcreteComponent component)

         {

                 XSDSimpleTypeDefinition simpleType = (XSDSimpleTypeDefinition)component;

                 CodegenRole role = context.getCurrentRole();

                 if (role == CodegenRole.UNMARSHAL) {

                         UnmarshalBuilder builder = context.getUnmarshalBuilder();

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

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

                         TypeDescriptor typeDesc = context.typeDescriptorFor(simpleType);

                         String methodName = unmarshalMethodNameFor(simpleType);

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

                         ASArg arg = meth.addParam("thisValue", "String");

                         String doc = "a value of type "+simpleType.getURI();

                         arg.setDescription(doc);

                         meth.setStatic(true);

                         context.pushAttrScope();

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

                         context.setCurrentMethodCode(meth);

                         context.generateCode(simpleType);

                         context.popAttrScope();

                         return meth;

                 }

                 if (role == CodegenRole.MARSHAL) {

                         MarshalBuilder builder = context.getMarshalBuilder();

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

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

                         String typeName = MarshalBuilder.xmlReturnTypeFor(simpleType);

                         String methodName = builder.methodNameFor(simpleType);

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

                         builder.buildMethodParams(meth, simpleType);

                         meth.setStatic(true);

                         context.pushAttrScope();

                         MarshalBuilder.setCurrentSourceExpr(context, "thisValue");

                         context.setCurrentMethodCode(meth);

                         context.generateCode(simpleType);

                         context.popAttrScope();

                         return meth;

                 }

                 return super.createFunction(context, component);

         }

         public boolean willAccept(XSDConcreteComponent component) {

                 return component instanceof XSDSimpleTypeDefinition

                     && willAcceptType((XSDSimpleTypeDefinition)component);

         }

         protected abstract boolean willAcceptType(XSDSimpleTypeDefinition simpleType);

 }