/*
 * Copyright 2010 Google Inc.
 * 
 * Licensed under the Apache License, Version 2.0 (the "License"); you may not
 * use this file except in compliance with the License. You may obtain a copy of
 * the License at
 * 
 * http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 * License for the specific language governing permissions and limitations under
 * the License.
 */
package com.google.gwt.autobean.rebind;

import com.google.gwt.autobean.client.impl.AbstractAutoBeanFactory;
import com.google.gwt.autobean.rebind.model.AutoBeanFactoryMethod;
import com.google.gwt.autobean.rebind.model.AutoBeanFactoryModel;
import com.google.gwt.autobean.rebind.model.AutoBeanMethod;
import com.google.gwt.autobean.rebind.model.AutoBeanMethod.Action;
import com.google.gwt.autobean.rebind.model.AutoBeanType;
import com.google.gwt.autobean.shared.AutoBean;
import com.google.gwt.autobean.shared.AutoBeanFactory;
import com.google.gwt.autobean.shared.AutoBeanUtils;
import com.google.gwt.autobean.shared.AutoBeanVisitor;
import com.google.gwt.autobean.shared.AutoBeanVisitor.CollectionPropertyContext;
import com.google.gwt.autobean.shared.AutoBeanVisitor.MapPropertyContext;
import com.google.gwt.autobean.shared.AutoBeanVisitor.PropertyContext;
import com.google.gwt.autobean.shared.impl.AbstractAutoBean;
import com.google.gwt.autobean.shared.impl.AbstractAutoBean.OneShotContext;
import com.google.gwt.core.client.impl.WeakMapping;
import com.google.gwt.core.ext.Generator;
import com.google.gwt.core.ext.GeneratorContext;
import com.google.gwt.core.ext.TreeLogger;
import com.google.gwt.core.ext.UnableToCompleteException;
import com.google.gwt.core.ext.typeinfo.JClassType;
import com.google.gwt.core.ext.typeinfo.JEnumConstant;
import com.google.gwt.core.ext.typeinfo.JMethod;
import com.google.gwt.core.ext.typeinfo.JParameter;
import com.google.gwt.core.ext.typeinfo.JPrimitiveType;
import com.google.gwt.core.ext.typeinfo.JType;
import com.google.gwt.core.ext.typeinfo.TypeOracle;
import com.google.gwt.dev.generator.NameFactory;
import com.google.gwt.editor.rebind.model.ModelUtils;
import com.google.gwt.user.rebind.ClassSourceFileComposerFactory;
import com.google.gwt.user.rebind.SourceWriter;

import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * Generates implementations of AutoBeanFactory.
 */
public class AutoBeanFactoryGenerator extends Generator {

  private GeneratorContext context;
  private String simpleSourceName;
  private TreeLogger logger;
  private AutoBeanFactoryModel model;

  @Override
  public String generate(TreeLogger logger, GeneratorContext context,
      String typeName) throws UnableToCompleteException {
    this.context = context;
    this.logger = logger;

    TypeOracle oracle = context.getTypeOracle();
    JClassType toGenerate = oracle.findType(typeName).isInterface();
    if (toGenerate == null) {
      logger.log(TreeLogger.ERROR, typeName + " is not an interface type");
      throw new UnableToCompleteException();
    }

    String packageName = toGenerate.getPackage().getName();
    simpleSourceName = toGenerate.getName().replace('.', '_') + "Impl";
    PrintWriter pw = context.tryCreate(logger, packageName, simpleSourceName);
    if (pw == null) {
      return packageName + "." + simpleSourceName;
    }

    model = new AutoBeanFactoryModel(logger, toGenerate);

    ClassSourceFileComposerFactory factory = new ClassSourceFileComposerFactory(
        packageName, simpleSourceName);
    factory.setSuperclass(AbstractAutoBeanFactory.class.getCanonicalName());
    factory.addImplementedInterface(typeName);
    SourceWriter sw = factory.createSourceWriter(context, pw);
    for (AutoBeanType type : model.getAllTypes()) {
      writeAutoBean(type);
    }
    writeDynamicMethods(sw);
    writeEnumSetup(sw);
    writeMethods(sw);
    sw.commit(logger);

    return factory.getCreatedClassName();
  }

