Main.scala

package tscfg

import java.io.{File, PrintWriter}
import java.util.Date

import com.typesafe.config.ConfigFactory
import tscfg.generators.java.JavaGen
import tscfg.generators.scala.ScalaGen
import tscfg.generators.{Generator, GenOpts}

/**
  * The main program. Run with no arguments to see usage.
  */
object Main {
  val version: String = ConfigFactory.load().getString("tscfg.version")

  val defaultGenOpts = GenOpts(
    packageName = "tscfg.example",
    className = "ExampleCfg",
    j7 = false
  )

  val defaultDestDir: String = "/tmp"

  val usage: String = s"""
                         |tscfg $version
                         |Usage:  tscfg.Main --spec inputFile [options]
                         |Options (default):
                         |  --pn <packageName>                                     (${defaultGenOpts.packageName})
                         |  --cn <className>                                       (${defaultGenOpts.className})
                         |  --dd <destDir>                                         ($defaultDestDir)
                         |  --j7                  generate code for java <= 7      (8)
                         |  --scala               generate scala code              (java)
                         |  --java                generate java code               (the default)
                         |Output is written to $$destDir/$$className.ext
    """.stripMargin

  case class CmdLineOpts(inputFilename: Option[String] = None,
                         packageName: String = defaultGenOpts.packageName,
                         className: String =   defaultGenOpts.className,
                         destDir: String = defaultDestDir,
                         j7: Boolean = false,
                         language: String = "java"
                        )

  def main(args: Array[String]): Unit = {
    generate(getOpts(args.toList))
  }

  private def getOpts(args: List[String]): CmdLineOpts = {
    if (args.isEmpty) {
      println(usage)
      sys.exit(0)
    }
    def traverseList(list: List[String], opts: CmdLineOpts = CmdLineOpts()): CmdLineOpts = {
      def chkVal(v: String): String = {
        if (!v.startsWith("-")) v
        else {
          println( s"""error: argument looks like a switch: $v""")
          sys.exit(0)
        }
      }
      list match {
        case "--spec" :: filename :: rest =>
          traverseList(rest, opts.copy(inputFilename = Some(chkVal(filename))))

        case "--pn" :: packageName :: rest =>
          traverseList(rest, opts.copy(packageName = chkVal(packageName)))

        case "--cn" :: className :: rest =>
          traverseList(rest, opts.copy(className = chkVal(className)))

        case "--dd" :: destDir :: rest =>
          traverseList(rest, opts.copy(destDir = chkVal(destDir)))

        case "--j7" :: rest =>
          traverseList(rest, opts.copy(j7 = true))

        case "--scala" :: rest =>
          traverseList(rest, opts.copy(language = "scala"))

        case "--java" :: rest =>
          traverseList(rest, opts.copy(language = "java"))

        case opt :: nil =>
          println( s"""missing argument or unknown option: $opt""")
          sys.exit(0)

        case nil => opts
      }
    }

    val opts = traverseList(args)

    opts.inputFilename.getOrElse {
      println("--spec not given")
      sys.exit(1)
    }
    opts
  }

  private def generate(opts: CmdLineOpts): Unit = {
    require(opts.inputFilename.isDefined)

    val ext = opts.language

    val inputFilename = opts.inputFilename.get
    val destFilename  = s"${opts.destDir}/${opts.className}.$ext"
    val destFile = new File(destFilename)
    val out = new PrintWriter(destFile)

    val genOpts = GenOpts(opts.packageName, opts.className, opts.j7)

    println(s"parsing: $inputFilename")
    val source = io.Source.fromFile(new File(inputFilename)).mkString.trim

    val buildResult = ModelBuilder(source)
    val objectType = buildResult.objectType

    //println("\nobjectType:\n  |" + objectType.format().replaceAll("\n", "\n  |"))

    if (buildResult.warnings.nonEmpty) {
      println("WARNINGS:")
      buildResult.warnings.foreach(w ⇒ println(s"   line ${w.line}: ${w.source}: ${w.message}"))
    }

    println(s"generating: $destFile")
    val pw = out match {
      case w: PrintWriter => w
      case w => new PrintWriter(w)
    }
    val generator: Generator = opts.language match {
      case "java"  => new JavaGen(genOpts)
      case "scala" => new ScalaGen(genOpts)
    }
    val results = generator.generate(objectType)

    pw.println(
      s"""// generated by tscfg $version on ${new Date()}
         |// source: $inputFilename"
         |
         |${results.code}
      """.stripMargin
    )

    out.close()

    /*
        opts.templates foreach { genTemplate =>
          val destFile = new File(genTemplate.filename)
          printf("%10s: %s\n", genTemplate.what, destFile.getAbsolutePath)
          val out = new PrintWriter(destFile)
          templateGenerator.generate(genTemplate.what, root, out)
          out.close()
        }
    */
  }
}