;;;; mpd-remote.lisp

(in-package #:mpd-remote)

;;; "mpd-remote" goes here. Hacks and glory await!

(defun call-with-mpd-connection (host port cb)
  (usocket:with-client-socket (sock stream host port :element-type '(unsigned-byte 8))
    (let ((stream (flexi-streams:make-flexi-stream stream :external-format :utf8)))
      (assert (alexandria:starts-with-subseq "OK" (read-line stream)))
      (funcall cb sock stream))))

(define-condition mpd-error ()
  ((message :initarg :message :reader message))
  (:report (lambda (condition stream)
	     (format stream "~a" (message condition)))))

(defmacro do-until ((end-condition &optional result) &body body)
  `(do () (,end-condition ,@(when result `(,result)))
     ,@body))

(defun get-response (stream)
  (let ((result (list))
	(done nil))
      (do-until (done (nreverse result))
	(let ((line (read-line stream)))
	  (format t "~&~s~%" line)
	  (if (string= line "OK")
	      (setf done t)
	      (multiple-value-bind (error-p suffix) (alexandria:starts-with-subseq "ACK" line :return-suffix t)
		(if error-p
		    (error 'mpd-error :message (serapeum:trim-whitespace suffix))
		    (push line result))))))))

(defmacro with-mpd-connection ((socket-sym stream-sym &optional (host "127.0.0.1") (port 6600)) &body body)
  `(call-with-mpd-connection ,host ,port
			     (lambda (,socket-sym ,stream-sym)
			       ,@body)))

(defclass mpd-command ()
  ())

(defgeneric render-mpd-command (command args))

(defgeneric send-command (stream command &key)
  (:method (stream command &rest r &key)
    (write-line (render-mpd-command command
				    r)
		stream)
    (finish-output stream)
    (get-response stream)))

(defclass current-song (mpd-command)
  ())

(defmacro mpd-progn ((stream) &body body)
  `(let ((*standard-output* ,stream))
     (write-line "command_list_ok_begin")
     (unwind-protect (progn ,@body)
       (write-line "command_list_end"))))

(defmethod render-mpd-command ((command (eql :current-song)) args)
  (declare (ignore command args))
  "currentsong")

(defmethod send-command :around (stream (command (eql :current-song)) &key)
  (declare (ignore stream))
  (mpd-remote.song:parse-song (call-next-method)))

(defmethod render-mpd-command ((command (eql :playlist-info)) args)
  (declare (ignore command))
  (format nil "playlistinfo ~{~a~^:~}" (getf args :slice)))

(defmethod send-command :around (stream (command (eql :playlist-info)) &key slice)
  (declare (ignore command stream))
  (mapcar #'mpd-remote.song:parse-song
	  (mpd-remote.song:split-songs (call-next-method))))

(defmethod render-mpd-command ((command (eql :play)) args)
  (declare (ignore command))
  "play")

(defmethod render-mpd-command ((command symbol) args)
  (declare (ignore args))
  (when (keywordp command)
    (string-downcase command)))