#lang racket/base
(require racket/vector
         racket/class
         racket/promise
         unstable/error
         "interfaces.rkt"
         (only-in "sql-data.rkt" sql-null sql-null?))
(provide (all-defined-out))

;; == Administrative procedures

(define (connected? x)
  (send x connected?))

(define (disconnect x)
  (send x disconnect))

(define (connection-dbsystem x)
  (send x get-dbsystem))

(define (dbsystem-name x)
  (send x get-short-name))

(define (dbsystem-supported-types x)
  ;; FIXME: make version sensitive?
  (send x get-known-types +inf.0))

;; == Misc procedures

;; Value of prop:statement should be a function from struct instance to statement.
(define-values (prop:statement prop:statement? prop:statement-ref)
  (make-struct-type-property 'prop:statement))

(define (statement? x)
  (or (string? x)
      (prepared-statement? x)
      (statement-binding? x)
      (prop:statement? x)))

(define (bind-prepared-statement pst params)
  (send pst bind 'bind-prepared-statement params))

(define (prepared-statement-parameter-types pst)
  (send pst get-param-types))
(define (prepared-statement-result-types pst)
  (send pst get-result-types))

;; A virtual-statement is:
;;   - (virtual-statement table gen)
;;     where table is a weak-hasheq[connection => prepared-statement]
;;     and gen is (dbsystem -> string)
(struct virtual-statement (table gen)
        #:property prop:statement
        (lambda (stmt c)
          (let* ([table (virtual-statement-table stmt)]
                 [gen (virtual-statement-gen stmt)]
                 [base-c (send c get-base)])
            (let ([table-pst (and base-c (hash-ref table base-c #f))])
              (or table-pst
                  (let* ([sql-string (gen (send c get-dbsystem))]
                         ;; FIXME: virtual-connection:prepare1 handles
                         ;; fsym = 'virtual-statement case specially
                         [pst (prepare1 'virtual-statement c sql-string #f)])
                    (hash-set! table base-c pst)
                    pst))))))

(define virtual-statement*
  (let ([virtual-statement
         (lambda (gen)
           (virtual-statement (make-weak-hasheq)
                              (if (string? gen) (lambda (_) gen) gen)))])
    virtual-statement))

;; == Query procedures

;; query1 : connection symbol Statement -> QueryResult
(define (query1 c fsym stmt)
  (send c query fsym stmt #f))

;; query/rows : connection symbol Statement nat/#f -> rows-result
(define (query/rows c fsym sql want-columns)
  (let [(result (query1 c fsym sql))]
    (unless (rows-result? result)
      (error/want-rows fsym sql #t))
    (let ([got-columns (length (rows-result-headers result))])
      (when (and want-columns (not (= got-columns want-columns)))
        (error/column-count fsym sql want-columns got-columns #t)))
    result))

(define (query/cursor c fsym sql want-columns)
  (let ([result (send c query fsym sql #t)])
    (unless (cursor-result? result)
      (error/want-cursor fsym sql))
    (let ([got-columns (length (cursor-result-headers result))])
      (when (and want-columns (not (= got-columns want-columns)))
        (error/column-count fsym sql want-columns got-columns #t)))
    result))

(define (rows-result->row fsym rs sql maybe-row? one-column?)
  (define rows (rows-result-rows rs))
  (cond [(null? rows)
         (cond [maybe-row? #f]
               [else (error/row-count fsym sql 1 0)])]
        [(null? (cdr rows))
         (let ([row (car rows)])
           (cond [one-column? (vector-ref row 0)]
                 [else row]))]
        [else (error/row-count fsym sql 1 (length rows))]))

(define (compose-statement fsym c stmt args checktype)
  (cond [(prop:statement? stmt)
         (let ([stmt* ((prop:statement-ref stmt) stmt c)])
           (compose-statement fsym c stmt* args checktype))]
        [(or (pair? args)
             (prepared-statement? stmt)
             (virtual-statement? stmt))
         (let ([pst
                (cond [(string? stmt)
                       (prepare1 fsym c stmt #t)]
                      [(prepared-statement? stmt)
                       ;; Ownership check done later, by query method.
                       stmt]
                      [(statement-binding? stmt)
                       (error/statement-binding-args fsym stmt args)])])
           (send pst check-results fsym checktype stmt)
           (send pst bind fsym args))]
        [else ;; no args, and stmt is either string or statement-binding
         stmt]))

;; Query API procedures

;; query-rows : connection Statement arg ... -> (listof (vectorof 'a))
(define (query-rows c sql
                    #:group [group-fields-list null]
                    #:group-mode [group-mode null]
                    . args)
  (let* ([sql (compose-statement 'query-rows c sql args 'rows)]
         [result (query/rows c 'query-rows sql #f)]
         [result
          (cond [(not (null? group-fields-list))
                 (group-rows-result* 'query-rows result group-fields-list group-mode)]
                [else result])])
    (rows-result-rows result)))

;; query-list : connection Statement arg ... -> (listof 'a)
;; Expects to get back a rows-result with one field per row.
(define (query-list c sql . args)
  (let ([sql (compose-statement 'query-list c sql args 1)])
    (map (lambda (v) (vector-ref v 0))
         (rows-result-rows (query/rows c 'query-list sql 1)))))

;; query-row : connection Statement arg ... -> (vector-of 'a)
;; Expects to get back a rows-result of zero or one rows.
(define (query-row c sql . args)
  (let ([sql (compose-statement 'query-row c sql args 'rows)])
    (rows-result->row 'query-row
                    (query/rows c 'query-row sql #f)
                    sql #f #f)))

;; query-maybe-row : connection Statement arg ... -> (vector-of 'a) or #f
;; Expects to get back a rows-result of zero or one rows.
(define (query-maybe-row c sql . args)
  (let ([sql (compose-statement 'query-maybe-row c sql args 'rows)])
    (rows-result->row 'query-maybe-row
                    (query/rows c 'query-maybe-row sql #f)
                    sql #t #f)))

;; query-value : connection string arg ... -> value | raises error
;; Expects to get back a rows-result of exactly one row, exactly one column.
(define (query-value c sql . args)
  (let ([sql (compose-statement 'query-value c sql args 1)])
    (rows-result->row 'query-value
                    (query/rows c 'query-value sql 1)
                    sql #f #t)))

;; query-maybe-value : connection Statement arg ... -> value/#f
;; Expects to get back a rows-result of zero or one rows, exactly one column.
(define (query-maybe-value c sql . args)
  (let ([sql (compose-statement 'query-maybe-value c sql args 1)])
    (rows-result->row 'query-maybe-value
                    (query/rows c 'query-maybe-value sql 1)
                    sql #t #t)))

;; query-exec : connection Statement arg ... -> void
(define (query-exec c sql . args)
  (let ([sql (compose-statement 'query-exec c sql args #f)])
    (query1 c 'query-exec sql)
    (void)))

;; query : connection Statement arg ... -> QueryResult
(define (query c sql . args)
  (let ([sql (compose-statement 'query c sql args #f)])
    (query1 c 'query sql)))

;; ========================================

(define (in-query c stmt
                  #:fetch [fetch-size +inf.0]
                  #:group [grouping-fields null]
                  #:group-mode [group-mode null]
                  . args)
  (apply in-query-helper #f c stmt
         #:fetch fetch-size
         #:group grouping-fields
         #:group-mode group-mode
         args))

(define (in-query-helper vars c stmt
                         #:fetch [fetch-size +inf.0]
                         #:group [grouping-fields null]
                         #:group-mode [group-mode null]
                         . args)
  (when (and (not (null? grouping-fields))
             (< fetch-size +inf.0))
    (error 'in-query "cannot apply grouping to cursor (finite fetch-size)"))
  (let* ([check
          ;; If grouping, can't check expected arity.
          ;; FIXME: should check header includes named fields
          (cond [(null? grouping-fields) (or vars 'rows)]
                [else 'rows])]
         [stmt (compose-statement 'in-query c stmt args check)])
    (cond [(eqv? fetch-size +inf.0)
           (in-list/vector->values
            (rows-result-rows
             (let ([result (query/rows c 'in-query stmt vars)])
               (if (null? grouping-fields)
                   result
                   (group-rows-result* 'in-query result grouping-fields group-mode)))))]
          [else
           (let ([cursor (query/cursor c 'in-query stmt vars)])
             (in-list-generator/vector->values
              (lambda () (send c fetch/cursor 'in-query cursor fetch-size))))])))

(define (in-list/vector->values vs)
  (make-do-sequence
   (lambda ()
     (values (lambda (p) (vector->values (car p)))
             cdr
             vs
             pair? #f #f))))

(define (in-list-generator/vector->values fetch-proc)
  ;; fetch-proc : symbol nat -> (U list #f)
  ;; state = #f | (cons vector (U state (promise-of state)))

  ;; more-promise : -> (promise-of state)
  (define (more-promise)
    (delay (let ([more (fetch-proc)])
             ;; note: improper append, list onto promise
             (and more (append more (more-promise))))))

  (make-do-sequence
   (lambda ()
     (values (lambda (p) (vector->values (car p)))
             (lambda (p)
               (let ([next (cdr p)]) (if (promise? next) (force next) next)))
             (force (more-promise))
             pair? #f #f))))

;; ========================================

(define (prepare c stmt)
  ;; FIXME: handle non-string statements
  (prepare1 'prepare c stmt #f))

;; ----

(define (prepare1 fsym c stmt close-on-exec?)
  ;; stmt is string
  (send c prepare fsym stmt close-on-exec?))

;; ========================================

(define (start-transaction c
                           #:isolation [isolation #f]
                           #:option [option #f])
  (send c start-transaction 'start-transaction isolation option #f))

(define (commit-transaction c)
  (send c end-transaction 'commit-transaction 'commit #f))

(define (rollback-transaction c)
  (send c end-transaction 'rollback-transaction 'rollback #f))

(define (call-with-transaction c proc
                               #:isolation [isolation #f]
                               #:option [option #f])
  (send c start-transaction '|call-with-transaction (start)| isolation option #t)
  (with-handlers ([exn?
                   (lambda (e1)
                     (with-handlers ([exn?
                                      (lambda (e2)
                                        (error/exn-in-rollback 'call-with-transaction e1 e2))])
                       (send c end-transaction '|call-with-transaction (rollback)| 'rollback #t))
                     (raise e1))])
    (begin0 (call-with-continuation-barrier proc)
      (send c end-transaction '|call-with-transaction (commit)| 'commit #t))))

(define (in-transaction? c)
  (and (send c transaction-status 'in-transaction?) #t))

(define (needs-rollback? c)
  (eq? (send c transaction-status 'needs-rollback?) 'invalid))

;; ========================================

;; list-tables : ... -> (listof string)
;;  - lists unqualified table/view/etc names in search path (omit system tables, if possible).
;;    Maybe it would be better to just search the current schema only?
;;    or maybe mode = 'current | 'search | 'current-or-search (default)
;;  - lists unqualified table/view/etc names for given schema (and/or catalog?)
;;  - Add option to include system tables?
(define (list-tables c
                     #:schema [schema 'search-or-current])
  (send c list-tables 'list-tables schema))

(define (table-exists? c table-name
                       #:schema [schema 'search-or-current]
                       #:case-sensitive? [cs? #f])
  (let ([tables (send c list-tables 'table-exists? schema)])
    (for/or ([table (in-list tables)])
      (if cs?
          (string=? table-name table)
          (string-ci=? table-name table)))))

;; list-tables* : ... -> (listof vector)
;; Return full catalog/schema/table/type list.

;; ========================================

;; FIXME: add 'assume-sorted optimization option?

(define (group-rows result
                    #:group key-fields-list
                    #:group-mode [group-mode null])
  (when (null? key-fields-list)
    (error 'group-rows "expected at least one grouping field set"))
  (group-rows-result* 'group-rows result key-fields-list group-mode))

(define (group-rows-result* fsym result key-fields-list group-mode)
  (let* ([invert-outer? (not (or (memq 'preserve-null group-mode)
                                 ;; old flag, deprecated:
                                 (memq 'preserve-null-rows group-mode)))]
         [as-list? (memq 'list group-mode)]
         [headers (rows-result-headers result)]
         [total-fields (length headers)]
         [name-map (headers->name-map headers)]
         [fields-used (make-vector total-fields #f)]
         [key-indexes-list
          (group-list->indexes fsym name-map total-fields fields-used key-fields-list)]
         [residual-length
          (for/sum ([x (in-vector fields-used)]) (if x 0 1))])
    (when (= residual-length 0)
      (raise-arguments-error fsym "cannot group by all fields"
                             "grouping field sets" key-fields-list))
    (when (and (> residual-length 1) as-list?)
      (raise-arguments-error fsym "expected exactly one residual field when #:group-mode is 'list"
                             "grouping field sets" key-fields-list
                             "residual field count" residual-length))
    (let* ([initial-projection
            (for/vector #:length total-fields ([i (in-range total-fields)]) i)]
           [headers
            (group-headers (list->vector headers)
                           initial-projection
                           key-indexes-list)]
           [rows
            (group-rows* fsym
                         (rows-result-rows result)
                         initial-projection
                         key-indexes-list
                         invert-outer?
                         as-list?)])
      (rows-result headers rows))))

(define (headers->name-map headers)
  (for/hash ([header (in-list headers)]
             [i (in-naturals)]
             #:when (assq 'name header))
    (values (cdr (assq 'name header)) i)))

(define (group-list->indexes fsym name-map total-fields fields-used key-fields-list)
  (let ([key-fields-list (if (list? key-fields-list) key-fields-list (list key-fields-list))])
    (for/list ([key-fields (in-list key-fields-list)])
      (group->indexes fsym name-map total-fields fields-used key-fields))))

(define (group->indexes fsym name-map total-fields fields-used key-fields)
  (let ([key-fields (if (vector? key-fields) key-fields (vector key-fields))])
    (for/vector ([key-field (in-vector key-fields)])
      (grouping-field->index fsym name-map total-fields fields-used key-field))))

(define (grouping-field->index fsym name-map total-fields fields-used key-field)
  (let ([key-index
         (cond [(string? key-field)
                (hash-ref name-map key-field #f)]
               [else key-field])])
    (when (string? key-field)
      (unless key-index
        (raise-arguments-error fsym "bad grouping field"
                               "given" key-field
                               "available" (sort (hash-keys name-map) string<?))))
    (when (exact-integer? key-field)
      (unless (< key-index total-fields)
        (raise-range-error fsym "fields" "grouping "
                           key-index
                           (sort (hash-keys name-map) string<?)
                           0 total-fields)))
    (when fields-used
      (when (vector-ref fields-used key-index)
        (raise-arguments-error fsym "grouping field used multiple times"
                               "field" key-field))
      (vector-set! fields-used key-index #t))
    key-index))

(define (group-headers headers projection key-indexes-list)
  (define (get-headers vec)
    (for/list ([index (in-vector vec)])
      (vector-ref headers index)))
  (cond [(null? key-indexes-list)
         (get-headers projection)]
        [else
         (let* ([key-indexes (car key-indexes-list)]
                [residual-projection
                 (vector-filter-not (lambda (index) (vector-member index key-indexes))
                                    projection)]
                [residual-headers
                 (group-headers headers residual-projection (cdr key-indexes-list))])
           (append (get-headers key-indexes)
                   (list `((name . "grouped") (grouped . ,residual-headers)))))]))

(define (group-rows* fsym rows projection key-indexes-list invert-outer? as-list?)
  ;; projection is vector of indexes (actually projection and permutation)
  ;; invert-outer? => residual rows with all NULL fields are dropped.
  (cond [(null? key-indexes-list)
         ;; Apply projection to each row
         (cond [as-list?
                (unless (= (vector-length projection) 1)
                  (error/internal
                   fsym 
                   "list mode requires a single residual column, got ~s"
                   (vector-length projection)))
                (let ([index (vector-ref projection 0)])
                  (for/list ([row (in-list rows)])
                    (vector-ref row index)))]
               [else
                (let ([plen (vector-length projection)])
                  (for/list ([row (in-list rows)])
                    (let ([v (make-vector plen)])
                      (for ([i (in-range plen)])
                        (vector-set! v i (vector-ref row (vector-ref projection i))))
                      v)))])]
        [else
         (let ()
           (define key-indexes (car key-indexes-list))
           (define residual-projection
             (vector-filter-not (lambda (index) (vector-member index key-indexes))
                                projection))
           (define key-row-length (vector-length key-indexes))
           (define (row->key-row row)
             (for/vector #:length key-row-length
                         ([i (in-vector key-indexes)])
                         (vector-ref row i)))
           (define (residual-all-null? row)
             (for/and ([i (in-vector residual-projection)])
                      (sql-null? (vector-ref row i))))
           (let* ([key-table (make-hash)]
                  [r-keys
                   (for/fold ([r-keys null])
                       ([row (in-list rows)])
                     (let* ([key-row (row->key-row row)]
                            [already-seen? (and (hash-ref key-table key-row #f) #t)])
                       (unless already-seen?
                         (hash-set! key-table key-row null))
                       (unless (and invert-outer? (residual-all-null? row))
                         (hash-set! key-table key-row (cons row (hash-ref key-table key-row))))
                       (if already-seen?
                           r-keys
                           (cons key-row r-keys))))])
             (for/list ([key (in-list (reverse r-keys))])
               (let ([residuals
                      (group-rows* fsym
                                   (reverse (hash-ref key-table key))
                                   residual-projection
                                   (cdr key-indexes-list)
                                   invert-outer?
                                   as-list?)])
                 (vector-append key (vector residuals))))))]))

;; ========================================

(define not-given (gensym 'not-given))

(define (rows->dict result
                    #:key key-field/s
                    #:value value-field/s
                    #:value-mode [value-mode null])
  (let* ([who 'rows->dict]
         [headers (rows-result-headers result)]
         [total-fields (length headers)]
         [name-map (headers->name-map headers)]
         [preserve-null? (memq 'preserve-null value-mode)]
         [value-list? (memq 'list value-mode)])
    (define (make-project field/s)
      (if (vector? field/s)
          (let* ([indexes (group->indexes who name-map total-fields #f field/s)]
                 [indexes-length (vector-length indexes)])
            (lambda (v)
              (for/vector #:length indexes-length ([i (in-vector indexes)])
                (vector-ref v i))))
          (let ([index (grouping-field->index who name-map total-fields #f field/s)])
            (lambda (v) (vector-ref v index)))))
    (define get-key (make-project key-field/s))
    (define get-value (make-project value-field/s))
    (define ok-value?
      (cond [preserve-null? (lambda (v) #t)]
            [(vector? value-field/s)
             (lambda (v) (not (for/or ([e (in-vector v)]) (sql-null? e))))]
            [else (lambda (v) (not (sql-null? v)))]))
    (for/fold ([table '#hash()]) ([row (in-list (if value-list?
                                                    (reverse (rows-result-rows result))
                                                    (rows-result-rows result)))])
      (let* ([key (get-key row)]
             [value (get-value row)]
             [old-value (hash-ref table key (if value-list? '() not-given))])
        (unless (or value-list?
                    (eq? (hash-ref table key not-given) not-given)
                    ;; FIXME: okay to coalesce values if equal?
                    (equal? value old-value))
          (raise-misc-error who "duplicate value for key"
                            '("key" value) key
                            '("values" multi value) (list old-value value)))
        (if value-list?
            (hash-set table key
                      (if (ok-value? value)
                          (cons value old-value)
                          ;; If all-NULL value, still enter key => '() into dict
                          old-value))
            (if (ok-value? value)
                (hash-set table key value)
                table))))))