(.require
 [library
  [lux (.except Type Primitive int char parameter)
   [abstract
    ["[0]" monad (.only do)]]
   [control
    ["[0]" maybe]
    ["[0]" try]
    ["<>" parser (.only)]]
   [data
    ["[0]" text (.only)
     ["%" \\format (.only format)]
     ["<[1]>" \\parser (.only Parser)]]
    [collection
     ["[0]" dictionary (.only Dictionary)]]]]]
 ["[0]" // (.only Type)
  [category (.only Void Value Return Method Primitive Object Class Array Var Parameter)]
  ["[1][0]" descriptor]
  ["[1][0]" signature (.only Signature)]
  ["[1][0]" reflection]
  ["[1][0]" parser]
  ["/[1]" //
   [encoding
    ["[1][0]" name]]]])

(type .public Aliasing
  (Dictionary Text Text))

(def .public fresh
  Aliasing
  (dictionary.empty text.hash))

(def (var aliasing)
  (-> Aliasing (Parser (Type Var)))
  (do <>.monad
    [var //parser.var']
    (in (|> aliasing
            (dictionary.value var)
            (maybe.else var)
            //.var))))

(def (class parameter)
  (-> (Parser (Type Parameter)) (Parser (Type Class)))
  (|> (do <>.monad
        [name //parser.class_name
         parameters (|> (<>.some parameter)
                        (<>.after (<text>.this //signature.parameters_start))
                        (<>.before (<text>.this //signature.parameters_end))
                        (<>.else (list)))]
        (in (//.class name parameters)))
      (<>.after (<text>.this //descriptor.class_prefix))
      (<>.before (<text>.this //descriptor.class_suffix))))

(with_template [<name> <prefix> <bound> <constructor>]
  [(def <name>
     (-> (Parser (Type Class)) (Parser (Type Parameter)))
     (|>> (<>.after (<text>.this <prefix>))
          (at <>.monad each <bound>)))]

  [lower //signature.lower_prefix //.lower ..Lower]
  [upper //signature.upper_prefix //.upper ..Upper]
  )

(def (parameter aliasing)
  (-> Aliasing (Parser (Type Parameter)))
  (<>.rec
   (function (_ parameter)
     (let [class (..class parameter)]
       (all <>.either
            (..var aliasing)
            //parser.wildcard
            (..lower class)
            (..upper class)
            class
            )))))

(def (value aliasing)
  (-> Aliasing (Parser (Type Value)))
  (<>.rec
   (function (_ value)
     (all <>.either
          //parser.primitive
          (parameter aliasing)
          (//parser.array' value)
          ))))

(def (inputs aliasing)
  (-> Aliasing (Parser (List (Type Value))))
  (|> (<>.some (..value aliasing))
      (<>.after (<text>.this //signature.arguments_start))
      (<>.before (<text>.this //signature.arguments_end))))

(def (return aliasing)
  (-> Aliasing (Parser (Type Return)))
  (all <>.either
       //parser.void
       (..value aliasing)
       ))

(def (exception aliasing)
  (-> Aliasing (Parser (Type Class)))
  (|> (..class (..parameter aliasing))
      (<>.after (<text>.this //signature.exception_prefix))))

(def (bound aliasing)
  (-> Aliasing (Parser (Type Class)))
  (do <>.monad
    [_ (<text>.this ":")]
    (..class (..parameter aliasing))))

(def (bound_type_var aliasing)
  (-> Aliasing (Parser (Type Var)))
  (|> //parser.var_name
      (at <>.monad each //.var)
      (<>.before (<>.many (..bound aliasing)))))

(def .public (method aliasing)
  (-> Aliasing (-> (Type Method) (Type Method)))
  (|>> //.signature
       //signature.signature
       (<text>.result (do <>.monad
                        [type_variables (|> (<>.some (..bound_type_var aliasing))
                                            (<>.after (<text>.this //signature.parameters_start))
                                            (<>.before (<text>.this //signature.parameters_end))
                                            (<>.else (list)))
                         inputs (..inputs aliasing)
                         return (..return aliasing)
                         exceptions (<>.some (..exception aliasing))]
                        (in (//.method [type_variables inputs return exceptions]))))
       try.trusted))