(.module:
  [lux #- not or and list if is]
  (lux (control pipe)
       (data [text]
             text/format
             [number]
             (coll [list "list/" Functor<List> Fold<List>]))
       (type abstract)))

(abstract: #export Single {} Unit)
(abstract: #export Poly {} Unit)
(abstract: #export Keyword {} Unit)

(abstract: #export (Var kind)
  {}

  Text

  (def: name (All [k] (-> (Var k) Text)) (|>> @representation))

  (def: #export var (-> Text (Var Single)) (|>> @abstraction))

  (do-template [<name> <kind> <prefix>]
    [(def: #export <name>
       (-> (Var Single) (Var <kind>))
       (|>> @representation (format <prefix>) @abstraction))]

    [poly    Poly    "*"]
    [keyword Keyword "**"]
    )
  )

(type: #export SVar (Var Single))
(type: #export PVar (Var Poly))
(type: #export KVar (Var Keyword))

(abstract: #export Expression
  {}
  
  Text

  (def: #export expression (-> Expression Text) (|>> @representation))

  (def: #export code (-> Text Expression) (|>> @abstraction))

  (def: #export none
    Expression
    (@abstraction "None"))

  (def: #export bool
    (-> Bool Expression)
    (|>> (case> true "True"
                false "False")
         @abstraction))

  (def: #export int
    (-> Int Expression)
    (|>> %i @abstraction))

  (def: #export float
    (-> Frac Expression)
    (|>> (cond> [(f/= number.positive-infinity)]
                [(new> "float(\"inf\")")]
                
                [(f/= number.negative-infinity)]
                [(new> "float(\"-inf\")")]
                
                [(f/= number.not-a-number)]
                [(new> "float(\"nan\")")]
                
                ## else
                [%f])
         @abstraction))

  (def: #export string
    (-> Text Expression)
    (|>> %t @abstraction))

  (def: (composite-literal left-delimiter right-delimiter entry-serializer)
    (All [a] (-> Text Text (-> a Text)
                 (-> (List a) Expression)))
    (function [entries]
      (@abstraction (format "(" left-delimiter
                            (|> entries (list/map entry-serializer) (text.join-with ","))
                            right-delimiter ")"))))

  (do-template [<name> <pre> <post>]
    [(def: #export <name>
       (-> (List Expression) Expression)
       (composite-literal <pre> <post> expression))]

    [tuple "(" ")"]
    [list  "[" "]"]
    )
  
  (def: #export (slice from to list)
    (-> Expression Expression Expression Expression)
    (@abstraction (format "(" (@representation list)
                          "[" (@representation from) ":" (@representation to) "]"
                          ")")))

  (def: #export (slice-from from list)
    (-> Expression Expression Expression)
    (@abstraction (format "(" (@representation list)
                          "[" (@representation from) ":]"
                          ")")))

  (def: #export dict
    (-> (List [Expression Expression]) Expression)
    (composite-literal "{" "}" (.function [[k v]] (format (@representation k) " : " (@representation v)))))

  (def: #export (apply args func)
    (-> (List Expression) Expression Expression)
    (@abstraction (format "(" (@representation func)
                          "(" (text.join-with "," (list/map expression args)) ")"
                          ")")))

  (do-template [<name> <kind> <prefix>]
    [(def: (<name> var)
       (-> Expression Text)
       (format <prefix> (@representation var)))]

    [splat-poly    Poly    "*"]
    [splat-keyword Keyword "**"]
    )

  (do-template [<name> <splat>]
    [(def: #export (<name> args extra func)
       (-> (List Expression) Expression Expression Expression)
       (@abstraction (format "(" (@representation func)
                             (format "(" (|> args
                                             (list/map (function [arg] (format (@representation arg) ", ")))
                                             (text.join-with ""))
                                     (<splat> extra) ")")
                             ")")))]

    [apply-poly    splat-poly]
    [apply-keyword splat-keyword]
    )

  (def: #export (field name object)
    (-> Text Expression Expression)
    (@abstraction (format "(" (@representation object) "." name ")")))

  (def: #export (send args method object)
    (-> (List Expression) Text Expression Expression)
    (|> object (field method) (apply args)))

  (do-template [<name> <apply>]
    [(def: #export (<name> args extra method)
       (-> (List Expression) Expression Text
           (-> Expression Expression))
       (|>> (field method) (<apply> args extra)))]

    [send-poly    apply-poly]
    [send-keyword apply-keyword]
    )

  (def: #export (nth idx array)
    (-> Expression Expression Expression)
    (@abstraction (format "(" (@representation array) "[" (@representation idx) "])")))

  (def: #export (if test then else)
    (-> Expression Expression Expression Expression)
    (@abstraction (format "(" (@representation then)
                          " if " (@representation test)
                          " else " (@representation else)
                          ")")))

  (do-template [<name> <op>]
    [(def: #export (<name> param subject)
       (-> Expression Expression Expression)
       (@abstraction (format "(" (@representation subject)
                             " " <op> " "
                             (@representation param) ")")))]

    [is      "is"]
    [=       "=="]
    [<       "<"]
    [<=      "<="]
    [>       ">"]
    [>=      ">="]
    [+       "+"]
    [-       "-"]
    [*       "*"]
    [/       "/"]
    [%       "%"]
    [**      "**"]
    [bit-or  "|"]
    [bit-and "&"]
    [bit-xor "^"]
    [bit-shl "<<"]
    [bit-shr ">>"]
    )

  (do-template [<name> <op>]
    [(def: #export (<name> param subject)
       (-> Expression Expression Expression)
       (@abstraction (format "(" (@representation param)
                             " " <op> " "
                             (@representation subject) ")")))]

    [or      "or"]
    [and     "and"]
    )

  (def: #export (not subject)
    (-> Expression Expression)
    (@abstraction (format "(not " (@representation subject) ")")))

  (def: #export (@@ var)
    (All [k] (-> (Var k) Expression))
    (@abstraction (format "(" (..name var) ")")))

  (def: #export (lambda arguments body)
    (-> (List (Ex [k] (Var k))) Expression Expression)
    (@abstraction (format "(" "lambda " (|> arguments (list/map ..name) (text.join-with ", ")) ": "
                          (@representation body) ")")))

  (def: #export global
    (-> Text Expression)
    (|>> var @@))

  (def: #export (length sequence)
    (-> Expression Expression)
    (apply (.list sequence) (global "len")))
  )

(abstract: #export Statement
  {}
  
  Text

  (def: #export statement (-> Statement Text) (|>> @representation))

  (def: nest
    (-> Statement Text)
    (|>> @representation
         (format "\n")
         (text.replace-all "\n" "\n  ")))

  (def: #export (set-nth! idx value array)
    (-> Expression Expression Expression Statement)
    (@abstraction (format (expression array) "[" (expression idx) "] = " (expression value))))

  (def: #export (set! vars value)
    (-> (List (Var Single)) Expression Statement)
    (@abstraction
     (format (|> vars (list/map ..name) (text.join-with ", "))
             " = "
             (expression value))))

  (def: #export (if! test then! else!)
    (-> Expression Statement Statement Statement)
    (@abstraction
     (format "if " (expression test) ":"
             (nest then!)
             "\n" "else:"
             (nest else!))))

  (def: #export (when! test then!)
    (-> Expression Statement Statement)
    (@abstraction
     (format "if " (expression test) ":"
             (nest then!))))

  (def: #export (cond! clauses else!)
    (-> (List [Expression Statement]) Statement Statement)
    (list/fold (.function [[test then!] next!]
                 (if! test then! next!))
               else!
               (list.reverse clauses)))

  (def: #export (then! pre! post!)
    (-> Statement Statement Statement)
    (@abstraction
     (format (@representation pre!)
             "\n"
             (@representation post!))))

  (def: #export (while! test body!)
    (-> Expression Statement Statement)
    (@abstraction
     (format "while " (expression test) ":"
             (nest body!))))

  (def: #export (for-in! var inputs body!)
    (-> SVar Expression Statement Statement)
    (@abstraction
     (format "for " (..name var) " in " (expression inputs) ":"
             (nest body!))))

  (def: #export (do! expression)
    (-> Expression Statement)
    (@abstraction
     (format (..expression expression) ";")))

  (def: #export no-op!
    Statement
    (@abstraction "\n"))

  (type: #export Except
    {#classes (List Text)
     #exception SVar
     #handler Statement})
  
  (def: #export (try! body! excepts)
    (-> Statement (List Except) Statement)
    (@abstraction
     (format "try:"
             (nest body!)
             (|> excepts
                 (list/map (function [[classes exception catch!]]
                             (format "\n" "except (" (text.join-with "," classes)
                                     ") as " (..name exception) ":"
                                     (nest catch!))))
                 (text.join-with "")))))

  (do-template [<name> <keyword>]
    [(def: #export (<name> message)
       (-> Expression Statement)
       (@abstraction
        (format <keyword> " " (expression message))))]

    [raise!  "raise"]
    [return! "return"]
    [print!  "print"]
    )
  
  (def: #export (def! name args body)
    (-> (Var Single) (List (Ex [k] (Var k))) Statement Statement)
    (@abstraction
     (format "def " (..name name)
             "(" (|> args (list/map ..name) (text.join-with ",")) "):"
             (nest body))))

  (def: #export (import! module-name)
    (-> Text Statement)
    (@abstraction (format "import " module-name)))
  )