/* sbt -- Simple Build Tool
 * Copyright 2009, 2010  Mark Harrah
 */
package xsbt
package datatype

import java.io.File
import sbt.IO.write

import Generator._
import java.util.Locale

abstract class GeneratorBase(val basePkgName: String, val baseDirectory: File) {
  def writeDefinitions(ds: Iterable[Definition]) = Generator.writeDefinitions(ds)(writeDefinition)
  def writeDefinition(d: Definition) = d match { case e: EnumDef => writeEnum(e); case c: ClassDef => writeClass(c) }
  def writeEnum(e: EnumDef) {
    val content =
      "public enum " + e.name + " {" +
        e.members.mkString("\n\t", ",\n\t", "\n") +
        "}"
    writeSource(e.name, basePkgName, content)
  }
  def writeClass(c: ClassDef): Unit

  def writeSource(name: String, pkgName: String, content: String) {
    val file = new File(new File(baseDirectory, packagePath(pkgName)), name + ".java")
    file.getParentFile.mkdirs()
    write(file, "package " + pkgName + ";\n\n" + content)
  }
  private def packagePath(pkgName: String) = pkgName.replace('.', File.separatorChar)
}

/**
 * Creates immutable datatype classes in Java from the intermediate Definition representation.
 *
 * A ClassDef is written as a class with an optional parent class.  The class has a single constructor with
 * parameters for all declared and inherited members.  Declared members are listed first in the constructor.
 * Inherited members are passed to the super constructor.  The value of each member is held in a private
 * final field and is accessed by a method of the same name.
 *
 * A toString method is generated for debugging.
 * The classes implement java.io.Serializable.
 *
 * .@param baseDirectory output directory for sources
 * @param pkgName package that classes will be defined in
 */
class ImmutableGenerator(pkgName: String, baseDir: File) extends GeneratorBase(pkgName, baseDir) {
  def writeClass(c: ClassDef): Unit = writeSource(c.name, basePkgName, classContent(c))
  def classContent(c: ClassDef): String =
    {
      val abstractStr = if (c.isAbstract) "abstract " else "final "
      val allMembers = c.allMembers.map(normalize)
      val normalizedMembers = c.members.map(normalize)
      val fields = normalizedMembers.map(m => "private final " + m.asJavaDeclaration(false) + ";")
      val accessors = normalizedMembers.map(m => "public final " + m.asJavaDeclaration(true) + "()\n\t{\n\t\treturn " + m.asGet + ";\n\t}")
      val parameters = allMembers.map(_.asJavaDeclaration(false))
      val assignments = normalizedMembers.map(m => "this." + m.name + " = " + m.name + ";")
      val superConstructor =
        {
          val inherited = c.inheritedMembers
          if (inherited.isEmpty) "" else "super(" + inherited.map(_.name).mkString(", ") + ");\n\t\t"
        }

      val constructor = "public " + c.name + "(" + parameters.mkString(", ") + ")\n\t" +
        "{\n\t\t" +
        superConstructor +
        assignments.mkString("\n\t\t") + "\n\t" +
        "}"
      "import java.util.Arrays;\n" +
        "import java.util.List;\n" +
        "public " + abstractStr + "class " + c.name + c.parent.map(" extends " + _.name + " ").getOrElse(" implements java.io.Serializable") + "\n" +
        "{\n\t" +
        constructor + "\n\t" +
        (fields ++ accessors).mkString("\n\t") + "\n" +
        (if (!c.isAbstract) "\t" + equalsMethod(c) + "\n\t" + hashCodeMethod(c) + "\n\t" + toStringMethod(c) + "\n" else "") +
        "}\n"
    }
}

