(.module:
  [lux (#- int char)
   [data
    ["." maybe ("#@." functor)]
    ["." text
     format]
    [collection
     ["." list ("#@." functor)]]]]
  ["." //])

(template [<name> <primitive>]
  [(def: #export <name> //.Type (#//.Primitive <primitive>))]

  [boolean #//.Boolean]
  [byte    #//.Byte]
  [short   #//.Short]
  [int     #//.Int]
  [long    #//.Long]
  [float   #//.Float]
  [double  #//.Double]
  [char    #//.Char]
  )

(template: #export (class name params)
  (#//.Generic (#//.Class name params)))

(template: #export (var name)
  (#//.Generic (#//.Var name)))

(template: #export (wildcard bound)
  (#//.Generic (#//.Wildcard bound)))

(def: #export (array depth elemT)
  (-> Nat //.Type //.Type)
  (case depth
    0 elemT
    _ (#//.Array (array (dec depth) elemT))))

(def: #export binary-name
  (-> Text Text)
  (text.replace-all "." "/"))

(def: #export (descriptor type)
  (-> //.Type Text)
  (case type
    (#//.Primitive prim)
    (case prim
      #//.Boolean "Z"
      #//.Byte    "B"
      #//.Short   "S"
      #//.Int     "I"
      #//.Long    "J"
      #//.Float   "F"
      #//.Double  "D"
      #//.Char    "C")

    (#//.Array sub)
    (format "[" (descriptor sub))

    (#//.Generic generic)
    (case generic
      (#//.Class class params)
      (format "L" (binary-name class) ";")

      (^or (#//.Var name) (#//.Wildcard ?bound))
      (descriptor (#//.Generic (#//.Class "java.lang.Object" (list)))))
    ))

(def: #export (class-name type)
  (-> //.Type (Maybe Text))
  (case type
    (#//.Primitive prim)
    #.None

    (#//.Array sub)
    (#.Some (descriptor type))

    (#//.Generic generic)
    (case generic
      (#//.Class class params)
      (#.Some class)

      (^or (#//.Var name) (#//.Wildcard ?bound))
      (#.Some "java.lang.Object"))
    ))

(def: #export (signature type)
  (-> //.Type Text)
  (case type
    (#//.Primitive prim)
    (case prim
      #//.Boolean "Z"
      #//.Byte    "B"
      #//.Short   "S"
      #//.Int     "I"
      #//.Long    "J"
      #//.Float   "F"
      #//.Double  "D"
      #//.Char    "C")

    (#//.Array sub)
    (format "[" (signature sub))

    (#//.Generic generic)
    (case generic
      (#//.Class class params)
      (let [=params (if (list.empty? params)
                      ""
                      (format "<"
                              (|> params
                                  (list@map (|>> #//.Generic signature))
                                  (text.join-with ""))
                              ">"))]
        (format "L" (binary-name class) =params ";"))

      (#//.Var name)
      (format "T" name ";")

      (#//.Wildcard #.None)
      "*"

      (^template [<tag> <prefix>]
        (#//.Wildcard (#.Some [<tag> bound]))
        (format <prefix> (signature (#//.Generic bound))))
      ([#//.Upper "+"]
       [#//.Lower "-"]))
    ))

(def: #export (method args return exceptions)
  (-> (List //.Type) (Maybe //.Type) (List //.Generic) //.Method)
  {#//.args args #//.return return #//.exceptions exceptions})

(def: #export (method-descriptor method)
  (-> //.Method Text)
  (format "(" (text.join-with "" (list@map descriptor (get@ #//.args method))) ")"
          (case (get@ #//.return method)
            #.None
            "V"

            (#.Some return)
            (descriptor return))))

(def: #export (method-signature method)
  (-> //.Method Text)
  (format "(" (|> (get@ #//.args method) (list@map signature) (text.join-with "")) ")"
          (case (get@ #//.return method)
            #.None
            "V"

            (#.Some return)
            (signature return))
          (|> (get@ #//.exceptions method)
              (list@map (|>> #//.Generic signature (format "^")))
              (text.join-with ""))))