  private String getBaseMethodDeclaration(JMethod jmethod) {
    // Foo foo, Bar bar, Baz baz
    StringBuilder parameters = new StringBuilder();
    for (JParameter param : jmethod.getParameters()) {
      parameters.append(",").append(
          ModelUtils.getQualifiedBaseSourceName(param.getType())).append(" ").append(
          param.getName());
    }
    if (parameters.length() > 0) {
      parameters = parameters.deleteCharAt(0);
    }

    StringBuilder throwsDeclaration = new StringBuilder();
    if (jmethod.getThrows().length > 0) {
      for (JType thrown : jmethod.getThrows()) {
        throwsDeclaration.append(". ").append(
            ModelUtils.getQualifiedBaseSourceName(thrown));
      }
      throwsDeclaration.deleteCharAt(0);
      throwsDeclaration.insert(0, "throws ");
    }
    String returnName = ModelUtils.getQualifiedBaseSourceName(jmethod.getReturnType());
    assert !returnName.contains("extends");
    return String.format("%s %s(%s) %s", returnName, jmethod.getName(),
        parameters, throwsDeclaration);
  }

  /**
   * Used by {@link #writeShim} to avoid duplicate declarations of Object
   * methods.
   */
  private boolean isObjectMethodImplementedByShim(JMethod jmethod) {
    String methodName = jmethod.getName();
    JParameter[] parameters = jmethod.getParameters();
    switch (parameters.length) {
      case 0:
        return methodName.equals("hashCode") || methodName.equals("toString");
      case 1:
        return methodName.equals("equals")
            && parameters[0].getType().equals(
                context.getTypeOracle().getJavaLangObject());
    }
    return false;
  }

  private void writeAutoBean(AutoBeanType type)
      throws UnableToCompleteException {
    PrintWriter pw = context.tryCreate(logger, type.getPackageNome(),
        type.getSimpleSourceName());
    if (pw == null) {
      // Previously-created
      return;
    }

    ClassSourceFileComposerFactory factory = new ClassSourceFileComposerFactory(
        type.getPackageNome(), type.getSimpleSourceName());
    factory.setSuperclass(AbstractAutoBean.class.getCanonicalName() + "<"
        + type.getPeerType().getQualifiedSourceName() + ">");
    SourceWriter sw = factory.createSourceWriter(context, pw);

    writeShim(sw, type);

    // Instance initializer code to set the shim's association
    sw.println("{ %s.set(shim, %s.class.getName(), this); }",
        WeakMapping.class.getCanonicalName(), AutoBean.class.getCanonicalName());

    // Only simple wrappers have a default constructor
    if (type.isSimpleBean()) {
      // public FooIntfAutoBean(AutoBeanFactory factory) {}
      sw.println("public %s(%s factory) {super(factory);}",
          type.getSimpleSourceName(), AutoBeanFactory.class.getCanonicalName());
    }

    // Clone constructor
    // public FooIntfAutoBean(FooIntfoAutoBean toClone, boolean deepClone) {
    sw.println("public %1$s(%1$s toClone, boolean deep) {",
        type.getSimpleSourceName());
    sw.indentln("super(toClone, deep);");
    sw.println("}");

    // Wrapping constructor
    // public FooIntfAutoBean(AutoBeanFactory factory, FooIntfo wrapped) {
    sw.println("public %s(%s factory, %s wrapped) {",
        type.getSimpleSourceName(), AutoBeanFactory.class.getCanonicalName(),
        type.getPeerType().getQualifiedSourceName());
    sw.indentln("super(factory, wrapped);");
    sw.println("}");

    // public FooIntf as() {return shim;}
    sw.println("public %s as() {return shim;}",
        type.getPeerType().getQualifiedSourceName());

    // public FooIntfAutoBean clone(boolean deep) {
    sw.println("public %s clone(boolean deep) {", type.getQualifiedSourceName());
    // return new FooIntfAutoBean(this, deep);
    sw.indentln("return new %s(this, deep);", type.getSimpleSourceName());
    sw.println("}");

    // public Class<Intf> getType() {return Intf.class;}
    sw.println("public Class<%1$s> getType() {return %1$s.class;}",
        ModelUtils.ensureBaseType(type.getPeerType()).getQualifiedSourceName());

    if (type.isSimpleBean()) {
      writeCreateSimpleBean(sw, type);
    }
    writeTraversal(sw, type);
    sw.commit(logger);
  }

