#| export
import subprocess
from pathlib import Path

#| export
install_emacs_scr="""
#!/usr/bin/env bash
set -euxo pipefail

mkdir -p $HOME/.local/bin

cd $HOME/.local/bin

# github repo: https://github.com/blahgeek/emacs-appimage/releases?q=Release&expanded=true

# download nox release: 

# older: known good
#curl -L -O https://github.com/blahgeek/emacs-appimage/releases/download/github-action-build-11538673229/Emacs-30.0.92-nox.AppImage
#E=Emacs-30.0.92-nox.AppImage

# # newer: untested
# curl -L -O https://github.com/blahgeek/emacs-appimage/releases/download/github-action-build-15043247736/Emacs-30.1-nox-x86_64.AppImage
# E=Emacs-30.1-nox-x86_64.AppImage

curl -L -O https://github.com/blahgeek/emacs-appimage/releases/download/github-action-build-17008212441/Emacs-30.2-nox-x86_64.AppImage
E=Emacs-30.2-nox-x86_64.AppImage

chmod u+x $E
./"$E" --appimage-extract
mkdir emacsdir
mv squashfs-root emacsdir

cat << 'EOF' > ctags
#!/bin/bash
WRAPPER_ROOT="$(dirname "$(readlink -f "$0")")"
exec "$WRAPPER_ROOT/emacsdir/squashfs-root/AppRun" --emacs-appimage-run-as ctags "$@"
EOF

cat << 'EOF' > ebrowse
#!/bin/bash
WRAPPER_ROOT="$(dirname "$(readlink -f "$0")")"
exec "$WRAPPER_ROOT/emacsdir/squashfs-root/AppRun"  --emacs-appimage-run-as ebrowse "$@"
EOF

cat << 'EOF' > emacs
#!/bin/bash
WRAPPER_ROOT="$(dirname "$(readlink -f "$0")")"
exec "$WRAPPER_ROOT/emacsdir/squashfs-root/AppRun" "$@"
EOF

cat << 'EOF' > emacsclient
#!/bin/bash
WRAPPER_ROOT="$(dirname "$(readlink -f "$0")")"
exec "$WRAPPER_ROOT/emacsdir/squashfs-root/AppRun"  --emacs-appimage-run-as emacsclient "$@"
EOF

chmod u+x ctags ebrowse emacs emacsclient
"""

#| export
def install_emacs():
    "Installs emacs, returning True on success"
    from pathlib import Path
    if (Path().home() / '.local/bin/emacs').exists():
        print("already installed.")
        return True
    cp = subprocess.run(install_emacs_scr,shell=True,executable='/usr/bin/bash',capture_output=True)
    return cp.returncode == 0

install_emacs()

#| export
def start_emacs_server():
    "Starts an emacs daemon"
    import subprocess
    from pathlib import Path
    return subprocess.run(str(Path().home() / '.local/bin/emacs') + ' --daemon',shell=True,executable='/usr/bin/bash')

start_emacs_server()

#| export
def eval_lisp_for_value(code:str):
    "Evaluates an emacs lisp expression and return the resulting value"
    from pathlib import Path
    return subprocess.run([
        str(Path().home() / '.local/bin/emacsclient'),
        '-e',code],capture_output=True).stdout.decode()

print( eval_lisp_for_value("(+ 1 2 3)").strip() )

print( eval_lisp_for_value(""" "Hello, World" """).strip() )

