(.using
 [library
  [lux {"-" and int}
   [ffi {"+" import:}]
   [control
    [functor {"+" Functor}]
    [apply {"+" Apply}]
    [monad {"+" Monad do}]
    ["ex" exception]
    ["[0]" try {"+" Try}]]
   [time
    ["[0]" instant {"+" Instant}]]
   ["[0]" io {"+" IO}]
   [world
    [binary {"+" Binary}]]]])

(import: java/lang/String)

(import: java/util/Date
  (getTime [] long))

(import: java/sql/Date)
(import: java/sql/Time)
(import: java/sql/Timestamp)

(`` (import: java/sql/ResultSet
      (~~ (template [<method_name> <return_class>]
            [(<method_name> [int] "try" <return_class>)]
            
            [getBoolean   boolean]
            
            [getByte      byte]
            [getShort     short]
            [getInt       int]
            [getLong      long]

            [getDouble    double]
            [getFloat     float]

            [getString    java/lang/String]
            [getBytes     [byte]]
            
            [getDate      java/sql/Date]
            [getTime      java/sql/Time]
            [getTimestamp java/sql/Timestamp]
            ))
      (next [] "try" boolean)
      (close [] "io" "try" void)))

(type: .public (Output a)
  (-> [Nat java/sql/ResultSet] (Try [Nat a])))

(implementation: .public functor
  (Functor Output)
  
  (def: (each f fa)
    (function (_ idx+rs)
      (case (fa idx+rs)
        {try.#Failure error}
        {try.#Failure error}
        
        {try.#Success [idx' value]}
        {try.#Success [idx' (f value)]}))))

(implementation: .public apply
  (Apply Output)
  
  (def: functor ..functor)

  (def: (apply ff fa)
    (function (_ [idx rs])
      (case (ff [idx rs])
        {try.#Success [idx' f]}
        (case (fa [idx' rs])
          {try.#Success [idx'' a]}
          {try.#Success [idx'' (f a)]}

          {try.#Failure msg}
          {try.#Failure msg})

        {try.#Failure msg}
        {try.#Failure msg}))))

(implementation: .public monad
  (Monad Output)
  
  (def: functor ..functor)

  (def: (in a)
    (function (_ [idx rs])
      {.#Some [idx a]}))
  
  (def: (conjoint mma)
    (function (_ [idx rs])
      (case (mma [idx rs])
        {try.#Failure error}
        {try.#Failure error}
        
        {try.#Success [idx' ma]}
        (ma [idx' rs])))))

(def: .public (fail error)
  (All (_ a) (-> Text (Output a)))
  (function (_ [idx result_set])
    {try.#Failure error}))

(def: .public (and left right)
  (All (_ a b)
    (-> (Output a) (Output b) (Output [a b])))
  (do ..monad
    [=left left
     =right right]
    (in [=left =right])))

(template [<func_name> <method_name> <type>]
  [(def: .public <func_name>
     (Output <type>)
     (function (_ [idx result_set])
       (case (<method_name> [(.int idx)] result_set)
         {try.#Failure error}
         {try.#Failure error}

         {try.#Success value}
         {try.#Success [(++ idx) value]})))]

  [boolean java/sql/ResultSet::getBoolean Bit]

  [byte    java/sql/ResultSet::getByte    Int]
  [short   java/sql/ResultSet::getShort   Int]
  [int     java/sql/ResultSet::getInt     Int]
  [long    java/sql/ResultSet::getLong    Int]

  [float   java/sql/ResultSet::getFloat   Frac]
  [double  java/sql/ResultSet::getDouble  Frac]

  [string  java/sql/ResultSet::getString  Text]
  [bytes   java/sql/ResultSet::getBytes   Binary]
  )

(template [<func_name> <method_name>]
  [(def: .public <func_name>
     (Output Instant)
     (function (_ [idx result_set])
       (case (<method_name> [(.int idx)] result_set)
         {try.#Failure error}
         {try.#Failure error}

         {try.#Success value}
         {try.#Success [(++ idx)
                        (instant.from_millis (java/util/Date::getTime value))]})))]

  [date       java/sql/ResultSet::getDate]
  [time       java/sql/ResultSet::getTime]
  [time_stamp java/sql/ResultSet::getTimestamp]
  )

(def: .public (rows output results)
  (All (_ a) (-> (Output a) java/sql/ResultSet (IO (Try (List a)))))
  (case (java/sql/ResultSet::next results)
    {try.#Success has_next?}
    (if has_next?
      (case (output [1 results])
        {.#Some [_ head]}
        (do io.monad
          [?tail (rows output results)]
          (case ?tail
            {try.#Success tail}
            (in {try.#Success {.#Item head tail}})

            {try.#Failure error}
            (do io.monad
              [temp (java/sql/ResultSet::close results)]
              (in (do try.monad
                    [_ temp]
                    (try.failure error))))))

        {try.#Failure error}
        (do io.monad
          [temp (java/sql/ResultSet::close results)]
          (in (do try.monad
                [_ temp]
                (try.failure error)))))
      (do io.monad
        [temp (java/sql/ResultSet::close results)]
        (in (do try.monad
              [_ temp]
              (in (list))))))

    {try.#Failure error}
    (do io.monad
      [temp (java/sql/ResultSet::close results)]
      (in (do try.monad
            [_ temp]
            (try.failure error))))
    ))