  /**
   * For interfaces that consist of nothing more than getters and setters,
   * create a map-based implementation that will allow the AutoBean's internal
   * state to be easily consumed.
   */
  private void writeCreateSimpleBean(SourceWriter sw, AutoBeanType type) {
    sw.println("@Override protected %s createSimplePeer() {",
        type.getPeerType().getQualifiedSourceName());
    sw.indent();
    // return new FooIntf() {
    sw.println("return new %s() {", type.getPeerType().getQualifiedSourceName());
    sw.indent();
    for (AutoBeanMethod method : type.getMethods()) {
      JMethod jmethod = method.getMethod();
      sw.println("public %s {", getBaseMethodDeclaration(jmethod));
      sw.indent();
      switch (method.getAction()) {
        case GET: {
          // Must handle de-boxing primitive types
          JPrimitiveType primitive = jmethod.getReturnType().isPrimitive();
          if (primitive != null) {
            // Object toReturn = values.get("foo");
            sw.println("Object toReturn = values.get(\"%s\");",
                method.getPropertyName());
            sw.println("if (toReturn == null) {");
            // return 0;
            sw.indentln("return %s;",
                primitive.getUninitializedFieldExpression());
            sw.println("} else {");
            // return (BoxedType) toReturn;
            sw.indentln("return (%s) toReturn;",
                primitive.getQualifiedBoxedSourceName());
            sw.println("}");
          } else {
            // return (ReturnType) values.get(\"foo\");
            sw.println("return (%s) values.get(\"%s\");",
                ModelUtils.getQualifiedBaseSourceName(jmethod.getReturnType()),
                method.getPropertyName());
          }
        }
          break;
        case SET:
          // values.put("foo", parameter);
          sw.println("values.put(\"%s\", %s);", method.getPropertyName(),
              jmethod.getParameters()[0].getName());
          break;
        case CALL:
          // return com.example.Owner.staticMethod(Outer.this, param,
          // param);
          JMethod staticImpl = method.getStaticImpl();
          if (!jmethod.getReturnType().equals(JPrimitiveType.VOID)) {
            sw.print("return ");
          }
          sw.print("%s.%s(%s.this",
              staticImpl.getEnclosingType().getQualifiedSourceName(),
              staticImpl.getName(), type.getSimpleSourceName());
          for (JParameter param : jmethod.getParameters()) {
            sw.print(", %s", param.getName());
          }
          sw.println(");");
          break;
        default:
          throw new RuntimeException();
      }
      sw.outdent();
      sw.println("}");
    }
    sw.outdent();
    sw.println("};");
    sw.outdent();
    sw.println("}");
  }

  /**
   * Write an instance initializer block to populate the creators map.
   */
  private void writeDynamicMethods(SourceWriter sw) {
    sw.println("{");
    sw.indent();
    for (AutoBeanType type : model.getAllTypes()) {
      if (type.isNoWrap()) {
        continue;
      }
      sw.println(
          "creators.put(%s.class, new Creator() {",
          ModelUtils.ensureBaseType(type.getPeerType()).getQualifiedSourceName());
      if (type.isSimpleBean()) {
        sw.indentln("public %1$s create() { return new %1$s(%2$s.this); }",
            type.getQualifiedSourceName(), simpleSourceName);
      } else {
        sw.indentln("public %1$s create() { return null; }",
            type.getQualifiedSourceName());
      }
      // public FooAutoBean create(Object delegate) {
      // return new FooAutoBean((Foo) delegate); }
      sw.indentln("public %1$s create(Object delegate) {"
          + " return new %1$s(%2$s.this, (%3$s) delegate); }",
          type.getQualifiedSourceName(), simpleSourceName,
          type.getPeerType().getQualifiedSourceName());
      sw.println("});");
    }
    sw.outdent();
    sw.println("}");
  }