object Generator {
  def methodSignature(modifiers: String, returnType: String, name: String, parameters: String) =
    modifiers + " " + returnType + " " + name + "(" + parameters + ")"
  def method(modifiers: String, returnType: String, name: String, parameters: String, body: String) =
    methodSignature(modifiers, returnType, name, parameters) + "\n\t{\n\t\t " + body + "\n\t}"
  def fieldToString(name: String, single: Boolean) = "\"" + name + ": \" + " + fieldString(name + "()", single)
  def fieldString(arg: String, single: Boolean) = if (single) arg else "Arrays.toString(" + arg + ")"
  def fieldEquals(arg: String, single: Boolean, primitive: Boolean) = {
    if (single) {
      if (primitive) arg + " == o." + arg else arg + ".equals(o." + arg + ")"
    } else {
      "Arrays." + (if (primitive) "equals" else "deepEquals") + "(" + arg + ", o." + arg + ")"
    }
  }
  def normalize(m: MemberDef): MemberDef =
    m.mapType(tpe => if (isPrimitive(tpe)) tpe.toLowerCase(Locale.ENGLISH) else tpe)
  def isPrimitive(tpe: String) = primitives(tpe.toLowerCase(Locale.ENGLISH))
  private val primitives = Set("int", "boolean", "float", "long", "short", "byte", "char", "double")

  def equalsMethod(c: ClassDef): String =
    {
      val content = if (c.hasLazyMembers) {
        "return this == obj;  // We have lazy members, so use object identity to avoid circularity."
      } else {
        val allMembers = c.allMembers.map(normalize)
        val memberComparisons = if (allMembers.isEmpty) "true" else allMembers.map(m => fieldEquals(m.name + "()", m.single, isPrimitive(m.tpe))).mkString(" && ")
        "if (this == obj) {\n\t\t\t return true;\n\t\t} else if (!(obj instanceof " + c.name + ")) {\n\t\t\t return false;\n\t\t} else {\n\t\t\t" + c.name + " o = (" + c.name + ")obj;\n\t\t\treturn " + memberComparisons + ";\n\t\t}"
      }
      method("public", "boolean", "equals", "Object obj", content)
    }

  def hashCodeMethod(c: ClassDef): String =
    {
      def hashCodeExprForMember(m: MemberDef) =
        {
          val primitive = isPrimitive(m.tpe)
          val f = m.name + "()" // Assumes m has already been normalized.
          if (m.single) {
            if (primitive) {
              m.tpe.toLowerCase match {
                case "boolean" => "(" + f + " ? 0 : 1)"
                case "long"    => "(int)(" + f + " ^ (" + f + " >>> 32))"
                case "float"   => "Float.floatToIntBits(" + f + ")"
                case "double"  => "(int)(Double.doubleToLongBits(" + f + ") ^ (Double.doubleToLongBits(" + f + ") >>> 32))"
                case "int"     => f
                case _         => "(int)" + f
              }
            } else {
              f + ".hashCode()"
            }
          } else {
            "Arrays." + (if (primitive) "hashCode" else "deepHashCode") + "(" + f + ")"
          }
        }
      val hashCodeExpr = if (c.hasLazyMembers) {
        "super.hashCode()"
      } else {
        val allMembers = c.allMembers.map(normalize)
        val memberHashCodes = allMembers.map(hashCodeExprForMember)
        ("17" /: memberHashCodes) { "37 * (" + _ + ") + " + _ }
      }
      method("public", "int", "hashCode", "", "return " + hashCodeExpr + ";")
    }

  def toStringMethod(c: ClassDef): String =
    {
      val content = if (c.hasLazyMembers) {
        "return super.toString();"
      } else {
        val allMembers = c.allMembers.map(normalize)
        val parametersString = if (allMembers.isEmpty) "\"\"" else allMembers.map(m => fieldToString(m.name, m.single)).mkString(" + \", \" + ")
        "return \"" + c.name + "(\" + " + parametersString + " + \")\";"
      }
      method("public", "String", "toString", "", content)
    }

  def writeDefinitions(ds: Iterable[Definition])(writeDefinition: Definition => Unit) {
    val (_, duplicates) =
      ((Set[String](), Set[String]()) /: ds.map(_.name)) {
        case ((nameSet, duplicates), name) =>
          if (nameSet.contains(name)) (nameSet, duplicates + name) else (nameSet + name, duplicates)
      }
    if (duplicates.isEmpty)
      ds.foreach(writeDefinition)
    else
      sys.error("Duplicate names:\n\t" + duplicates.mkString("\n\t"))
  }
  def implName(name: String) = name + "0"
}