(defpackage :strings-and-runes
  (:use :cl))

(in-package :strings-and-runes)

(defun main ()
  ;; `s` is a string assigned a literal value
  ;; representing the word "hello" in the Thai
  ;; language. Lisp string literals are typically
  ;; UTF-8 encoded text.
  (defparameter *s* "สวัสดี")

  ;; In Lisp, we can get the length of a string using the
  ;; `length` function. This will return the number of characters,
  ;; not the number of bytes.
  (format t "Len: ~A~%" (length *s*))

  ;; To iterate over the characters in a string, we can use
  ;; the `loop` macro with `across`.
  (format t "Characters: ")
  (loop for char across *s*
        do (format t "~A " (char-code char)))
  (terpri)

  ;; In Common Lisp, there's no built-in function to count
  ;; Unicode code points. We can create a custom function
  ;; for this purpose.
  (defun unicode-char-count (string)
    (length (remove-if-not #'characterp string)))

  (format t "Unicode char count: ~A~%" (unicode-char-count *s*))

  ;; We can use `loop` with `for` and `across` to iterate
  ;; over characters in a string.
  (loop for char across *s*
        for i from 0
        do (format t "U+~4,'0X '~A' starts at ~D~%"
                   (char-code char) char i))

  ;; Common Lisp doesn't have a direct equivalent to Go's
  ;; DecodeRuneInString, but we can iterate over characters
  ;; using similar logic.
  (format t "~%Using character iteration~%")
  (loop for i from 0 below (length *s*)
        for char = (char *s* i)
        do (progn
             (format t "U+~4,'0X '~A' starts at ~D~%"
                     (char-code char) char i)
             (examine-char char))))

(defun examine-char (c)
  ;; In Common Lisp, we can compare characters directly.
  (cond ((char= c #\t)
         (format t "found tee~%"))
        ((char= c #\ส)
         (format t "found so sua~%"))))

;; Call the main function
(main)