#| export
def eval_lisp(code:str):
    "Evaluates a lisp expression and return (value,out,message)"
    from pathlib import Path
    import tempfile
    tmpout = tempfile.NamedTemporaryFile(delete=False).name
    tmperr = tempfile.NamedTemporaryFile(delete=False).name
    preamble = """
(require 'cl-lib) 
(defmacro with-captured-elisp-io (stdout-file stderr-file &rest body)
  "Capture standard-output and message output while returning BODY's value."
  (declare (indent 2))
  `(let ((out (generate-new-buffer " *out*"))
         (err (generate-new-buffer " *err*")))
     (unwind-protect
         (prog1
             (cl-letf (((symbol-function 'message)
                        (lambda (fmt &rest args)
                          (with-current-buffer err
                            (insert (apply #'format fmt args) "\n"))
                          ;; Return the displayed message as usual:
                          (apply #'format fmt args))))
               (let ((standard-output out))
                 ,@body))
           (with-current-buffer out
             (write-region (point-min) (point-max) ,stdout-file nil 'silent))
           (with-current-buffer err
             (write-region (point-min) (point-max) ,stderr-file nil 'silent)))
       (kill-buffer out)
       (kill-buffer err))))"""
    wrapped_code =  f"""(with-captured-elisp-io "{tmpout}" "{tmperr}" {code})"""
    form = "(progn " + preamble + wrapped_code + ")"
    cp = subprocess.run([str(Path().home() / '.local/bin/emacsclient'),'-e',form],capture_output=True)
    out = Path(tmpout).read_text()
    err = Path(tmperr).read_text()
    return cp.stdout.decode(), out, err

ret = eval_lisp(""" (princ "Hello\nWorld") """)
print( "output value: ")
print( ret[0] )
print( "\nprinted output: ")
print( ret[1] )
print( "\nerror messages: ")
print( ret[2] )

#| export
from IPython.core.magic import register_cell_magic
from dialoghelper import find_msg_id
import base64

@register_cell_magic
def elisp(line, cell):
    """Evaluate emacs lisp in an emacs daemon and return a lisp form."""    
    output = eval_lisp(cell)[0].rstrip()
    if output: print(output)

%%elisp
(+ 1 (* 3 4))

%%elisp
"Hello, World. A string is a lisp atom"

%%elisp
:keywords-are-self-evaluating

%%elisp
nil

%%elisp
(let* ((width 50)
       (height 50)
       (max-iter 80)
       (x-min -2.5)
       (x-max 1.0)
       (y-min -1.5)
       (y-max 1.5)
       (chars " .:-=+*#%@"))
  (with-output-to-temp-buffer "*m*"
    (dotimes (j height)
      (let* ((y (+ y-min
                   (* (/ (float j) (1- height))
                      (- y-max y-min)))))
        (dotimes (i width)
          (let* ((x (+ x-min
                       (* (/ (float i) (1- width))
                          (- x-max x-min))))
                 (zx 0.0)
                 (zy 0.0)
                 (iter 0))
            (while (and (< iter max-iter)
                        (< (+ (* zx zx) (* zy zy)) 4.0))
              (let* ((zx2 (- (* zx zx) (* zy zy)))
                     (zy2 (* 2.0 zx zy)))
                (setq zx (+ zx2 x)
                      zy (+ zy2 y)
                      iter (1+ iter))))
            (let* ((len (length chars))
                   (index (if (= iter max-iter)
                              (1- len)
                            (floor (* (/ (float iter) max-iter)
                                      (1- len))))))
              (princ (aref chars index)))))
        (princ "\n")))))

#| export
def list_buffers():
    "Prints emacs buffers, using list-buffers-noselect"
    return eval_lisp("""(princ (with-current-buffer 
      (list-buffers-noselect) 
      (buffer-substring-no-properties (point-min) (point-max))))
      """)[1]

print( list_buffers() )

#| export
def view_buffer(buffer:str):
    "Returns the contents of an emacs buffer"
    return eval_lisp(f"""(princ (with-current-buffer (get-buffer "{buffer}") (buffer-substring-no-properties (point-min) (point-max))))""")[1]

print( view_buffer("*scratch*") )

print( view_buffer("*m*") )

#| export
def create_buffer(name:str, contents:str):
    "Create an emacs buffer, populated with contents"
    lisp_escaped = contents.replace('\\', '\\\\').replace('"', '\\"')
    return eval_lisp(f"""
(with-current-buffer (get-buffer-create "{name}")
  (erase-buffer)
  (insert "{lisp_escaped}")
  (current-buffer))""")[0]

print( list_buffers() )

print( view_buffer('testbuf2') )