package mayton.image

object ScalaMain {

  val u = 1

  var glx: Int = 0
  var gly: Int = 0

  def linerel(x: Int, y: Int) {
    glx += x
    gly += y
    printf("%d,%d\n", glx, gly)
  }

  def moveto(x: Int, y: Int) {
    glx = x
    gly = y
    printf("%d,%d\n", glx, gly)
  }

  def a(i: Int) {
    if (i > 0) {
      d(i - 1)
      linerel(+u, 0)
      a(i - 1)
      linerel(0, u)
      a(i - 1)
      linerel(-u, 0)
      c(i - 1)
    }
  }

  def b(i: Int) {
    if (i > 0) {
      c(i - 1)
      linerel(-u, 0)
      b(i - 1)
      linerel(0, -u)
      b(i - 1)
      linerel(u, 0)
      d(i - 1)
    }
  }

  def c(i: Int) {
    if (i > 0) {
      b(i - 1)
      linerel(0, -u)
      c(i - 1)
      linerel(-u, 0)
      c(i - 1)
      linerel(0, u)
      a(i - 1)
    }
  }

  def d(i: Int) {
    if (i > 0) {
      a(i - 1)
      linerel(0, u)
      d(i - 1)
      linerel(u, 0)
      d(i - 1)
      linerel(0, -u)
      b(i - 1)
    }
  }

  def flp2(arg1: Int): Int = {
    var x = arg1
    x = x | (x >> 1)
    x = x | (x >> 2)
    x = x | (x >> 4)
    x = x | (x >> 8)
    x = x | (x >> 16)
    x - (x >> 1)
  }

  def clp2(arg1: Int): Int = {
    var x = arg1
    x = x - 1
    x = x | (x >> 1)
    x = x | (x >> 2)
    x = x | (x >> 4)
    x = x | (x >> 8)
    x = x | (x >> 16)
    x + 1
  }

  def nlz(arg1: Int): Int = {
    var n: Int = 0
    var x = arg1
    if (x == 0){
      return 32
    }
    n = 1
    if ((x >> 16) == 0) {
      n += 16
      x <<= 16
    }
    if ((x >> 24) == 0) {
      n += 8
      x <<= 8
    }
    if ((x >> 28) == 0) {
      n += 4
      x <<= 4
    }
    if ((x >> 30) == 0) {
      n += 2
      x <<= 2
    }
    n = n - (x >> 31)
    n
  }

  def log2up(x: Int): Int = {
    if (x < 1)
      0
    else
      32 - nlz(x - 1)
  }

  def main(args: Array[String]): Unit = {


    if (args.length == 0) {

      printf("\nGilbert Route 1.0 (c) Mayton and SQL.RU. Written in 'Scala' :)\n")
      printf("\nUsage: gilbertroute [ { level=N | size=M } [binaryout]] [help]\n")
      printf("\nWhere:\n")
      printf("\n       M          : { 32 | 64 | 128 | 256 ... etc powers of two} ")
      printf("\n       N          : { 1,2,3...}")
      printf("\n")
      System.exit(-1)

    } else {

      var level:Int = -1
      var size:Int = -1
      val arg1 = args(0)

      if (arg1.substring(0,5) == "size="){
        val size:Int = arg1.substring(5).toInt
        if (size<=0){
          printf("\nGilbertroute: Error! Argument size cannot be zero or negative.\n")
          System.exit( -3 )
        }
        level = MathUtils.log2up(size)
      } else if (arg1.substring(0,6)=="level="){
        level = arg1.substring(6).toInt
        if (level<0){
          printf("\nGilbertroute: Error! Argument level cannot be negative.\n")
          System.exit( -3 )
        }
      }

      if (level>=0){
        moveto(0, 0)
        a(level)
        System.exit( 0 )
      } else {
        printf("\nGilbertroute: Error! Unrecognized argument.\n")
        System.exit( -2 )
      }
    }

  }
}