package java.util

import scala.annotation.switch
import scala.scalajs.js

import java.io._
import java.lang._

final class Formatter(private val dest: Appendable) extends Closeable with Flushable {
  import Formatter._

  var closed = false

  def this() = this(new StringBuilder())

  def close(): Unit = {
    if (!closed) {
      dest match {
        case cl: Closeable => cl.close()
        case _ =>
      }
    }
    closed = true
  }

  def flush(): Unit = ifNotClosed {
    dest match {
      case fl: Flushable => fl.flush()
      case _ =>
    }
  }

  // Begin implem of format()

  def format(format_in: String, args: Array[AnyRef]): Formatter = ifNotClosed {
    import js.Any.fromDouble // to have .toFixed and .toExponential on Doubles

    var fmt: String = format_in
    var lastImplicitIndex: Int = 0
    var lastIndex: Int = 0 // required for < flag

    while (!fmt.isEmpty) {
      fmt match {
        case RegularChunk(matchResult) =>
          fmt = fmt.substring(matchResult(0).get.length)
          dest.append(matchResult(0).get)

        case DoublePercent(_) =>
          fmt = fmt.substring(2)
          dest.append('%')

        case EOLChunk(_) =>
          fmt = fmt.substring(2)
          dest.append('\n')

        case FormattedChunk(matchResult) =>
          fmt = fmt.substring(matchResult(0).get.length)

          val flags = matchResult(2).get
          def hasFlag(flag: String) = flags.indexOf(flag) >= 0

          val indexStr = matchResult(1).getOrElse("")
          val index = if (!indexStr.isEmpty) {
            Integer.parseInt(indexStr)
          } else if (hasFlag("<")) {
            lastIndex
          } else {
            lastImplicitIndex += 1
            lastImplicitIndex
          }
          lastIndex = index
          if (index <= 0 || index > args.length)
            throw new MissingFormatArgumentException(matchResult(5).get)
          val arg = args(index-1)

          val widthStr = matchResult(3).getOrElse("")
          val hasWidth = !widthStr.isEmpty
          val width =
            if (hasWidth) Integer.parseInt(widthStr)
            else 0

          val precisionStr = matchResult(4).getOrElse("")
          val hasPrecision = !precisionStr.isEmpty
          val precision =
            if (hasPrecision) Integer.parseInt(precisionStr)
            else 0

          val conversion = matchResult(5).get.charAt(0)

          def intArg: Int = (arg: Any) match {
            case arg: Int  => arg
            case arg: Char => arg.toInt
          }
          def numberArg: scala.Double = (arg: Any) match {
            case arg: Number => arg.doubleValue()
            case arg: Char   => arg.toDouble
          }

          def padCaptureSign(argStr: String, prefix: String) = {
            val firstChar = argStr.charAt(0)
            if (firstChar == '+' || firstChar == '-')
              pad(argStr.substring(1), firstChar+prefix)
            else
              pad(argStr, prefix)
          }

          def strRepeat(s: String, times: Int) = {
            var result: String = ""
            var i = times
            while (i > 0) {
              result += s
              i -= 1
            }
            result
          }

          def with_+(s: String, preventZero: scala.Boolean = false) = {
            if (s.charAt(0) != '-') {
              if (hasFlag("+"))
                pad(s, "+", preventZero)
              else if (hasFlag(" "))
                pad(s, " ", preventZero)
              else
                pad(s, "", preventZero)
            } else {
              if (hasFlag("("))
                pad(s.substring(1) + ")", "(", preventZero)
              else
                pad(s.substring(1), "-", preventZero)
            }
          }

          def pad(argStr: String, prefix: String = "",
                  preventZero: Boolean = false) = {
            val prePadLen = argStr.length + prefix.length

            val padStr = {
              if (width <= prePadLen) {
                prefix + argStr
              } else {
                val padRight = hasFlag("-")
                val padZero = hasFlag("0") && !preventZero
                val padLength = width - prePadLen
                val padChar: String = if (padZero) "0" else " "
                val padding = strRepeat(padChar, padLength)

                if (padZero && padRight)
                  throw new java.util.IllegalFormatFlagsException(flags)
                else if (padRight) prefix + argStr  + padding
                else if (padZero)  prefix + padding + argStr
                else padding + prefix + argStr
              }
            }

            val casedStr =
              if (conversion.isUpper) padStr.toUpperCase()
              else padStr
            dest.append(casedStr)
          }

          (conversion: @switch) match {
            case 'b' | 'B' => pad { arg match {
              case null => "false"
              case b: Boolean => String.valueOf(b)
              case _ => "true"
            } }
            case 'h' | 'H' => pad {
              if (arg eq null) "null"
              else Integer.toHexString(arg.hashCode)
            }
            case 's' | 'S' => arg match {
              case null if !hasFlag("#") => pad("null")
              case formattable: Formattable =>
                val flags = (
                  (if (hasFlag("-"))       FormattableFlags.LEFT_JUSTIFY else 0) |
                  (if (hasFlag("#"))       FormattableFlags.ALTERNATE    else 0) |
                  (if (conversion.isUpper) FormattableFlags.UPPERCASE    else 0)
                )

                formattable.formatTo(this, flags,
                                     if (hasWidth)     width.toInt     else -1,
                                     if (hasPrecision) precision.toInt else -1)
                None // no further processing
              case t: AnyRef if !hasFlag("#") => pad(t.toString)
              case _ =>
                throw new FormatFlagsConversionMismatchException("#", 's')
            }
            case 'c' | 'C' =>
              pad(js.String.fromCharCode(intArg))
            case 'd' =>
              with_+(numberArg.toString())
            case 'o' =>
              val str = (arg: Any) match {
                case arg: scala.Int  => Integer.toOctalString(arg)
                case arg: scala.Long => Long.toOctalString(arg)
              }
              padCaptureSign(str, if (hasFlag("#")) "0" else "")
            case 'x' | 'X' =>
              val str = (arg: Any) match {
                case arg: scala.Int  => Integer.toHexString(arg)
                case arg: scala.Long => Long.toHexString(arg)
              }
              padCaptureSign(str, if (hasFlag("#")) "0x" else "")
            case 'e' | 'E' =>
              sciNotation(if (hasPrecision) precision else 6)
            case 'g' | 'G' =>
              val m = Math.abs(numberArg)
              // precision handling according to JavaDoc
              // precision here means number of significant digits
              // not digits after decimal point
              val p =
                if (!hasPrecision) 6
                else if (precision == 0) 1
                else precision
              // between 1e-4 and 10e(p): display as fixed
              if (m >= 1e-4 && m < Math.pow(10, p)) {
                val sig = Math.ceil(Math.log10(m))
                with_+(numberArg.toFixed(Math.max(p - sig, 0)))
              } else sciNotation(p - 1)
            case 'f' =>
              with_+({
                // JavaDoc: 6 is default precision
                numberArg.toFixed(if (hasPrecision) precision else 6)
              }, numberArg.isNaN || numberArg.isInfinite)
          }

          def sciNotation(precision: Int) = {
            val exp = numberArg.toExponential(precision)
            with_+({
              // check if we need additional 0 padding in exponent
              // JavaDoc: at least 2 digits
              if ("e" == exp.charAt(exp.length - 3)) {
                exp.substring(0, exp.length - 1) + "0" +
                  exp.charAt(exp.length - 1)
              } else exp
            }, numberArg.isNaN || numberArg.isInfinite)
          }
      }
    }

    this
  }

  def ioException(): IOException = null
  def locale(): Locale = ifNotClosed { null }
  def out(): Appendable = ifNotClosed { dest }

  override def toString(): String = out().toString()

  @inline private def ifNotClosed[T](body: => T): T =
    if (closed) throwClosedException()
    else body

  private def throwClosedException(): Nothing =
    throw new FormatterClosedException()

}

object Formatter {

  private class RegExpExtractor(val regexp: js.RegExp) {
    def unapply(str: String): Option[js.RegExp.ExecResult] = {
      Option(regexp.exec(str))
    }
  }

  private val RegularChunk = new RegExpExtractor(new js.RegExp("""^[^\x25]+"""))
  private val DoublePercent = new RegExpExtractor(new js.RegExp("""^\x25{2}"""))
  private val EOLChunk = new RegExpExtractor(new js.RegExp("""^\x25n"""))
  private val FormattedChunk = new RegExpExtractor(new js.RegExp(
      """^\x25(?:([1-9]\d*)\$)?([-#+ 0,\(<]*)(\d*)(?:\.(\d+))?([A-Za-z])"""))

}