(library (bs string (0))
  (export
   replace replace-char to-string str capitalize split
   strip lstrip rstrip prefix? suffix?)
  (import
    (rnrs base)
    (only  (rnrs control) case-lambda)
    (only (rnrs io simple) display)
    (only (srfi srfi-13)
          string-trim string-trim-both string-trim-right
          string-prefix? string-suffix? string-upcase string-concatenate
          string-drop string-take string-contains substring/shared string-null? string-fold
          string-tokenize)
    (only (srfi srfi-14)
          string->char-set char-set-complement char-set)
    (only (srfi srfi-28) format)
    ;; TODO: port ice-9 dependency or replace with (scheme something)
    (only (ice-9 ports) with-output-to-string))

  (define (prefix? s pre)
    "Is PRE a prefix of S?"
    (string-prefix? pre s))

  (define (suffix? s suf)
    "Is SUF a suffix of S?"
    (string-suffix? suf s))

  (define (split s sep)
    "Split S at SEP"
    ;; this is still wrong. it splits on any of the "sep" characters
    ;; instead of all of them
    (string-tokenize s (char-set-complement (apply char-set (string->list sep)))))

  (define (replace-char s match char)
    "Replace MATCH in S with CHAR"
    (let ((f (lambda (a b)
               (let ((next-char (if (eq? a match) char a)))
                 (string-concatenate (list b (string next-char)))))))
      (string-fold f "" s)))

  (define (replace s match repl)
    "Replace MATCH in S with REPL"
    ;; based on string-replace-substring By A. Wingo in
    ;; https://lists.gnu.org/archive/html/guile-devel/2014-03/msg00058.html
    ;; also in string-replace-substring guix:guix/utils.scm.
    (let ((matchlen (string-length match)))
      (with-output-to-string
        (lambda ()
          (let lp ((start 0))
            (cond
             ((string-contains s match start)
              => (lambda (end)
                   (display (substring/shared s start end))
                   (display repl)
                   (lp (+ end matchlen))))
             (else
              (display (substring/shared s start)))))))))

  (define (to-string x)
    (format #f "~a" x))

  (define str
    (case-lambda
      (() "")
      ((x) (to-string x))
      ((x . rest) (string-concatenate (map str (cons x rest))))))

  (define (capitalize s)
    (let ((s (to-string s)))
      (if (< (string-length s) 2)
          (string-upcase s)
          (str (string-upcase (substring s 0 1))
               (substring s 1 )))))

  (define (strip s char)
    (string-trim-both s char))

  (define (lstrip s char)
    (string-trim s char))

  (define (rstrip s char)
    (string-trim-right s char )))