  private void writeEnumSetup(SourceWriter sw) {
    // Make the deobfuscation model
    Map<String, List<JEnumConstant>> map = new HashMap<String, List<JEnumConstant>>();
    for (Map.Entry<JEnumConstant, String> entry : model.getEnumTokenMap().entrySet()) {
      List<JEnumConstant> list = map.get(entry.getValue());
      if (list == null) {
        list = new ArrayList<JEnumConstant>();
        map.put(entry.getValue(), list);
      }
      list.add(entry.getKey());
    }

    sw.println("@Override protected void initializeEnumMap() {");
    sw.indent();
    for (Map.Entry<JEnumConstant, String> entry : model.getEnumTokenMap().entrySet()) {
      // enumToStringMap.put(Enum.FOO, "FOO");
      sw.println("enumToStringMap.put(%s.%s, \"%s\");",
          entry.getKey().getEnclosingType().getQualifiedSourceName(),
          entry.getKey().getName(), entry.getValue());
    }
    for (Map.Entry<String, List<JEnumConstant>> entry : map.entrySet()) {
      String listExpr;
      if (entry.getValue().size() == 1) {
        JEnumConstant e = entry.getValue().get(0);
        // Collections.singletonList(Enum.FOO)
        listExpr = String.format("%s.<%s<?>> singletonList(%s.%s)",
            Collections.class.getCanonicalName(),
            Enum.class.getCanonicalName(),
            e.getEnclosingType().getQualifiedSourceName(), e.getName());
      } else {
        // Arrays.asList(Enum.FOO, OtherEnum.FOO, ThirdEnum,FOO)
        StringBuilder sb = new StringBuilder();
        boolean needsComma = false;
        sb.append(String.format("%s.<%s<?>> asList(",
            Arrays.class.getCanonicalName(), Enum.class.getCanonicalName()));
        for (JEnumConstant e : entry.getValue()) {
          if (needsComma) {
            sb.append(",");
          }
          needsComma = true;
          sb.append(e.getEnclosingType().getQualifiedSourceName()).append(".").append(
              e.getName());
        }
        sb.append(")");
        listExpr = sb.toString();
      }
      sw.println("stringsToEnumsMap.put(\"%s\", %s);", entry.getKey(), listExpr);
    }
    sw.outdent();
    sw.println("}");
  }

  private void writeMethods(SourceWriter sw) throws UnableToCompleteException {
    for (AutoBeanFactoryMethod method : model.getMethods()) {
      AutoBeanType autoBeanType = method.getAutoBeanType();
      // public AutoBean<Foo> foo(FooSubtype wrapped) {
      sw.println("public %s %s(%s) {",
          method.getReturnType().getQualifiedSourceName(), method.getName(),
          method.isWrapper()
              ? (method.getWrappedType().getQualifiedSourceName() + " wrapped")
              : "");
      if (method.isWrapper()) {
        sw.indent();
        // AutoBean<Foo> toReturn = AutoBeanUtils.getAutoBean(wrapped);
        sw.println("%s toReturn = %s.getAutoBean(wrapped);",
            method.getReturnType().getParameterizedQualifiedSourceName(),
            AutoBeanUtils.class.getCanonicalName());
        sw.println("if (toReturn != null) {return toReturn;}");
        // return new FooAutoBean(Factory.this, wrapped);
        sw.println("return new %s(%s.this, wrapped);",
            autoBeanType.getQualifiedSourceName(), simpleSourceName);
        sw.outdent();
      } else {
        // return new FooAutoBean(Factory.this);
        sw.indentln("return new %s(%s.this);",
            autoBeanType.getQualifiedSourceName(), simpleSourceName);
      }
      sw.println("}");
    }
  }

  private void writeReturnWrapper(SourceWriter sw, AutoBeanType type,
      AutoBeanMethod method) throws UnableToCompleteException {
    if (!method.isValueType() && !method.isNoWrap()) {
      JMethod jmethod = method.getMethod();
      JClassType returnClass = jmethod.getReturnType().isClassOrInterface();
      AutoBeanType peer = model.getPeer(returnClass);

      sw.println("if (toReturn != null) {");
      sw.indent();
      sw.println("if (%s.this.isWrapped(toReturn)) {",
          type.getSimpleSourceName());
      sw.indentln("toReturn = %s.this.getFromWrapper(toReturn);",
          type.getSimpleSourceName());
      sw.println("} else {");
      sw.indent();
      if (peer != null) {
        // toReturn = new FooAutoBean(getFactory(), toReturn).as();
        sw.println("toReturn = new %s(getFactory(), toReturn).as();",
            peer.getQualifiedSourceName());
      }
      sw.outdent();
      sw.println("}");

      sw.outdent();
      sw.println("}");
    }
    // Allow return values to be intercepted
    JMethod interceptor = type.getInterceptor();
    if (interceptor != null) {
      // toReturn = FooCategory.__intercept(FooAutoBean.this, toReturn);
      sw.println("toReturn = %s.%s(%s.this, toReturn);",
          interceptor.getEnclosingType().getQualifiedSourceName(),
          interceptor.getName(), type.getSimpleSourceName());
    }
  }

