zotelo.el

;;; zotelo.el --- Manage Zotero collections from emacs
;;
;; Filename: zotelo.el
;; Author: Spinu Vitalie
;; Maintainer: Spinu Vitalie
;; Copyright (C) 2011-2012, Spinu Vitalie, all rights reserved.
;; Created: Oct 2 2011
;; Version: 1.3.9000
;; URL: https://github.com/vitoshka/zotelo
;; Keywords: zotero, emacs, reftex, bibtex, MozRepl, bibliography manager
;; Package-Requires: ((cl-lib "0.5"))
;;
;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;; This file is *NOT* part of GNU Emacs.
;;
;; This program is free software; you can redistribute it and/or
;; modify it under the terms of the GNU General Public License as
;; published by the Free Software Foundation; either version 3, or
;; (at your option) any later version.
;;
;; This program is distributed in the hope that it will be useful,
;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
;; General Public License for more details.
;;
;; You should have received a copy of the GNU General Public License
;; along with this program; see the file COPYING.  If not, write to
;; the Free Software Foundation, Inc., 51 Franklin Street, Fifth
;; Floor, Boston, MA 02110-1301, USA.
;;
;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;;; Commentary:
;;
;; Zotelo helps you efficiently export and synchronize local databases (bib,
;; rdf, html, json etc) and [Zotero](http://www.zotero.org) collections directly
;; from emacs.
;;
;; Zotelo can be used in conjunction with any emacs mode but is primarily
;; intended for bibtex and RefTeX users.
;;
;; zotelo-mode-map lives on  C-c z prefix.
;;
;;   *Installation*
;;
;;   (add-hook 'TeX-mode-hook 'zotelo-minor-mode)
;;
;;  See https://github.com/vspinu/zotelo for more
;;
;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;;; Code:

(require 'cl-lib)

(defgroup zotelo nil "Customization for zotelo"
  :group 'convenience)

(defcustom zotelo-default-translator 'BibTeX
  "The name of the default zotero-translator to use (a symbol).
Must correspond to one of the labels of the translators in
Zotero. You can set this variable interactively with
`zotelo-set-translator'."
  :type 'symbol
  :group 'zotelo)

(defcustom zotelo-translator-charsets
  '((BibTeX . "Western")
    (Default . "Unicode"))
  "Default charsets for exporting bibliography.
Alist where the car of each element is a name of a
translator (symbol) and the cdr is the name of the character
set (string) that should be used by default for this translator
to export the bibliography. The special `Default' translator sets
the character set for all other translators not listed here."
  :group 'zotelo
  :type '(repeat
          (cons :tag ""
                (symbol :tag "Translator")
                (string :tag "   Charset"))))

(defcustom zotelo-charset nil
  "Charset used for exporting bibliography.
If nil (default), the charset will be determined by the current
translator and `zotelo-translator-charsets'. You can set the
buffer local value of this variable interactively with
`zotelo-set-charset'."
  :group 'zotelo
  :type '(string :tag "Charset")
  :safe 'string-or-null-p)

(defcustom zotelo-use-journal-abbreviation nil
  "If non-nil, use journal abbreviations for exporting bibliography.
See https://www.zotero.org/support/kb/journal_abbreviations"
  :group 'zotelo
  :type '(boolean :tag "Use journal abbreviation")
  :safe 'booleanp)

(defcustom zotelo-bibliography-commands '("bibliography" "nobibliography" "zotelo" "addbibresource")
  "List of commands which specify databases to use.
For example \\bibliography{file1,file2} or \\zotelo{file1,file2}
both specify that file1 is a primary database and file2 is the
secondary one."
  :group 'zotelo
  :type 'list)

(defvar zotelo--check-timer nil
  "Global timer executed at `zotelo-check-interval' seconds. ")

(defvar zotelo-check-interval 5
  "Seconds between checks for zotero database changes.
Note that zotelo uses idle timer. Yeach time emacs is idle for
this number of seconds zotelo checks for an update.")

(defvar zotelo-auto-update-all nil
  "If t zotelo checks for the change in zotero database every
`zotelo-check-interval' seconds and auto updates all buffers with
active `zotelo-minor-mode'. If nil the only updated files are
those with non-nil file local variable `zotelo-auto-update'. See
`zotelo-mark-for-auto-update'. ")

(defvar zotelo--auto-update-is-on nil
  "If t zotelo auto updates the collection on changes in zotero database.
  You can toggle it with 'C-c z T'")

(defvar zotelo--ignore-files (list "_region_.tex"))

(defvar zotelo--verbose nil)

(defun zotelo-verbose ()
  "Toggle zotelo debug messages (all printed in *message* buffer)"
  (interactive)
  (message "zotelo verbose '%s'" (setq zotelo--verbose (not zotelo--verbose))))

(defun zotelo--message (str)
  (when zotelo--verbose
    (with-current-buffer "*Messages*"
      (let ((inhibit-read-only t))
	(goto-char (point-max))
	(insert (format "\n zotelo message [%s]\n %s\n" (current-time-string) str))))))



;;; JAVASCRIPT

(defconst zotelo--get-zotero-database-js
  "var zotelo_zotero = Components.classes['@zotero.org/Zotero;1'].getService(Components.interfaces.nsISupports).wrappedJSObject;
zotelo_zotero.getZoteroDatabase().path;")

(defconst zotelo--get-zotero-storage-js
  "var zotelo_zotero = Components.classes['@zotero.org/Zotero;1'].getService(Components.interfaces.nsISupports).wrappedJSObject;
zotelo_zotero.getStorageDirectory().path;")

(defconst zotelo--render-collection-js
  "
var zotelo_render_collection = function() {
var R=%s;
var Zotero = Components.classes['@zotero.org/Zotero;1'].getService(Components.interfaces.nsISupports).wrappedJSObject;
var print_names = function(collections, prefix){
    for (c in collections) {
        var fullname = prefix + '/' + collections[c].name;
        R.print(collections[c].id + ' ' + fullname);
        if (collections[c].hasChildCollections) {
            var subcol = Zotero.getCollections(collections[c].id);
            print_names(subcol, fullname); 
        }}};
print_names(Zotero.getCollections(), '');
var groups = Zotero.Groups.getAll();        
for (g in groups){
    print_names(groups[g].getCollections(), '/*groups*/'+groups[g].name);
}};
")

(defconst zotelo--render-translators-js
  "
var zotelo_render_translators = function() {
var R=%s;
var Zotero = Components.classes['@zotero.org/Zotero;1'].getService(Components.interfaces.nsISupports).wrappedJSObject;
var translator = new Zotero.Translate.Export();
for each (var w in translator.getTranslators()) {
    R.print(\"'\" + w.label + \"' \" +
            w.translatorID + \" '\" +
            w.target + \"'\");
}};
")

(defconst zotelo--render-charsets-js
  "
var R = %s;
Components.utils.import(\"resource://gre/modules/CharsetMenu.jsm\");
zoteloAllCharsets = CharsetMenu.getData().pinnedCharsets.concat(CharsetMenu.getData().otherCharsets);
for each (var cs in zoteloAllCharsets) {
    R.print(\"'\" + cs.label + \"' '\" + cs.value + \"'\");
};
")

;;;; moz-repl splits long commands. Need to send it partially, but then errors
;;;; in first parts are not visible ... :(
;;;; todo: insert the check dirrectly in moz-command ??? 
(defconst zotelo--export-collection-js
  "
var zotelo_filename=('%s');
var zotelo_id = %s;
var zotelo_translator_id = '%s';
var charset = '%s';
var jabrev = %s;
var zotelo_prefs = Components.classes['@mozilla.org/preferences-service;1'].getService(Components.interfaces.nsIPrefService).getBranch('extensions.zotero.');
var zotelo_file = Components.classes['@mozilla.org/file/local;1'].createInstance(Components.interfaces.nsILocalFile);
var zotelo_recColl = zotelo_prefs.getBoolPref('recursiveCollections');
zotelo_file.initWithPath(zotelo_filename);
//split
var zotelo_zotero = Components.classes['@zotero.org/Zotero;1'].getService(Components.interfaces.nsISupports).wrappedJSObject;
var zotelo_collection = true;
var zotelo_translator = new zotelo_zotero.Translate.Export();
if (zotelo_id != 0){ //not all collections
    zotelo_collection = zotelo_zotero.Collections.get(zotelo_id);
    zotelo_translator.setCollection(zotelo_collection);
} else {
    zotelo_translator.setLibraryID(null);
}
//split
if(zotelo_collection){
    zotelo_translator.setLocation(zotelo_file);
    zotelo_translator.setTranslator(zotelo_translator_id);
    zotelo_prefs.setBoolPref('recursiveCollections', true);
    zotelo_translator.setDisplayOptions({'exportCharset': charset, 'useJournalAbbreviation': jabrev});
    zotelo_translator.translate();
    zotelo_prefs.setBoolPref('recursiveCollections', zotelo_recColl);
    zotelo_out=':MozOK:';
}else{
    zotelo_out='Collection with the id ' + zotelo_id + ' does not exist.';
};
//split
zotelo_out;
"
  "Command sent to zotero for export request.")

(defconst zotelo--dateModified-js
  "var zotelo_zotero = Components.classes['@zotero.org/Zotero;1'].getService(Components.interfaces.nsISupports).wrappedJSObject;
var zotelo_id = %s;
var zotelo_collection = zotelo_zotero.Collections.get(zotelo_id);
if(zotelo_collection){
   ':MozOK:' + zotelo_collection.dateModified;
}else{
   'Collection with the id ' + zotelo_id + ' does not exist.';
}"
  "Command to get last modification date of the collection.")



;;; ZOTELO MINOR MODE

(defvar zotelo-minor-mode-map
  (let ((map (make-sparse-keymap)))
    (define-key map "\C-czu" 'zotelo-update-database)
    (define-key map "\C-cze" 'zotelo-export-secondary)
    (define-key map "\C-czs" 'zotelo-set-collection)
    (define-key map "\C-czc" 'zotelo-set-collection)
    (define-key map "\C-czC" 'zotelo-set-charset)
    (define-key map "\C-czm" 'zotelo-mark-for-auto-update)
    (define-key map "\C-czr" 'zotelo-reset)
    (define-key map "\C-czt" 'zotelo-set-translator)
    (define-key map "\C-czT" 'zotelo-toggle-auto-update)
    map))

;;;###autoload
(define-minor-mode zotelo-minor-mode
  "zotelo minor mode for interaction with Firefox.
With no argument, this command toggles the mode. Non-null prefix
argument turns on the mode. Null prefix argument turns off the
mode.

When this minor mode is enabled, `zotelo-set-collection' prompts
for zotero collection and stores it as file local variable . To
manually update the BibTeX data base call
`zotelo-update-database'. The \"file_name.bib\" file will be
created with the exported zotero items. To specify the file_name
just insert insert \\bibliography{file_name} anywhere in the
buffer.

This mode is designed mainly for latex modes and works in
conjunction with RefTex, but it can be used in any other mode
such as org-mode.

\\{zotelo-minor-mode-map}"
  nil
  (zotelo--auto-update-is-on " ZX" " zx")
  :keymap zotelo-minor-mode-map
  :group 'zotelo
  (if zotelo-minor-mode
      (progn
        (unless (timerp zotelo--check-timer)
          (setq zotelo--check-timer
                (run-with-idle-timer 5 zotelo-check-interval 'zotelo--check-and-update-all))))
    (unless
        (cl-loop for b in (buffer-list)
                 for is-zotelo-mode = (buffer-local-value 'zotelo-minor-mode b)
                 until is-zotelo-mode
                 finally return is-zotelo-mode)
      ;; if no more active zotelo mode, cancel the timer and kill the process
      (when (timerp zotelo--check-timer)
        (cancel-timer zotelo--check-timer)
        (setq zotelo--check-timer nil)
        (delete-process (zotelo--moz-process))
        (kill-buffer zotelo--moz-buffer)))))

(defun zotelo--check-and-update-all ()
  "Function run with `zotelo--check-timer'."
  (when zotelo--auto-update-is-on
    (let ( out id any-z-buffer-p z-buffer-p)
      (zotelo--message  "zotelo checking for updates.")
      (dolist (b  (buffer-list)) ;iterate through zotelo buffers
        (setq z-buffer-p (buffer-local-value 'zotelo-minor-mode b))
        (when z-buffer-p
          (setq any-z-buffer-p t))
        (when (and
               ;; zotelo buffer?
               z-buffer-p
               ;; exclusion reg-exp  matched?,
               (not (delq nil (mapcar (lambda (reg)
                                        (string-match reg (buffer-name b)))
                                      zotelo--ignore-files)))
               ;; collection is set?,
               (assoc 'zotero-collection (buffer-local-value 'file-local-variables-alist b))
               ;; auto-update-all?, auto-update?
               (let ((auto-update
                      (assoc 'zotelo-auto-update (buffer-local-value 'file-local-variables-alist b))))
                 (if (and zotelo-auto-update-all (null auto-update))
                     (setq auto-update '(t . t)))
                 (cdr auto-update)))
          (with-current-buffer b
            (ignore-errors
              (setq id (zotelo-update-database t))))
          (when id
            (setq out
                  (append (list (buffer-name b)) out)))))
      (if (> (length out) 0)
          (message "Bibliography updated in %s buffers: %s." (length out) out))
      (when (and (not any-z-buffer-p)
                 (timerp zotelo--check-timer))
        ;; stop timer if no more zotelo buffers
        (cancel-timer zotelo--check-timer)
        (setq zotelo--check-timer nil)
        (delete-process (zotelo--moz-process))
        (kill-buffer zotelo--moz-buffer)))))

;;;###autoload
(defun zotelo-export-secondary ()
  "Export zotero collection into  secondary BibTeX database.
Before export, ask for a secondary database and zotero collection
to be exported into the database. Secondary databases are those
in \\bibliography{file1, file2, ...}, except the first one.

Throw error if there is only one (primary) file listed in
\\bibliography{...}. Throw error if zotero collection is not
found by MozRepl"
  (interactive)
  (let* ((files (zotelo--locate-bibliography-files))
         (bibfile (cond
                   ((< (length files) 2)
                    (error "No secondary databases (\\bibliography{...} lists contain less than 2 files)."))
                   ((= (length files) 2)
                    (cadr files))
                   (t (completing-read "File to update: " (cdr files)))))
         (collection (zotelo-set-collection
                      (format "Export into '%s': " (file-name-nondirectory bibfile))
                      'no-update 'no-set)))
    (zotelo-update-database nil bibfile (get-text-property 0 'zotero-id collection))))

(defun zotelo--get-translators ()
  "Get translators from running Zotero instance.
In case that no default extension is provided for the translator
by Zotero, use `txt'"
  (let ((buf (get-buffer-create "*moz-command-output*"))
	translators)
    ;; set up the translator list
    (moz-command (format zotelo--render-translators-js
			 (process-get (zotelo--moz-process) 'moz-prompt)))
    (moz-command "zotelo_render_translators()" buf)
    (with-current-buffer buf
      (goto-char (point-min))
      (zotelo--message (format "Translators:\n %s"
			       (buffer-substring-no-properties (point-min) (min 500 (point-max)))))
      (while (re-search-forward "^'\\(.+\\)' \\(.*\\) '\\(.*\\)'$" nil t)
	(let* ((label (intern (match-string-no-properties 1)))
               (id (match-string-no-properties 2))
               (ext-from-zotero (match-string-no-properties 3))
               (extension (if (string= ext-from-zotero "")
                              "txt"
                            ext-from-zotero)))
          (setq translators (cons (cons label (cons id (cons extension nil))) translators)))))
    (if (null translators)
        (error "No translators found or error occured see *moz-command-output* buffer for clues.")
      translators)))

(defun zotelo-set-translator ()
  "Ask to choose from available translators and set `zotelo-default-translator'."
  (interactive)
  (let ((tnames (mapcar (lambda (el) (symbol-name (car el)))
                        (zotelo--get-translators))))
    (setq zotelo-default-translator
          (intern (completing-read "Choose translator: " tnames nil nil nil nil 
                                   (symbol-name zotelo-default-translator))))
    (message "Translator set to %s" zotelo-default-translator)))

(defvar zotelo--cached-charsets nil)
(defun zotelo--get-charsets ()
  "Get charsets (character encoding) for export from running Zotero instance."
  (or zotelo--cached-charsets
      (let ((buf (get-buffer-create "*moz-command-output*"))
	    charsets)
	(moz-command (format zotelo--render-charsets-js
			     (process-get (zotelo--moz-process) 'moz-prompt))
		     buf)
	(with-current-buffer buf
	  (goto-char (point-min))
	  (zotelo--message (format "Charsets:\n %s"
				   (buffer-substring-no-properties (point-min) (min 500 (point-max)))))
	  (while (re-search-forward "^'\\(.+\\)' '\\(.*\\)'$" nil t)
	    (let ((label (match-string-no-properties 1))
		  (value (match-string-no-properties 2)))
	      (setq charsets (cons (list label value) charsets)))))
	(if (null charsets)
	    (error "No charsets found or error occured see *moz-command-output* buffer for clues.")
	  (setq zotelo--cached-charsets (nreverse charsets))))))

;;;###autoload
(defun zotelo-set-charset ()
  "Ask to choose from available character sets for exporting the bibliography.
This function sets the variable `zotelo-charset'."
  (interactive)
  (let ((charsets (mapcar (lambda (el) (car el))
                          (zotelo--get-charsets))))
    (setq-local zotelo-charset
                (completing-read "Choose Charset: " charsets))
    (message "Charset was set to %s" zotelo-charset)))

;;;###autoload
(defun zotelo-update-database (&optional check-zotero-change bibfile id)
  "Update the primary BibTeX database associated with the current buffer.
Primary database is the first file in \\bibliography{file1, file2,
...}, list. If you want to export into a different file use
`zotelo-update-database-secondary'.

When BIBFILE is supplied, use it instead of the file in
\\bibliography{...}. If ID is supplied, use it instead of the id
from file local variables. Through an error if zotero collection
has not been found by MozRepl"
  (interactive)
  (let ((bibfile (or bibfile
		     (car (zotelo--locate-bibliography-files))))
        (proc  (zotelo--moz-process))
        (id (or id (zotelo--get-local-collection-id)))
        (file-name (file-name-nondirectory (file-name-sans-extension (buffer-file-name))))
        (translator (assoc zotelo-default-translator (zotelo--get-translators)))
        all-colls-p bib-last-change zotero-last-change)
    (unless translator
      (error "Cannot find %s in Zotero's translators" zotelo-default-translator))

    (unless bibfile
      ;; (setq file-name (concat file-name "."))
      (setq bibfile file-name)
      (message "Using '%s' filename for %s export." file-name zotelo-default-translator))

    (let ((extension (nth 2 translator)))
      (if (string-match (concat "\\." extension "$") bibfile)
          (setq bibfile (expand-file-name bibfile))
        (setq bibfile (concat (expand-file-name bibfile) "." extension))))
    (setq bib-last-change (nth 5 (file-attributes bibfile))) ;; nil if bibfile does not exist
    (setq bibfile (replace-regexp-in-string "\\\\" "\\\\"
					    (convert-standard-filename bibfile) nil 'literal))
    (unless (file-exists-p (file-name-directory bibfile))
      (error "Directory '%s' does not exist; create it first." (file-name-directory bibfile)))
    ;; Add cygwin support.
    ;; "C:\\foo\\test.bib" workes with javascript.
    ;; while "/foo/test.bib" "C:\cygwin\foo\test.bib" and "C:/cygwin/foo/test.bib" don't
    (when (eq system-type 'cygwin)
      (setq bibfile
            (replace-regexp-in-string
             "/" "\\\\\\\\" (substring
                             (shell-command-to-string (concat "cygpath -m '" bibfile "'")) 0 -1))))
    (when (and (called-interactively-p 'any) (null id))
      (zotelo-set-collection "Zotero collection is not set. Choose one: " 'no-update)
      (setq id (zotelo--get-local-collection-id)))
    
    (when check-zotero-change
      (set-time-zone-rule t)
      (with-current-buffer (moz-command (format zotelo--dateModified-js id))
        (goto-char (point-min))
        (when (re-search-forward ":MozOK:" nil t) ;; ingore the error it is  cought latter
          (setq zotero-last-change (date-to-time
                                    (buffer-substring-no-properties (point) (point-max)))))))
    (when (and id
               (or (null check-zotero-change)
                   (null bib-last-change)
                   (time-less-p bib-last-change zotero-last-change)))

      (let* ((charset (or zotelo-charset
			  (cdr (assoc (car translator) zotelo-translator-charsets))
			  (cdr (assoc 'Default zotelo-translator-charsets))))
	     (charset (cadr (assoc charset (zotelo--get-charsets))))
	     (journal-abbr (if zotelo-use-journal-abbreviation
			       "true"
			     "false"))
	     (cstr (format zotelo--export-collection-js
			   bibfile id (cadr translator) charset journal-abbr))
	     (msg  (format "Executing command: \n\n (moz-command (format zotelo--export-collection-js '%s' %s %s %s %s))\n\n translated as:\n %s\n"
			   bibfile id (cadr translator) charset journal-abbr cstr))
	     (com (split-string cstr "//split" t))
	     (com1))
	(zotelo--message msg)
	(message "Updating '%s' ..." (file-name-nondirectory bibfile))
	(while (setq com1 (pop com))
	  (when com ;; append to all except the last one
	    (setq com1 (concat com1 "\":MozOK:\"")))
	  (with-current-buffer (moz-command com1)
	    (goto-char (point-min))
	    (unless (re-search-forward ":MozOK:" nil t)
	      (error "MozError: \n%s" (buffer-substring-no-properties (point) (point-max)))))))
      
      (let ((buf (get-file-buffer bibfile)))
	(when buf (with-current-buffer buf (revert-buffer 'no-auto 'no-conf))))
      (message "'%s' updated successfully (%s)" (file-name-nondirectory bibfile) zotelo-default-translator)
      id)))

(defun zotelo--locate-bibliography-files ()
  ;; Scan buffer for bibliography macro and return as a list.
  ;; Modeled after the corresponding reftex function
  (save-excursion
    (goto-char (point-max))
    (if (re-search-backward
         (concat
	  ;; "\\(\\`\\|[\n\r]\\)[^%]*\\\\\\("
          "\\(^\\)[^%\n\r]*\\\\\\("
          (mapconcat 'identity zotelo-bibliography-commands "\\|")
          "\\){[ \t]*\\([^}]+\\)") nil t)
        (split-string   (when (match-beginning 3)
                          (buffer-substring-no-properties (match-beginning 3) (match-end 3)))
                        "[ \t\n\r]*,[ \t\n\r]*"))))

;;;###autoload
(defun zotelo-set-collection (&optional prompt no-update no-file-local)
  "Ask for a zotero collection.
Ido interface is used by default. If you don't like it set
`zotelo-use-ido' to nil.  In `ido-mode' use \"C-s\" and \"C-r\"
for navigation. See ido-mode emacs wiki for many more details.

If no-update is t, don't update after setting the collecton. If
no-file-local is non-nill don't set file-local variable. Return
the properized collection name."
  (interactive)
  (let ((buf (get-buffer-create "*moz-command-output*"))
        colls)
    ;; set up the collection list
    (moz-command (format zotelo--render-collection-js
                         (process-get (zotelo--moz-process) 'moz-prompt)))
    (moz-command "zotelo_render_collection()" buf)
    (with-current-buffer buf
      (goto-char (point-min))
      (zotelo--message (format "Collections:\n %s" 
                               (buffer-substring-no-properties (point-min) (min 500 (point-max)))))
      (let (name id)
        (while (re-search-forward "^\\([0-9]+\\) /\\(.*\\)$" nil t)
          (setq id (match-string-no-properties 1)
                name (match-string-no-properties 2))
          (setq colls (cons (cons name id) colls)))))

    (if (null colls)
        (error "No collections found or error occured see *moz-command-output* buffer for clues.")
      ;; (setq colls (mapcar 'remove-text-properties colls))
      (let* ((colls (cons (cons "*ALL*" "0") (nreverse colls)))
             (name (completing-read (or prompt "Collection: ") (mapcar #'car colls)))
             (id (or (cdr (assoc name colls))
                     (error "Null id for collection '%s'. Please see *moz-command-output* for clues." name))))
        (unless no-file-local
          (save-excursion
            (add-file-local-variable 'zotero-collection (propertize id 'name name))
            (hack-local-variables))
          (unless no-update
            (zotelo-update-database)))
       name))))

(defun zotelo-mark-for-auto-update (&optional unmark)
  "Mark current file for auto-update.
If the file is marked for auto-update zotelo runs
`zotelo-update-database' on it whenever the zotero data-base is
updated.

File is marked by adding file local variable
'zotelo-auto-update'. To un-mark the file call this function with
an argument or just delete or set to nil the local variable at
the end of the file."
  (interactive "P")
  (save-excursion
    (if unmark
        (progn
          (delete-file-local-variable 'zotelo-auto-update)
          (setq file-local-variables-alist
                (assq-delete-all 'zotelo-auto-update file-local-variables-alist)))
      (add-file-local-variable 'zotelo-auto-update t)
      (hack-local-variables))))

;;;###autoload
(defun zotelo-reset ()
  "Reset zotelo."
  (interactive)
  (delete-process (zotelo--moz-process))
  (kill-buffer zotelo--moz-buffer)
  (message "Killed moz process"))

(defun zotelo-toggle-auto-update ()
  "Togles auto-updating in all buffers.
Note that once toggled in your firefox and MozRepl must be
started, otherwise you will start getting error screens. "
  (interactive)
  (setq zotelo--auto-update-is-on (not zotelo--auto-update-is-on)))

(defun zotelo--get-local-collection-id ()
  (or (and (boundp 'zotero-collection) zotero-collection)
      (cdr (assoc 'zotero-collection file-local-variables-alist))))


;;; MOZ UTILITIES

(defvar zotelo--moz-host "localhost")
(defvar zotelo--moz-port 4242)
(defvar zotelo--moz-buffer nil)
(defvar zotelo--startup-error-count 0)
(defvar zotelo--max-errors 10)

(defun zotelo--moz-process ()
  "Return inferior MozRepl process.  Start it if necessary."
  (or (if (buffer-live-p zotelo--moz-buffer)
          (get-buffer-process zotelo--moz-buffer))
      (progn
        (zotelo--moz-start-process)
        (zotelo--moz-process))))

(defun zotelo--moz-start-process ()
  "Start mozrepl process and connect to Firefox.
Note that you have to start the MozRepl server from Firefox."
  (interactive)
  (setq zotelo--moz-buffer (get-buffer-create "*zoteloMozRepl*"))
  (condition-case err
      (let ((proc (make-network-process :name "zoteloMozRepl" :buffer zotelo--moz-buffer
					:host zotelo--moz-host :service zotelo--moz-port
					:filter 'moz-ordinary-insertion-filter)))
        (sleep-for 0 100)
	(set-process-query-on-exit-flag proc nil)
        (with-current-buffer zotelo--moz-buffer
          (set-marker (process-mark proc) (point-max)))
        (setq zotelo--startup-error-count 0))
    (file-error
     (let ((buf (get-buffer-create "*MozRepl Error*")))
       (setq zotelo--startup-error-count (1+ zotelo--startup-error-count))
       (with-current-buffer buf
         (erase-buffer)
         (insert "Can't start MozRepl, the error message was:\n\n     "
                 (error-message-string err)
                 "\n"
                 "\nA possible reason is that you have not installed"
                 "\nthe MozRepl add-on to Firefox or that you have not"
                 "\nstarted it.  You start it from the menus in Firefox:"
                 "\n\n     Tools / MozRepl / Start"
                 "\n"
                 "\nSee ")
         (insert-text-button
          "MozRepl home page"
          'action (lambda (button)
                    (browse-url
                     "http://hyperstruct.net/projects/mozrepl")
                    )
          'face 'button)
         (insert
          " for more information."
          "\n"
          "\nMozRepl is also available directly from Firefox add-on"
          "\npages, but is updated less frequently there.\n\n"
          (format "zotelo Error Count: %s\n\n%s"
                  zotelo--startup-error-count
                  (if (not (and (>= zotelo--startup-error-count 10)
                                zotelo--auto-update-is-on))
                      "If zotelo auto-update is on, press \"C-c z t\" to turn it off."
                    (setq zotelo--auto-update-is-on nil)
                    (setq zotelo--startup-error-count 0)
                    "Too many errors. zotelo auto-update was turned off!\nUse [C-c z t] to switch it on.")))
         )
       (kill-buffer "*zoteloMozRepl*")
       (display-buffer buf t)
       (error "zotelo cannot start MozRepl")))))

(defun moz-ordinary-insertion-filter (proc string)
  "simple filter for command execution"
  (with-current-buffer (process-buffer proc)
    (let ((ready (string-match "\\(\\w+\\)> \\'" string))
	  moving)
      (when ready
	(process-put proc 'moz-prompt (match-string-no-properties 1 string)))
      (process-put proc 'busy (not ready))
      (setq moving (= (point) (process-mark proc)))
      (save-excursion
        ;; Insert the text, moving the process-marker.
        (goto-char (process-mark proc))
        (insert string)
        (set-marker (process-mark proc) (point)))
      (if moving (goto-char (process-mark proc))))))

(defvar moz-verbose nil
  "If t print informative statements.")

;;;###autoload
(defun moz-command (com &optional buf)
  "Send the moz-repl  process command COM and delete the output
from the MozRepl process buffer.  If an optional second argument BUF
exists, it must be a string or an existing buffer object. The
output is inserted in that buffer. BUF is erased before use.

New line is automatically appended.
"
  (if buf
      (setq buf (get-buffer-create buf))
    (setq buf (get-buffer-create "*moz-command-output*")))
  (let ((proc (zotelo--moz-process))
        oldpb oldpf oldpm)
    (save-excursion
      ;; (set-buffer sbuffer)
      (when (process-get proc 'busy)
        (process-send-string proc ";\n") ;; clean up unfinished
        (sleep-for 0 100)
        (when (process-get proc 'busy)
          (error
           "MozRepl process is not ready. Try latter or reset.")))
      (setq oldpf (process-filter proc))
      (setq oldpb (process-buffer proc))
      (setq oldpm (marker-position (process-mark proc)))
      ;; need the buffer-local values in result buffer "buf":
      (unwind-protect
	  (progn
	    (set-process-buffer proc buf)
	    (set-process-filter proc 'moz-ordinary-insertion-filter)
	    ;; Output is now going to BUF:
            (with-current-buffer buf
	      (erase-buffer)
	      (set-marker (process-mark proc) (point-min))
	      (process-put proc 'busy t)
	      (process-send-string proc (concat com "\n"))
	      (moz-wait-for-process proc)
	      ;;(delete-region (point-at-bol) (point-max))
	      )
	    (zotelo--message "Moz-command finished"))
	;; Restore old values for process filter
	(set-process-buffer proc oldpb)
	(set-process-filter proc oldpf)
	;; need oldpb here!!! otherwise it is not set for some reason
	(set-marker (process-mark proc) oldpm oldpb))))
  buf)


(defun moz-wait-for-process (proc &optional wait)
  "Wait for 'busy property of the process to become nil.
If SEC-PROMPT is non-nil return if secondary prompt is detected
regardless of whether primary prompt was detected or not.  If
WAIT is non-nil wait for WAIT seconds for process output before
the prompt check, default 0.01s. "
  ;; (unless (eq (process-status proc) 'run)
  ;;   (error "MozRepl process has died unexpectedly."))
  (setq wait (or wait 0.01))
  (save-excursion
    (while (or (accept-process-output proc wait)
	       (process-get proc 'busy)))))


;; (defun inferior-moz-track-proc-busy (comint-output)
;;   "track if process returned the '>' prompt and mark it as busy if not."
;;   (if (string-match "\\(\\w+\\)> \\'" comint-output)
;;       (process-put (get-buffer-process (current-buffer)) 'busy nil)
;;     (process-put (get-buffer-process (current-buffer)) 'busy t)))

;; (defun zotelo-insert-busy-hook ()
;;   "Add `inferior-moz-track-proc-busy' to comint-outbut-filter hook "
;;   (add-hook 'comint-output-filter-functions 'inferior-moz-track-proc-busy nil t)
;;   )

;; (add-hook 'inferior-moz-hook 'zotelo-insert-busy-hook)

(provide 'zotelo)
;;; zotelo.el ends here.