%classpath config resolver snapshots https://repository.apache.org/content/repositories/snapshots
%classpath config resolver vendredi https://repository.hellonico.info/repository/hellonico/
%classpath config resolver staging https://repository.apache.org/content/repositories/staging

%classpath add mvn org.apache.mxnet.contrib.clojure clojure-mxnet-linux-cpu 1.4.0
%classpath add mvn origami origami 4.0.0-7

(require '[clojure.java.io :as io])

;; MXNet namespaces
(require '[org.apache.clojure-mxnet.image :as mx-img])
(require '[org.apache.clojure-mxnet.ndarray :as ndarray])
(require '[org.apache.clojure-mxnet.shape :as mx-shape])

;; OpenCV namespaces
(require '[opencv4.colors.rgb :as rgb])
(require '[opencv4.mxnet :as mx-cv])
(require '[opencv4.core :as cv])
(require '[opencv4.utils :as cvu])

(import org.opencv.core.Mat)
(import java.awt.image.DataBufferByte)

(defn download!
  "Download `uri` and store it in `filename` on disk"
  [uri filename]
  (with-open [in (io/input-stream uri)
              out (io/output-stream filename)]
    (io/make-parents filename)
    (io/copy in out)))

;; Download a cat image from a `uri` and save it into `images/cat.jpg`
(download! "https://raw.githubusercontent.com/dmlc/web-data/master/mxnet/doc/tutorials/python/predict_image/cat.jpg" "images/cat.jpg")

;; Download a dog image from a `uri` and save it into `images/dog.jpg`
(download! "https://github.com/dmlc/web-data/blob/master/mxnet/doc/tutorials/python/predict_image/dog.jpg?raw=true" "images/dog.jpg")

(-> "images/dog.jpg"
    ;; Convert filename to NDArray
    (mx-img/read-image {:to-rgb true}) ;; option :to-rgb, true by default
    ;; Resizing image to height = 400, width = 400
    (mx-img/resize-image 400 400)
    ;; Convert to BufferedImage
    (mx-img/to-image)
    ;; Saving BufferedImage to disk
    (javax.imageio.ImageIO/write "jpg" (java.io.File. "test2.jpg")))

(defn mat->ndarray
  "Convert a `mat` from OpenCV to an MXNet `ndarray`"
  [mat]
  (let [h (.height mat)
        w (.width mat)
        c (.channels mat)]
    (-> mat
        cvu/mat->flat-rgb-array
        (ndarray/array [c h w]))))

(defn ndarray->mat
  "Convert a `ndarray` to an OpenCV `mat`"
  [ndarray]
  (let [shape (mx-shape/->vec ndarray)
        [h w _ _] (mx-shape/->vec (ndarray/shape ndarray))
        bytes (byte-array shape)
        mat (cv/new-mat h w cv/CV_8UC3)]
    (.put mat 0 0 bytes)
    mat))

(defn filename->ndarray!
  "Convert an image stored on disk `filename` into an `ndarray`

  `filename`: string representing the image on disk
  `shape-vec`: is the actual shape of the returned `ndarray`
   return: ndarray"
  [filename shape-vec]
  (-> filename
      (cv/imread)
      (mat->ndarray)))

(defn draw-bounding-box!
  "Draw bounding box on `img` given the `top-left` and `bottom-right` coordonates.
  Add `label` when provided.
  returns: nil"
  [img {:keys [label top-left bottom-right]}]
  (let [[x0 y0] top-left
        [x1 y1] bottom-right
        top-left-point (cv/new-point x0 y0)
        bottom-right-point (cv/new-point x1 y1)]
    (cv/rectangle img top-left-point bottom-right-point rgb/white 1)
    (when label
      (cv/put-text! img label top-left-point cv/FONT_HERSHEY_DUPLEX 1.0 rgb/white 1))))

(defn draw-predictions!
    "Draw all predictions on an `img` passing `results` which is a collection
     of bounding boxes data.
     returns: nil"
    [img results]
    (doseq [{:keys [label top-left bottom-right] :as result} results]
      (draw-bounding-box! img result)))

(require '[clojure.string :as string])
;; MXNet namespaces
(require '[org.apache.clojure-mxnet.module :as m])
(require '[org.apache.clojure-mxnet.ndarray :as ndarray])

;; OpenCV namespaces
(require '[opencv4.core :as cv])
(require '[opencv4.utils :as cvu])

(require '[org.apache.clojure-mxnet.dtype :as d])

(def model-dir "model/")
(def h 224) ;; Image height
(def w 224) ;; Image width
(def c 3)   ;; Number of channels: Red, Green, Blue
(defonce vgg-16-mod
  (-> {:prefix (str model-dir "vgg16") :epoch 0}
      (m/load-checkpoint)
      ;; Define the shape of input data and bind the name of the input layer
      ;; to "data"
      (m/bind {:for-training false
               :data-shapes [{:name "data" :shape [1 c h w]}]})))
(defonce inception-mod
  (-> {:prefix (str model-dir "Inception-BN") :epoch 0}
      (m/load-checkpoint)
      ;; Define the shape of input data and bind the name of the input layer
      ;; to "data"
      (m/bind {:for-training false
               :data-shapes [{:name "data" :shape [1 c h w]}]})))

(defonce image-net-labels
  (-> (str model-dir "/synset.txt")
      (slurp)
      (string/split #"\n")))

;; ImageNet 1000 Labels check
(assert (= 1000 (count image-net-labels)))

(defn preprocess-img-mat
  "Preprocessing steps on an `img-mat` from OpenCV to feed into the Model"
  [img-mat]
  (-> img-mat
      ;; Resize image to (w, h)
      (cv/resize! (cv/new-size w h))
      ;; Maps pixel values from [-128, 128] to [0, 127]
      (cv/convert-to! cv/CV_8SC3 0.5)
      ;; Substract mean pixel values from ImageNet dataset
      (cv/add! (cv/new-scalar -103.939 -116.779 -123.68))
      ;; Flatten matrix
      (cvu/mat->flat-rgb-array)
      ;; Reshape to (1, c, h, w)
      (ndarray/array [1 c h w])))

(defn- top-k
  "Return top `k` from prob-maps with :prob key"
  [k prob-maps]
  (->> prob-maps
       (sort-by :prob)
       (reverse)
       (take k)))

(defn predict
  "Predict with `model` the top `k` labels from `labels` of the ndarray `x`"
  ([model labels x]
   (predict model labels x 5))
  ([model labels x k]
   (let [probs (-> model
                   (m/forward {:data [x]})
                   (m/outputs)
                   (ffirst)
                   (ndarray/->vec))
         prob-maps (mapv (fn [p l] {:prob p :label l}) probs labels)]
     (top-k k prob-maps))))

%classpath add mvn rhizome rhizome 0.2.9
%classpath add mvn instaparse instaparse 1.4.9
;; with leiningen one would have a project.clj with
;;
;;(defproject languages "0.1.0-SNAPSHOT"
;;  :description "FIXME: write description"
;;  :url "http://example.com/FIXME"
;;  :license {:name "Eclipse Public License"
;;            :url "http://www.eclipse.org/legal/epl-v10.html"}
;;  :dependencies [[org.clojure/clojure "1.8.0"]
;;                 [instaparse "1.4.9"]
;;                 [rhizome "0.2.9"]])

(use 'instaparse.core)
(def const-parser
  (instaparse.core/parser
   "PROG= NUMBER
    NUMBER= #'-?[0-9]+'"))
    
(prn (const-parser "-123"))

(System/setProperty "java.awt.headless" "true");; required for the notebook
(use 'rhizome.viz)
(instaparse.core/visualize (const-parser "-256") :output-file :buffered-image )

(prn (const-parser "    -123456    "))

(def const-parser
  (instaparse.core/parser
   "prog= spaces number spaces
    number=#'-?[0-9]+'
    <spaces> = <#'[ ]'*>"))
    
(instaparse.core/visualize (const-parser "    -123456    ") :output-file :buffered-image )

(defn const-interpreter [ast]
   (instaparse.core/transform {:number #(Long/parseLong %)} ast))

(prn (-> "-123" const-parser const-interpreter))

(defn dynamic-eval [interpreter]
    (fn[ast]
      (fn[]
        (instaparse.core/transform interpreter ast))))

(def const-interpreting
  {:prog identity
   :number #(Long/parseLong %)})
(def const-eval (dynamic-eval const-interpreting))

(def const-eval-test (-> "-123 " const-parser const-eval))

(const-eval-test)

(def const-compiling
  {:prog (fn[& instrs](conj (reduce into [[:loadi 0]] instrs)[:reti]))
   :number #(vector [:loadi (Long/parseLong %)])})

(prn (->> "-123" const-parser (instaparse.core/transform const-compiling)))

(import '(clojure.asm Opcodes Type ClassWriter))
  (import '(clojure.asm.commons Method GeneratorAdapter))

(defn const-instr-generating [mv instr]
  "Generate the method call to an  org.objectweb.asm.MethodVisitor for a given instruction."
  (do
    (condp = (first instr)
        :loadi (.visitLdcInsn mv (int (second instr)))
        :reti (.visitInsn mv Opcodes/IRETURN)
        )
  mv))

(defn compiled [n-args class-name bytecode-generator]
    (let [cw (ClassWriter. (+ ClassWriter/COMPUTE_FRAMES ClassWriter/COMPUTE_MAXS ))
          init (Method/getMethod "void <init>()")
          meth-name "run"
          meth-sig (str "(" (apply str (repeat n-args "I")) ")I")]
      (.visit cw Opcodes/V1_6 Opcodes/ACC_PUBLIC (.replace class-name \. \/) nil "java/lang/Object" nil)
      (doto (GeneratorAdapter. Opcodes/ACC_PUBLIC init nil nil cw)
        (.visitCode)
        (.loadThis)
        (.invokeConstructor (Type/getType Object) init)
        (.returnValue)
        (.endMethod))
      (doto (.visitMethod cw (+ Opcodes/ACC_PUBLIC Opcodes/ACC_STATIC) meth-name meth-sig nil nil )
        (.visitCode)
        (bytecode-generator)
        (.visitMaxs 0 0 )
        (.visitEnd))
      (.visitEnd cw)
      (let [b (.toByteArray cw)
            cl (clojure.lang.DynamicClassLoader.)]
        (.defineClass cl class-name b nil))
      (fn [& args] (clojure.lang.Reflector/invokeStaticMethod class-name meth-name (into-array args))))
    )

(defn bytecode-generating-eval [n-args class-name compiling instr-generating]
  (fn[ast]
  (let[instrs (instaparse.core/transform compiling ast)
       generate-prog (fn[mv] (reduce instr-generating mv instrs))]
    (compiled n-args class-name generate-prog))))

(def const-compiler (bytecode-generating-eval 0 "ConstCompiler" const-compiling const-instr-generating))

(def const-compiler-test (-> "-123" const-parser const-compiler ))

(const-compiler-test)

(defmulti generate-instr (fn [mv [instr & args]] instr))
(defn dispatching-bytecode-generating-eval [n-args class-name compiling]
  (fn[ast]
    (let[instrs (instaparse.core/transform compiling ast)
         generate-prog (fn[mv] (reduce generate-instr mv instrs))]
      (compiled n-args class-name generate-prog))))

(defmethod generate-instr :loadi [mv [instr & args]]
  (doto mv
    (.visitLdcInsn (int (first args)))))

(defmethod generate-instr :reti [mv [instr & args]]
  (doto mv
    (.visitInsn Opcodes/IRETURN)))

(def const-compiler (dispatching-bytecode-generating-eval 0 "ConstCompiler" const-compiling))
(def const-compiler-test (-> "-123" const-parser const-compiler))
(const-compiler-test)

(def addsub-parser
  (instaparse.core/parser
   "prog= spaces add-sub spaces
    <add-sub>= number | add | sub
    add= add-sub spaces <'+'> spaces number
    sub= add-sub spaces <'-'> spaces number
    number= #'-?[0-9]+'
    <spaces>= <#'\\s*'>"))

(-> "1+2-3-1" addsub-parser (instaparse.core/visualize :output-file :buffered-image ))

(def addsub-interpreting
  (assoc const-interpreting :add + :sub -))

(def addsub-eval (dynamic-eval addsub-interpreting))
(def addsub-eval-test (-> "1+2-3-1" addsub-parser addsub-eval))
(addsub-eval-test)

(defn assoc-binary-op [m [op instr]]
  (let[binary-op-compiling (fn[op]
                             (fn[instrs-v0 instrs-v1]
         (conj (into instrs-v0 instrs-v1) [op])))]
    (assoc m op (binary-op-compiling instr))))

(def addsub-compiling
  (reduce assoc-binary-op const-compiling [[:add :addi][:sub :subi]]))

(str (->> "1+2-3-1" addsub-parser (instaparse.core/transform addsub-compiling)))

(defmethod generate-instr :addi [mv [instr & args]]
  (doto mv
    (.visitInsn Opcodes/IADD)))

(defmethod generate-instr :subi [mv [instr & args]]
  (doto mv
    (.visitInsn Opcodes/ISUB)))

(def addsub-compiler (dispatching-bytecode-generating-eval 0 "AddsubCompiler" addsub-compiling))

(def addsub-compiler-test (-> "1+ 2 - 3 - 1" addsub-parser addsub-compiler))
(addsub-compiler-test)

(def addmult-parser
  (instaparse.core/parser
   "prog= spaces add-sub spaces
    <add-sub>= mult-div | add | sub
    add= add-sub spaces <'+'> spaces mult-div
    sub= add-sub spaces <'-'> spaces mult-div
    <mult-div>= number | mult | div
    mult= mult-div spaces <'*'> spaces number
    div= mult-div spaces <'/'> spaces number
    number= #'-?[0-9]+'
    <spaces>= <#'\\s*'>"))

(-> "1 + 3 * -2 -1" addmult-parser (instaparse.core/visualize :output-file :buffered-image ))

(def addmult-interpreting (assoc addsub-interpreting :mult * :div /))

(def addmult-eval (dynamic-eval addmult-interpreting ))

(def addmult-eval-test (-> "1 + 3 * -2 -1" addmult-parser addmult-eval))
(addmult-eval-test)

(def addmult-compiling
  (reduce assoc-binary-op addsub-compiling [[:mult :multi][:div :divi]]))

(defmethod generate-instr :multi [mv [instr & args]]
  (doto mv
    (.visitInsn Opcodes/IMUL)))

(defmethod generate-instr :divi [mv [instr & args]]
  (doto mv
    (.visitInsn Opcodes/IDIV)))

(def addmult-compiler (dispatching-bytecode-generating-eval 0 "AddmultCompiler" addmult-compiling))

(def addmult-compiler-test (-> "1 + 3 * -2 - 1" addmult-parser addmult-compiler))
(addmult-compiler-test)

(def arith-parser
  (instaparse.core/parser
   "prog = spaces add-sub spaces
    <add-sub> = mult-div | add | sub
    add = add-sub spaces <'+'> spaces mult-div
    sub = add-sub spaces <'-'> spaces mult-div
    <mult-div> = term | mult | div
    mult = mult-div spaces <'*'> spaces term
    div = mult-div spaces <'/'> spaces term
    <term> = number | <'('> add-sub <')'>
    <spaces> = <#'\\s'*>
    number = #'-?[0-9]+'"))

(-> "(1 + 3) * -2 -1" arith-parser (instaparse.core/visualize :output-file :buffered-image ))

(def arith-eval-test (-> "(1 + 3) * -2 -1" arith-parser addmult-eval))
(arith-eval-test)

(def arith-compiler-test (-> "1 + 3 * (-2 - 1)" arith-parser addmult-compiler))
(arith-compiler-test)

(def lang0-parser
  (instaparse.core/parser
   "prog = (spaces expr spaces <';'> spaces)*
    <expr> = assig | add-sub
    assig = varname spaces <'='> spaces expr
    <add-sub> = mult-div | add | sub
    add = add-sub spaces <'+'> spaces mult-div
    sub = add-sub spaces <'-'> spaces mult-div
    <mult-div> = factor | mult |div
    mult = mult-div spaces <'*'> spaces factor
    div = mult-div spaces <'/'> spaces factor
    <factor> = number | <'('> spaces expr spaces <')'> | varget |assig
    <spaces> = <#'\\s*'>
    number = #'-?[0-9]+'
    varget = varname
    varname = #'[a-zA-Z]\\w*'"))

(-> "a=1+1*3;b=a-2; a+b;" lang0-parser (instaparse.core/visualize :output-file :buffered-image ))

(defn make-interpreting [make-instr-interpreting init-env]
  {:prog (fn [& instrs] (:_ret (reduce
                                       (fn[env instr]
                                         (instaparse.core/transform (make-instr-interpreting env) instr))
                                       init-env
                                       instrs)))})
(defn make-lang0-instr-interpreting [env]
  { :assig (fn[{varname :_ret :as env1} {value :_ret :as env2}]
             (assoc (merge env1 env2) varname value :_ret value))
   :add (fn[{v1 :_ret :as env1} {v2 :_ret :as env2}]
          (assoc (merge env1 env2) :_ret (+ v1 v2)))
   :sub (fn[{v1 :_ret :as env1} {v2 :_ret :as env2}]
          (assoc (merge env1 env2) :_ret (- v1 v2)))
   :mult (fn[{v1 :_ret :as env1} {v2 :_ret :as env2}]
           (assoc (merge env1 env2) :_ret (* v1 v2)))
   :div (fn[{v1 :_ret :as env1} {v2 :_ret :as env2}]
          (assoc (merge env1 env2) :_ret (quot v1 v2)))
   :number #(assoc env :_ret (Integer/parseInt %))
   :varname #(assoc env :_ret (keyword %))
   :varget (fn [{varname :_ret :as env1}]
             (assoc env1 :_ret (varname env1)))})

(def lang0-interpret (dynamic-eval (make-interpreting make-lang0-instr-interpreting {:_ret 0})))

(def lang0-interpret-test (->> "a=1+1*3;b=a-2; a+b;" lang0-parser lang0-interpret))
(lang0-interpret-test)

(def lang0-compiling
  (assoc addmult-compiling
         :varget #(vector [:load %])
         :assig (fn[var instrs](conj instrs [:store var]))))

(use 'clojure.set)
;; helper function that replaces all the values in map m with the given value v
(defn replace-vals [m v]
  (into {} (map vector (keys m) (repeat v ))))

(defn to-numeric-vars[nb-args ast]
  (let[varnames
       (instaparse.core/transform
        (assoc (replace-vals
                lang0-compiling
                (fn[& instrs] (apply clojure.set/union (filter set? instrs))))
               :varname (fn[varname]#{varname}))
        ast)
       name->num (into {} (map vector varnames (iterate inc nb-args)))]
    (instaparse.core/transform {:varname #(get name->num %)} ast)))

(str (->> "a=1+1*3;b=a-2; a+b;" lang0-parser (to-numeric-vars 0)))

(str (->> "a=1+1*3;b=a-2; a+b;" lang0-parser (to-numeric-vars 0) (instaparse.core/transform lang0-compiling)))

(defmethod generate-instr :load [mv [instr & args]]
  (doto mv
    (.visitVarInsn Opcodes/ILOAD (int (first args)))))

(defmethod generate-instr :store [mv [instr & args]]
  (doto mv
    (.visitInsn Opcodes/DUP)
    (.visitVarInsn Opcodes/ISTORE (int (first args)))))

(def lang0-compiler (dispatching-bytecode-generating-eval 0 "Lang0Compiler" lang0-compiling))

(def lang0-compiler-test (->> "a=1 + 3 * (-2 - 1);b= 0 - a;" lang0-parser (to-numeric-vars 0) lang0-compiler))
(lang0-compiler-test)

(def lang1-parser
  (instaparse.core/parser
   "prog = (spaces expr spaces <';'> spaces)*
      <expr> = assig | add-sub
      assig = varname spaces <'='> spaces expr
      <add-sub> = mult-div | add | sub
      add = add-sub spaces <'+'> spaces mult-div
      sub = add-sub spaces <'-'> spaces mult-div
      <mult-div> = factor | mult |div
      mult = mult-div spaces <'*'> spaces factor
      div = mult-div spaces <'/'> spaces factor
      <factor> = number | <'('> spaces expr spaces <')'> | varget |assig
      <spaces> = <#'\\s*'>
      number = #'-?[0-9]+'
      varget = varname | argument
      varname = #'[a-zA-Z]\\w*'
      argument= <'%'>#'[0-9]+'"))

(-> "a=%0;a + %1 *3;" lang1-parser (instaparse.core/visualize :output-file :buffered-image ))

(defn args-to-env[args]
  (into {} (map-indexed #(vector (keyword (str "%" %1)) %2) args)))

(defn dynamic-eval-args [make-interpreter]
  (fn[ast]
    (fn[& args]
      (instaparse.core/transform (make-interpreting make-interpreter
                                          (assoc (args-to-env args)
                                                 :_ret 0))
                       ast))))

(defn make-lang1-instr-interpreting [env]
  (assoc (make-lang0-instr-interpreting env)
         :argument #(assoc env :_ret (keyword (str "%" %)))))

(def lang1-interpret (dynamic-eval-args make-lang1-instr-interpreting))

(def lang1-interpret-test (->> "a=%0;a + %1 *3;" lang1-parser lang1-interpret))
(lang1-interpret-test 2 3)

(defn nb-args[ast]
  (inc (instaparse.core/transform (assoc (replace-vals
                           lang0-compiling (fn[& args]
                                             (apply max (conj (filter number? args)
                                                              -1))))
                          :argument #(Integer/parseInt %))
                   ast)))

(->> "a=%0;a + %1 *3;" lang1-parser nb-args)

(defn args->varnum[ast]
  (instaparse.core/transform {:argument #(Integer/parseInt %)} ast))

(defn lang1-compiler-chain[class-name ast]
  (let[n-args (nb-args ast)
       compiler (dispatching-bytecode-generating-eval n-args class-name lang0-compiling)]
    (->> ast args->varnum (to-numeric-vars n-args) compiler)))

(def lang1-compiler-test (->> "a=%0;a + %1 *3;" lang1-parser (lang1-compiler-chain "Lang1Compiler")))
(lang1-compiler-test 2 5)

;; TODO parser should be defined here

;; TODO test the parser

;; TODO function creating the transform map and defining the modulo-interpret function.

;; TODO test the interpreter

;; TODO redefine multimethods and define the modulo-compiler-chain function

;; TODO test the compiler