(.module:
  lux
  (lux (control [monad #+ do])
       (data text/format)
       [macro]
       (macro [code]
              ["s" syntax #+ syntax:])
       [io #+ Process])
  [//]
  (luxc (lang (host [js #+ JS Expression Statement]))))

(def: prefix Text "LuxRuntime")

(def: #export unit Expression (%t //.unit))

(def: (flag value)
  (-> Bit JS)
  (if value
    (%t "")
    "null"))

(def: (variant' tag last? value)
  (-> Expression Expression Expression Expression)
  (js.object (list [//.variant-tag-field tag]
                   [//.variant-flag-field last?]
                   [//.variant-value-field value])))

(def: #export (variant tag last? value)
  (-> Nat Bit Expression Expression)
  (variant' (%i (.int tag)) (flag last?) value))

(def: none
  Expression
  (variant +0 #0 unit))

(def: some
  (-> Expression Expression)
  (variant +1 #1))

(def: left
  (-> Expression Expression)
  (variant +0 #0))

(def: right
  (-> Expression Expression)
  (variant +1 #1))

(type: Runtime JS)

(def: (runtime-name name)
  (-> Text Text)
  (format prefix "$" name))

(def: (feature name definition)
  (-> Text (-> Text Expression) Statement)
  (format "var " name " = " (definition name) ";\n"))

(syntax: (runtime-implementation-name {runtime-name s.local-symbol})
  (wrap (list (code.local-symbol (format "__" runtime-name)))))

(template: (runtime: <lux-name> <js-name> <js-definition>)
  (def: #export <lux-name> Text (runtime-name <js-name>))
  (`` (def: ((~' ~~) (runtime-implementation-name <lux-name>))
        Runtime
        (feature <lux-name>
                 (function ((~' _) (~' @))
                   <js-definition>)))))

(def: #export (int value)
  (-> Int Expression)
  (format "({"
          //.int-high-field " : " (|> value .nat //.high .int %i)
          ", "
          //.int-low-field " : " (|> value .nat //.low .int %i)
          "})"))

(def: #export frac
  (-> Frac Expression)
  js.number)

(runtime: lux//try "runTry"
  (format "(function " @ "(op) {"
          (format "try {"
                  (format "return " (right "op(null)") ";")
                  "}"
                  "catch(ex) {"
                  (format "return " (left "ex.toString()") ";")
                  "}")
          "})"))

(runtime: lux//program-args "programArgs"
  (format "(function " @ "() {"
          (format "if(typeof process !== 'undefined' && process.argv) {"
                  (format (format "var result = " none ";")
                          "for(var idx = process.argv.length-1; idx >= 0; idx--) {"
                          (format "result = " (some "[process.argv[idx],result]") ";")
                          "}")
                  (format "return result;")
                  "}"
                  "else {"
                  (format "return " none ";")
                  "}")
          "})"))

(def: runtime//lux
  Runtime
  (format __lux//try
          __lux//program-args))

(runtime: product//left "product_left"
  (format "(function " @ "(product,index) {"
          "var index_min_length = (index+1);"
          "if(product.length > index_min_length) {"
          ## No need for recursion
          "return product[index];"
          "}"
          "else {"
          ## Needs recursion
          "return " @ "(product[product.length - 1], (index_min_length - product.length));"
          "}"
          "})"))

(runtime: product//right "product_right"
  (format "(function " @ "(product,index) {"
          "var index_min_length = (index+1);"
          "if(product.length === index_min_length) {"
          ## Last element.
          "return product[index];"
          "}"
          "else if(product.length < index_min_length) {"
          ## Needs recursion
          "return " @ "(product[product.length - 1], (index_min_length - product.length));"
          "}"
          "else {"
          ## Must slice
          "return product.slice(index);"
          "}"
          "})"))

(runtime: sum//get "sum_get"
  (let [no-match "return null;"
        sum-tag (format "sum." //.variant-tag-field)
        sum-flag (format "sum." //.variant-flag-field)
        sum-value (format "sum." //.variant-value-field)
        is-last? (format sum-flag " === ''")
        extact-match (format "return " sum-value ";")
        test-recursion (format "if(" is-last? ") {"
                               ## Must recurse.
                               "return " @ "(" sum-value ", (wantedTag - " sum-tag "), wantsLast);"
                               "}"
                               "else { " no-match " }")]
    (format "(function " @ "(sum,wantedTag,wantsLast) {"
            "if(wantedTag === " sum-tag ") {"
            (format "if(" sum-flag " === wantsLast) {" extact-match "}"
                    "else {" test-recursion "}")
            "}"
            (format "else if(wantedTag > " sum-tag ") {" test-recursion "}")
            (format "else if(wantedTag < " sum-tag " && wantsLast === '') {"
                    (let [updated-sum (variant' (format "(" sum-tag " - wantedTag)") sum-flag sum-value)]
                      (format "return " updated-sum ";"))
                    "}")
            "else { " no-match " }"
            "})")))

(def: runtime//adt
  Runtime
  (format __product//left
          __product//right
          __sum//get))

(runtime: int//new "makeI64"
  (format "(function " @ "(high,low) {"
          "return { H: (high|0), L: (low|0)};"
          "})"))

(runtime: int//2^16 "TWO_PWR_16"
  "(1 << 16)")

(runtime: int//2^32 "TWO_PWR_32"
  (format "(" int//2^16 " * " int//2^16 ")"))

(runtime: int//2^64 "TWO_PWR_64"
  (format "(" int//2^32 " * " int//2^32 ")"))

(runtime: int//2^63 "TWO_PWR_63"
  (format "(" int//2^64 " / 2)"))

(runtime: int//unsigned-low "getLowBitsUnsigned"
  (format "(function " @ "(i64) {"
          "return (i64.L >= 0) ? i64.L : (" int//2^32 " + i64.L);"
          "})"))

(runtime: int//to-number "toNumberI64"
  (format "(function " @ "(i64) {"
          "return (i64.H * " int//2^32 ") + " int//unsigned-low "(i64);"
          "})"))

(runtime: int//zero "ZERO"
  "{ H: (0|0), L: (0|0)}")

(runtime: int//min "MIN_VALUE_I64"
  "{ H: (0x80000000|0), L: (0|0)}")

(runtime: int//max "MAX_VALUE_I64"
  "{ H: (0x7FFFFFFF|0), L: (0xFFFFFFFF|0)}")

(runtime: int//one "ONE"
  "{ H: (0|0), L: (1|0)}")

(runtime: int//= "eqI64"
  (format "(function " @ "(l,r) {"
          "return (l.H === r.H) && (l.L === r.L);"
          "})"))

(runtime: int//+ "addI64"
  (format "(function " @ "(l,r) {"
          "var l48 = l.H >>> 16;"
          "var l32 = l.H & 0xFFFF;"
          "var l16 = l.L >>> 16;"
          "var l00 = l.L & 0xFFFF;"

          "var r48 = r.H >>> 16;"
          "var r32 = r.H & 0xFFFF;"
          "var r16 = r.L >>> 16;"
          "var r00 = r.L & 0xFFFF;"

          "var x48 = 0, x32 = 0, x16 = 0, x00 = 0;"
          "x00 += l00 + r00;"
          "x16 += x00 >>> 16;"
          "x00 &= 0xFFFF;"
          "x16 += l16 + r16;"
          "x32 += x16 >>> 16;"
          "x16 &= 0xFFFF;"
          "x32 += l32 + r32;"
          "x48 += x32 >>> 16;"
          "x32 &= 0xFFFF;"
          "x48 += l48 + r48;"
          "x48 &= 0xFFFF;"

          "return " int//new "((x48 << 16) | x32, (x16 << 16) | x00);"
          "})"))

(template: (bit-operation: <lux-name> <js-name> <op>)
  (runtime: <lux-name> <js-name>
    (format "(function " (~' @) "(input,mask) {"
            "return " int//new "(input.H " <op> " mask.H, input.L " <op> " mask.L);"
            "})")))

(bit-operation: bit//and "andI64" "&")
(bit-operation: bit//or  "orI64"  "|")
(bit-operation: bit//xor "xorI64" "^")

(runtime: bit//not "notI64"
  (format "(function " @ "(i64) {"
          "return " int//new "(~i64.H,~i64.L);"
          "})"))

(runtime: int//negate "negateI64"
  (format "(function " @ "(i64) {"
          (format "if(" int//= "(" int//min ",i64)) {"
                  "return " int//min ";"
                  "}")
          (format "else {"
                  "return " int//+ "(" bit//not "(i64)," int//one ");"
                  "}")
          "})"))

(runtime: int//-one "NEG_ONE"
  (js.apply int//negate (list int//one)))

(runtime: int//from-number "fromNumberI64"
  (format "(function " @ "(num) {"
          (format "if(isNaN(num)) {"
                  "return " int//zero ";"
                  "}")
          (format "else if(num <= -" int//2^63 ") {"
                  "return " int//min ";"
                  "}")
          (format "else if((num + 1) >= " int//2^63 ") {"
                  "return " int//max ";"
                  "}")
          (format "else if(num < 0) {"
                  "return  " int//negate "(" @ "(-num));"
                  "}")
          (format "else {"
                  "return " int//new "((num / " int//2^32 "), (num % " int//2^32 "));"
                  "}")
          "})"))

(runtime: bit//left-shift "shlI64"
  (format "(function " @ "(input,shift) {"
          "shift &= 63;"
          (format "if(shift === 0) {"
                  "return input;"
                  "}"
                  "else {"
                  (format "if (shift < 32) {"
                          "var high = (input.H << shift) | (input.L >>> (32 - shift));"
                          "var low = input.L << shift;"
                          "return " int//new "(high, low);"
                          "}"
                          "else {"
                          "var high = (input.L << (shift - 32));"
                          "return " int//new "(high, 0);"
                          "}")
                  "}")
          "})"))

(runtime: bit//arithmetic-right-shift "shrI64"
  (format "(function " @ "(input,shift) {"
          "shift &= 63;"
          (format "if(shift === 0) {"
                  "return input;"
                  "}"
                  "else {"
                  (format "if (shift < 32) {"
                          "var high = input.H >> shift;"
                          "var low = (input.L >>> shift) | (input.H << (32 - shift));"
                          "return " int//new "(high, low);"
                          "}"
                          "else {"
                          "var low = (input.H >> (shift - 32));"
                          "var high = input.H >= 0 ? 0 : -1;"
                          "return " int//new "(high, low);"
                          "}")
                  "}")
          "})"))

(runtime: bit//logical-right-shift "ushrI64"
  (format "(function " @ "(input,shift) {"
          "shift &= 63;"
          (format "if(shift === 0) {"
                  "return input;"
                  "}"
                  "else {"
                  (format "if (shift < 32) {"
                          "var high = input.H >>> shift;"
                          "var low = (input.L >>> shift) | (input.H << (32 - shift));"
                          "return " int//new "(high, low);"
                          "}"
                          "else if(shift === 32) {"
                          "return " int//new "(0, input.H);"
                          "}"
                          "else {"
                          "var low = (input.H >>> (shift - 32));"
                          "return " int//new "(0, low);"
                          "}")
                  "}")
          "})"))

(def: runtime//bit
  Runtime
  (format __bit//and
          __bit//or
          __bit//xor
          __bit//not
          __bit//left-shift
          __bit//arithmetic-right-shift
          __bit//logical-right-shift))

(runtime: int//- "subI64"
  (format "(function " @ "(l,r) {"
          "return " int//+ "(l, " int//negate "(r));"
          "})"))

(runtime: int//* "mulI64"
  (format "(function " @ "(l,r) {"
          "if (l.H < 0) {"
          (format "if (r.H < 0) {"
                  ## Both are negative
                  "return " @ "( " int//negate "(l), " int//negate "(r));"
                  "}"
                  "else {"
                  ## Left is negative
                  "return  " int//negate "(" @ "( " int//negate "(l),r));"
                  "}")
          "}"
          "else if (r.H < 0) {"
          ## Right is negative
          "return  " int//negate "(" @ "(l, " int//negate "(r)));"
          "}"
          ## Both are positive
          "else {"
          "var l48 = l.H >>> 16;"
          "var l32 = l.H & 0xFFFF;"
          "var l16 = l.L >>> 16;"
          "var l00 = l.L & 0xFFFF;"

          "var r48 = r.H >>> 16;"
          "var r32 = r.H & 0xFFFF;"
          "var r16 = r.L >>> 16;"
          "var r00 = r.L & 0xFFFF;"

          "var x48 = 0, x32 = 0, x16 = 0, x00 = 0;"
          "x00 += l00 * r00;"
          "x16 += x00 >>> 16;"
          "x00 &= 0xFFFF;"
          "x16 += l16 * r00;"
          "x32 += x16 >>> 16;"
          "x16 &= 0xFFFF;"
          "x16 += l00 * r16;"
          "x32 += x16 >>> 16;"
          "x16 &= 0xFFFF;"
          "x32 += l32 * r00;"
          "x48 += x32 >>> 16;"
          "x32 &= 0xFFFF;"
          "x32 += l16 * r16;"
          "x48 += x32 >>> 16;"
          "x32 &= 0xFFFF;"
          "x32 += l00 * r32;"
          "x48 += x32 >>> 16;"
          "x32 &= 0xFFFF;"
          "x48 += (l48 * r00) + (l32 * r16) + (l16 * r32) + (l00 * r48);"
          "x48 &= 0xFFFF;"

          "return " int//new "((x48 << 16) | x32, (x16 << 16) | x00);"
          "}"
          "})"))

(runtime: int//< "ltI64"
  (format "(function " @ "(l,r) {"
          "var ln = l.H < 0;"
          "var rn = r.H < 0;"
          "if(ln && !rn) { return true; }"
          "if(!ln && rn) { return false; }"
          "return (" int//- "(l,r).H < 0);"
          "})"))

(def: (<I param subject)
  (-> Expression Expression Expression)
  (js.apply int//< (list subject param)))

(def: (<=I param subject)
  (-> Expression Expression Expression)
  (js.or (js.apply int//< (list subject param))
         (js.apply int//= (list subject param))))

(def: (>I param subject)
  (-> Expression Expression Expression)
  (js.apply int//< (list param subject)))

(def: (>=I param subject)
  (-> Expression Expression Expression)
  (js.or (js.apply int//< (list param subject))
         (js.apply int//= (list subject param))))

(def: (=I reference sample)
  (-> Expression Expression Expression)
  (js.apply int//= (list sample reference)))

(runtime: int/// "divI64"
  (let [negate (|>> (list) (js.apply int//negate))
        negative? (function (_ value)
                    (js.apply int//< (list value int//zero)))
        valid-division-check [(=I int//zero "parameter")
                              (js.throw! (js.string "Cannot divide by zero!"))]
        short-circuit-check [(=I int//zero "subject")
                             (js.return! int//zero)]
        recur (function (_ subject parameter)
                (js.apply @ (list subject parameter)))]
    (js.function @ (list "subject" "parameter")
      (list (js.cond! (list valid-division-check
                            short-circuit-check

                            [(=I int//min "subject")
                             (js.cond! (list [(js.or (=I int//one "parameter")
                                                     (=I int//-one "parameter"))
                                              (js.return! int//min)]
                                             [(=I int//min "parameter")
                                              (js.return! int//one)])
                                       (js.block! (list (js.var! "approximation"
                                                                 (#.Some (js.apply bit//left-shift
                                                                                   (list (recur (js.apply bit//arithmetic-right-shift
                                                                                                          (list "subject" (js.number 1.0)))
                                                                                                "parameter")
                                                                                         (js.number 1.0)))))
                                                        (js.if! (=I int//zero "approximation")
                                                                (js.return! (js.? (negative? "parameter")
                                                                                  int//one
                                                                                  int//-one))
                                                                (let [remainder (js.apply int//- (list "subject"
                                                                                                       (js.apply int//* (list "parameter"
                                                                                                                              "approximation"))))
                                                                      result (js.apply int//+ (list "approximation"
                                                                                                    (recur remainder
                                                                                                           "parameter")))]
                                                                  (js.return! result))))))]
                            [(=I int//min "parameter")
                             (js.return! int//zero)]

                            [(negative? "subject")
                             (js.return! (js.? (negative? "parameter")
                                               (recur (negate "subject")
                                                      (negate "parameter"))
                                               (negate (recur (negate "subject")
                                                              "parameter"))))]

                            [(negative? "parameter")
                             (js.return! (negate (recur "subject" (negate "parameter"))))])
                      (js.block! (list (js.var! "result" (#.Some int//zero))
                                       (js.var! "remainder" (#.Some "subject"))
                                       (js.while! (>=I "parameter" "remainder")
                                                  (let [rough-estimate (js.apply "Math.floor" (list (js./ (js.apply int//to-number (list "parameter"))
                                                                                                          (js.apply int//to-number (list "remainder")))))
                                                        log2 (js./ "Math.LN2"
                                                                   (js.apply "Math.log" (list "approximate")))
                                                        approx-result (js.apply int//from-number (list "approximate"))
                                                        approx-remainder (js.apply int//* (list "approximate_result" "parameter"))]
                                                    (list (js.var! "approximate" (#.Some (js.apply "Math.max" (list (js.number 1.0)
                                                                                                                    rough-estimate))))
                                                          (js.var! "log2" (#.Some (js.apply "Math.ceil" (list log2))))
                                                          (js.var! "delta" (#.Some (js.? (js.<= (js.number 48.0) "log2")
                                                                                         (js.number 1.0)
                                                                                         (js.apply "Math.pow" (list (js.number 2.0)
                                                                                                                    (js.- (js.number 48.0)
                                                                                                                          "log2"))))))
                                                          (js.var! "approximate_result" (#.Some approx-result))
                                                          (js.var! "approximate_remainder" (#.Some approx-remainder))
                                                          (js.while! (js.or (negative? "approximate_remainder")
                                                                            (>I "remainder"
                                                                                "approximate_remainder"))
                                                                     (list (js.set! "approximate" (js.- "delta" "approximate"))
                                                                           (js.set! "approximate_result" approx-result)
                                                                           (js.set! "approximate_remainder" approx-remainder)))
                                                          (js.block! (list (js.set! "result" (js.apply int//+ (list "result"
                                                                                                                    (js.? (=I int//zero "approximate_result")
                                                                                                                          int//one
                                                                                                                          "approximate_result"))))
                                                                           (js.set! "remainder" (js.apply int//- (list "remainder" "approximate_remainder"))))))))
                                       (js.return! "result")))
                      )))))

(runtime: int//% "remI64"
  (js.function @ (list "subject" "parameter")
    (list (let [flat (js.apply int//* (list (js.apply int/// (list "subject" "parameter"))
                                            "parameter"))]
            (js.return! (js.apply int//- (list "subject" flat)))))))

(def: runtime//int
  Runtime
  (format __int//2^16
          __int//2^32
          __int//2^64
          __int//2^63
          __int//unsigned-low
          __int//zero
          __int//new
          __int//min
          __int//max
          __int//one
          __int//=
          __int//+
          __int//negate
          __int//to-number
          __int//from-number
          __int//-
          __int//*
          __int//<
          __int///
          __int//%))

(runtime: text//index "index"
  (format "(function " @ "(text,part,start) {"
          "var idx = text.indexOf(part," int//to-number "(start));"
          (format (format "if(idx === -1) {"
                          "return " none ";"
                          "}")
                  (format "else {"
                          (format "return " (some (format int//from-number "(idx)")) ";")
                          "}"))
          "})"))

(runtime: text//clip "clip"
  (format "(function " @ "(text,from,to) {"
          (format "if(from.L > text.length || to.L > text.length) {"
                  (format "return " none ";")
                  "}"
                  "else {"
                  (format "return " (some "text.substring(from.L,to.L)") ";")
                  "}")
          "})"))

(runtime: text//char "textChar"
  (format "(function " @ "(text,idx) {"
          "var result = text.charCodeAt(idx.L);"
          (format "if(result === NaN) {"
                  (format "return " none ";")
                  "}"
                  "else {"
                  (format "return " (some (format int//from-number "(result)")) ";")
                  "}")
          "})"))

(def: runtime//text
  Runtime
  (format __text//index
          __text//clip
          __text//char))

(runtime: array//get "arrayGet"
  (format "(function " @ "(arr,idx) {"
          "var temp = arr[" int//to-number "(idx)];"
          (format "if(temp !== undefined) {"
                  (format "return " (some "temp") ";")
                  "}"
                  "else {"
                  (format "return " none ";")
                  "}")
          "})"))

(runtime: array//put "arrayPut"
  (format "(function " @ "(arr,idx,val) {"
          "arr[" int//to-number "(idx)] = val;"
          "return arr;"
          "})"))

(runtime: array//remove "arrayRemove"
  (format "(function " @ "(arr,idx) {"
          "delete arr[" int//to-number "(idx)];"
          "return arr;"
          "})"))

(def: runtime//array
  Runtime
  (format __array//get
          __array//put
          __array//remove))

(runtime: io//log "log"
  (format "(function " @ "(message) {"
          "if(typeof console !== \"undefined\" && console.log) { console.log(message); }"
          "else if(typeof print !== \"undefined\") { print(message); }"
          "return " unit ";"
          "})"))

(runtime: io//error "error"
  (format "(function " @ "(message) {"
          "throw new Error(message);"
          "})"))

(def: runtime//io
  Runtime
  (format __io//log
          __io//error))

(def: #export atom-field Text "V")

(runtime: atom//compare-and-swap "atomCompareAndSwap"
  (format "(function " @ "(atom,oldV,newV) {"
          "if(atom." atom-field " === oldV) {"
          "atom." atom-field " = newV;"
          "return true;"
          "}"
          "else {"
          "return false;"
          "}"
          "})"))

(def: runtime//atom
  Runtime
  (format __atom//compare-and-swap))

(runtime: js//get "jsGetField"
  (format "(function " @ "(object, field) {"
          "var temp = object[field];"
          (format "if(temp !== undefined) {"
                  (format "return " (some "temp") ";")
                  "}"
                  "else {"
                  (format "return " none ";")
                  "}")
          "})"))

(runtime: js//set "jsSetField"
  (format "(function " @ "(object, field, input) {"
          "object[field] = input;"
          "return object;"
          "})"))

(runtime: js//delete "jsDeleteField"
  (format "(function " @ "(object, field) {"
          "delete object[field];"
          "return object;"
          "})"))

(runtime: js//call "jsObjectCall"
  (format "(function " @ "(object, method, args) {"
          "return object[method].apply(object, args);"
          "})"))

(def: runtime//js
  Runtime
  (format __js//get
          __js//set
          __js//delete
          __js//call))

(def: runtime
  Runtime
  (format runtime//lux
          runtime//adt
          runtime//bit
          runtime//int
          runtime//text
          runtime//array
          runtime//io
          runtime//atom
          runtime//js))

(def: #export artifact Text (format prefix ".js"))

(def: #export translate
  (Meta (Process Any))
  (do macro.Monad<Meta>
    [_ //.init-module-buffer
     _ (//.save-js runtime)]
    (//.save-module! artifact)))