  /**
   * Create the shim instance of the AutoBean's peer type that lets us hijack
   * the method calls. Using a shim type, as opposed to making the AutoBean
   * implement the peer type directly, means that there can't be any conflicts
   * between methods in the peer type and methods declared in the AutoBean
   * implementation.
   */
  private void writeShim(SourceWriter sw, AutoBeanType type)
      throws UnableToCompleteException {
    // private final FooImpl shim = new FooImpl() {
    sw.println("private final %1$s shim = new %1$s() {",
        type.getPeerType().getQualifiedSourceName());
    sw.indent();
    for (AutoBeanMethod method : type.getMethods()) {
      JMethod jmethod = method.getMethod();
      String methodName = jmethod.getName();
      JParameter[] parameters = jmethod.getParameters();
      if (isObjectMethodImplementedByShim(jmethod)) {
        // Skip any methods declared on Object, since we have special handling
        continue;
      }

      // foo, bar, baz
      StringBuilder arguments = new StringBuilder();
      {
        for (JParameter param : parameters) {
          arguments.append(",").append(param.getName());
        }
        if (arguments.length() > 0) {
          arguments = arguments.deleteCharAt(0);
        }
      }

      sw.println("public %s {", getBaseMethodDeclaration(jmethod));
      sw.indent();

      // Use explicit enclosing this reference to avoid method conflicts
      sw.println("%s.this.checkWrapped();", type.getSimpleSourceName());

      switch (method.getAction()) {
        case GET:
          /*
           * The getter call will ensure that any non-value return type is
           * definitely wrapped by an AutoBean instance.
           */
          // Foo toReturn=FooAutoBean.this.get("getFoo", getWrapped().getFoo());
          sw.println(
              "%s toReturn = %3$s.this.get(\"%2$s\", getWrapped().%2$s());",
              ModelUtils.getQualifiedBaseSourceName(jmethod.getReturnType()),
              methodName, type.getSimpleSourceName());

          // Non-value types might need to be wrapped
          writeReturnWrapper(sw, type, method);
          sw.println("return toReturn;");
          break;
        case SET:
          sw.println("%s.this.checkFrozen();", type.getSimpleSourceName());
          // getWrapped().setFoo(foo);
          sw.println("%s.this.getWrapped().%s(%s);",
              type.getSimpleSourceName(), methodName, parameters[0].getName());
          // FooAutoBean.this.set("setFoo", foo);
          sw.println("%s.this.set(\"%s\", %s);", type.getSimpleSourceName(),
              methodName, parameters[0].getName());
          break;
        case CALL:
          // XXX How should freezing and calls work together?
          // sw.println("checkFrozen();");
          if (JPrimitiveType.VOID.equals(jmethod.getReturnType())) {
            // getWrapped().doFoo(params);
            sw.println("%s.this.getWrapped().%s(%s);",
                type.getSimpleSourceName(), methodName, arguments);
            // call("doFoo", null, params);
            sw.println("%s.this.call(\"%s\", null%s %s);",
                type.getSimpleSourceName(), methodName, arguments.length() > 0
                    ? "," : "", arguments);
          } else {
            // Type toReturn = getWrapped().doFoo(params);
            sw.println(
                "%s toReturn = %s.this.getWrapped().%s(%s);",
                ModelUtils.ensureBaseType(jmethod.getReturnType()).getQualifiedSourceName(),
                type.getSimpleSourceName(), methodName, arguments);
            // Non-value types might need to be wrapped
            writeReturnWrapper(sw, type, method);
            // call("doFoo", toReturn, params);
            sw.println("%s.this.call(\"%s\", toReturn%s %s);",
                type.getSimpleSourceName(), methodName, arguments.length() > 0
                    ? "," : "", arguments);
            sw.println("return toReturn;");
          }
          break;
        default:
          throw new RuntimeException();
      }
      sw.outdent();
      sw.println("}");
    }

    // Delegate equals(), hashCode(), and toString() to wrapped object
    sw.println("@Override public boolean equals(Object o) {");
    sw.indentln("return this == o || getWrapped().equals(o);");
    sw.println("}");
    sw.println("@Override public int hashCode() {");
    sw.indentln("return getWrapped().hashCode();");
    sw.println("}");
    sw.println("@Override public String toString() {");
    sw.indentln("return getWrapped().toString();");
    sw.println("}");

    // End of shim field declaration and assignment
    sw.outdent();
    sw.println("};");
  }

