(ql:quickload :parenscript)
(ql:quickload :cl-markup)

(defpackage :angular
  (:use :parenscript :cl)
  (:export main))
(declaim (optimize (speed 0) (safety 2) (debug 2)))

(in-package :angular)

(defpsmacro macros (&body body)
  `(lisp (progn
           ,@(loop for form in body
                   collect `(defpsmacro ,@form))
           "")))


(defmacro+ps scope-vars (&rest bindings)
  `(progn ,@(loop for (n v) in bindings collect `(scope-var ,n ,v))))

(defmacro+ps scope-var (name value)
  `(setf ($s ,name) ,value))

(defmacro+ps scope-function (name arguments &body body)
  `(scope-var ,name (lambda ,arguments
                      ,@body)))

(defmacro+ps $s (&rest values) `(chain $scope ,@values))

(defun build-lambda (dependencies body)
  `(list ,@(mapcar #'symbol-to-js-string dependencies)
         (lambda ,(loop for x in dependencies
                        collect x)
           ,@body
           )))


; This is just for slimv's sake
(defmacro defcontroller (name dependencies &body body)
  (declare (ignore name dependencies body)))


(defmacro+ps resource (name url params &body body)
  `(var ,name
        ($resource ,url ,(cons 'create params)
                   ,(cons 'create (loop for (name form) in body
                                         append (list name (cons 'create form)))))))


(defpsmacro defdirective (module-name name dependencies &body body)
  (let ((dependencies (cons '$scope dependencies)))
    `(chain ,module-name
            (directive ,(symbol-to-js-string name)
                       ,(build-lambda dependencies
                                      `((create
                                          ,@body)))))))
(defpsmacro markup (&body body)
  `(lisp (cl-markup:markup ,@body)))

(defun def-module-function (module-name block-name function-name)
  `(,block-name (name dependencies &body body)
                (let ((dependencies (cons '$scope dependencies)))
                  `(chain ,',module-name
                          (,',function-name ,(symbol-to-js-string name)
                                            ,(build-lambda dependencies body))))))

(defmacro+ps defmodule (module-name dependencies &body body)
  `(macrolet ((defdirective (name dependencies &body body)
                (let ((dependencies (cons '$scope dependencies)))
                  `(chain ,',module-name
                          (directive ,(symbol-to-js-string name)
                                     ,(build-lambda dependencies
                                                    `((create
                                                        ,@body)))))))

              ,(def-module-function module-name 'defservice 'service)
              ,(def-module-function module-name 'defcontroller 'controller))
     (progn (var ,module-name ((@ angular module) ,(symbol-to-js-string module-name) ,dependencies))
            ,@body)))

(defmacro+ps select-> (selector)
  `(chain document (query-selector ,selector)))

(defmacro+ps select->element (selector)
  `(chain angular (element (select-> ,selector))))


(defmacro+ps ng-ajax (mthd endpoint data resultS &body callback)
  `(chain $http
          (,mthd ,endpoint ,data)
          (success (lambda (,resultS)
                     ,@callback))))

(defun translate-file (infile outfile)
  (let ((*JS-TARGET-VERSION* 1.9))
    (with-open-file (o outfile :direction :output :if-exists :supersede)
      (with-open-file (i infile :direction :input)
        (write-line (ps-compile-file i) o)))))

(defun main (args)
  (in-package :angular)
  (apply #'translate-file (cdr args)))