  /**
   * Generate traversal logic.
   */
  private void writeTraversal(SourceWriter sw, AutoBeanType type) {
    NameFactory names = new NameFactory();
    sw.println(
        "@Override protected void traverseProperties(%s visitor, %s ctx) {",
        AutoBeanVisitor.class.getCanonicalName(),
        OneShotContext.class.getCanonicalName());
    sw.indent();

    for (AutoBeanMethod method : type.getMethods()) {
      if (!method.getAction().equals(Action.GET)) {
        continue;
      }

      AutoBeanMethod setter = null;
      // If it's not a simple bean type, try to find a real setter method
      if (!type.isSimpleBean()) {
        for (AutoBeanMethod maybeSetter : type.getMethods()) {
          if (maybeSetter.getAction().equals(Action.SET)
              && maybeSetter.getPropertyName().equals(method.getPropertyName())) {
            setter = maybeSetter;
            break;
          }
        }
      }

      // The type of property influences the visitation
      String valueExpression = String.format(
          "%1$s value = (%1$s) %2$s.getAutoBean(as().%3$s());",
          AbstractAutoBean.class.getCanonicalName(),
          AutoBeanUtils.class.getCanonicalName(), method.getMethod().getName());
      String visitMethod;
      Class<?> propertyContextType;
      if (method.isCollection()) {
        propertyContextType = CollectionPropertyContext.class;
        visitMethod = "Collection";
      } else if (method.isMap()) {
        propertyContextType = MapPropertyContext.class;
        visitMethod = "Map";
      } else if (method.isValueType()) {
        propertyContextType = PropertyContext.class;
        valueExpression = String.format("Object value = as().%s();",
            method.getMethod().getName());
        visitMethod = "Value";
      } else {
        visitMethod = "Reference";
        propertyContextType = PropertyContext.class;
      }

      /*
       * Make the PropertyContext that lets us call the setter. We allow
       * multiple methods to be bound to the same property (e.g. to allow JSON
       * payloads to be interpreted as different types). The leading underscore
       * allows purely numeric property names, which are valid JSON map keys.
       */
      String propertyContextName = names.createName("_"
          + method.getPropertyName() + "PropertyContext");
      sw.println("class %s implements %s {", propertyContextName,
          propertyContextType.getCanonicalName());
      sw.indent();
      sw.println("public boolean canSet() { return %s; }", type.isSimpleBean()
          || setter != null);
      if (method.isCollection()) {
        // Will return the collection's element type or null if not a collection
        sw.println(
            "public Class<?> getElementType() { return %s.class; }",
            ModelUtils.ensureBaseType(method.getElementType()).getQualifiedSourceName());
      } else if (method.isMap()) {
        // Will return the map's value type
        sw.println(
            "public Class<?> getValueType() { return %s.class; }",
            ModelUtils.ensureBaseType(method.getValueType()).getQualifiedSourceName());
        // Will return the map's key type
        sw.println(
            "public Class<?> getKeyType() { return %s.class; }",
            ModelUtils.ensureBaseType(method.getKeyType()).getQualifiedSourceName());
      }
      // Return the property type
      sw.println(
          "public Class<?> getType() { return %s.class; }",
          ModelUtils.ensureBaseType(method.getMethod().getReturnType()).getQualifiedSourceName());
      sw.println("public void set(Object obj) { ");
      if (setter != null) {
        // Prefer the setter if one exists
        // as().setFoo((Foo) obj);
        sw.indentln(
            "as().%s((%s) obj);",
            setter.getMethod().getName(),
            ModelUtils.ensureBaseType(
                setter.getMethod().getParameters()[0].getType()).getQualifiedSourceName());
      } else if (type.isSimpleBean()) {
        // Otherwise, fall back to a map assignment
        sw.indentln("values.put(\"%s\", obj);", method.getPropertyName());
      } else {
        sw.indentln("throw new UnsupportedOperationException(\"No setter\");");
      }
      sw.println("}");
      sw.outdent();
      sw.println("}");

      sw.print("{");
      sw.indent();
      sw.println("%1$s %1$s = new %1$s();", propertyContextName);

      // Call the visit methods
      sw.println(valueExpression);
      // if (visitor.visitReferenceProperty("foo", value, ctx))
      sw.println("if (visitor.visit%sProperty(\"%s\", value, %s))",
          visitMethod, method.getPropertyName(), propertyContextName);
      if (!method.isValueType()) {
        // Cycle-detection in AbstractAutoBean.traverse
        sw.indentln("if (value != null) { value.traverse(visitor, ctx); }");
      }
      // visitor.endVisitorReferenceProperty("foo", value, ctx);
      sw.println("visitor.endVisit%sProperty(\"%s\", value, %s);", visitMethod,
          method.getPropertyName(), propertyContextName);
      sw.outdent();
      sw.print("}");
    }
    sw.outdent();
    sw.println("}");
  }
}