ein-notebook.el

;;; ein-notebook.el --- Notebook module   -*- lexical-binding: t -*-

;; Copyright (C) 2012- Takafumi Arakaki

;; Author: Takafumi Arakaki <aka.tkf at gmail.com>

;; This file is NOT part of GNU Emacs.

;; ein-notebook.el 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 of the License, or
;; (at your option) any later version.

;; ein-notebook.el 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 ein-notebook.el.  If not, see <http://www.gnu.org/licenses/>.

;;; Commentary:

;; * Coding rule about current buffer.
;; A lot of notebook and cell functions touches to current buffer and
;; it is not ideal to wrap all these functions by `with-current-buffer'.
;; Therefore, when the function takes `notebook' to the first argument
;; ("method" function), it is always assumed that the current buffer
;; is the notebook buffer.  **However**, functions called as callback
;; (via `url-retrieve', for example) must protect themselves by
;; calling from unknown buffer.

;;; Code:


(eval-when-compile (require 'auto-complete))

(require 'ewoc)
(require 'mumamo nil t)
(require 'company nil t)
(require 'px nil t)
(require 'eldoc nil t)
(require 'ein-core)
(require 'ein-classes)
(require 'ein-console)
(require 'ein-log)
(require 'ein-node)
(require 'ein-contents-api)
(require 'ein-kernel)
(require 'ein-kernelinfo)
(require 'ein-cell)
(require 'ein-cell-edit)
(require 'ein-cell-output)
(require 'ein-worksheet)
(require 'ein-iexec)
(require 'ein-scratchsheet)
(require 'ein-notification)
(require 'ein-completer)
(require 'ein-pager)
(require 'ein-pseudo-console)
(require 'ein-events)
(require 'ein-notification)
(require 'ein-kill-ring)
(require 'ein-query)
(require 'ein-pytools)
(require 'ein-traceback)
(require 'ein-inspector)
(require 'ein-shared-output)
(require 'ein-notebooklist)
(require 'ein-multilang)
(require 'ob-ein)
(require 'poly-ein)

;;; Configuration

(make-obsolete-variable 'ein:notebook-discard-output-on-save nil "0.2.0")

(declare-function ein:smartrep-config "ein-smartrep")

(defcustom ein:use-smartrep nil
  "Set to `t' to use preset smartrep configuration.

.. warning:: When used with MuMaMo (see `ein:notebook-modes'),
   keyboard macro which manipulates cell (add, remove, move,
   etc.) may start infinite loop (you need to stop it with
   ``C-g``).  Please be careful using this option if you are a
   heavy keyboard macro user.  Using keyboard macro for other
   commands is fine.

.. (Comment) I guess this infinite loop happens because the three
   modules (kmacro.el, mumamo.el and smartrep.el) touches to
   `unread-command-events' in somehow inconsistent ways."
  :type 'boolean
  :group 'ein)

(defvar *ein:notebook--pending-query* (make-hash-table :test 'equal)
  "A map: (URL-OR-PORT . PATH) => t/nil")

(defcustom ein:notebook-autosave-frequency 300
  "Sets the frequency (in seconds) at which the notebook is
automatically saved, per IPEP15. Set to 0 to disable this feature.

Autosaves are automatically enabled when a notebook is opened,
but can be controlled manually via `ein:notebook-enable-autosave'
and `ein:notebook-disable-autosave'.

If you wish to change the autosave frequency for the current
notebook call `ein:notebook-update-autosave-freqency'.

"
  :type 'number
  :group 'ein)

(defcustom ein:notebook-create-checkpoint-on-save t
  "If non-nil a checkpoint will be created every time the
notebook is saved. Otherwise checkpoints must be created manually
via `ein:notebook-create-checkpoint'."
  :type 'boolean
  :group 'ein)

(defcustom ein:notebook-discard-output-on-save 'no
  "Configure if the output part of the cell should be saved or not.

.. warning:: This configuration is obsolete now.
   Use nbconvert (https://github.com/ipython/nbconvert) to
   strip output.

`no' : symbol
    Save output. This is the default.
`yes' : symbol
    Always discard output.
a function
    This function takes two arguments, notebook and cell.  Return
    `t' to discard output and return `nil' to save.  For example,
    if you don't want to save image output but other kind of
    output, use `ein:notebook-cell-has-image-output-p'.
"
  :type '(choice (const :tag "No" 'no)
                 (const :tag "Yes" 'yes)
                 )
  :group 'ein)

(defun ein:notebook-cell-has-image-output-p (_ignore cell)
  (ein:cell-has-image-ouput-p cell))

(defun ein:notebook-discard-output-p (notebook cell)
  "Return non-`nil' if the output must be discarded, otherwise save."
  (cl-case ein:notebook-discard-output-on-save
    (no nil)
    (yes t)
    (t (funcall ein:notebook-discard-output-on-save notebook cell))))

;; As opening/saving notebook treats possibly huge data, define these
;; timeouts separately:

(defcustom ein:notebook-querty-timeout-save (* 60 1000) ; 1 min
  "Query timeout for saving notebook.
Similar to `ein:notebook-querty-timeout-open', but for saving
notebook.  For global setting and more information, see
`ein:query-timeout'."
  :type '(choice (integer :tag "Timeout [ms]" 5000)
                 (const :tag "Use global setting" nil))
  :group 'ein)

(defcustom ein:helm-kernel-history-search-key nil
  "Bind `helm-ein-kernel-history' to this key in notebook mode.

Example::

    (setq ein:helm-kernel-history-search-key \"\\M-r\")

This key will be installed in the `ein:notebook-mode-map'."
  :type 'boolean
  :group 'ein)

(defcustom ein:anything-kernel-history-search-key nil
  "Bind `anything-ein-kernel-history' to this key in notebook mode.

Example::

    (setq ein:anything-kernel-history-search-key \"\\M-r\")

This key will be installed in the `ein:notebook-mode-map'."
  :type 'boolean
  :group 'ein)

(defcustom ein:notebook-set-buffer-file-name nil
  "[DEPRECATED] Set `buffer-file-name' of notebook buffer. Currently does nothing."
  :type 'boolean
  :group 'ein)

(defvar ein:notebook-after-rename-hook nil
  "Hooks to run after notebook is renamed successfully.
Current buffer for these functions is set to the notebook buffer.")


;;; Class and variable

(defvar ein:base-kernel-url "/api/")
(defvar ein:create-session-url "/api/sessions")
;; Currently there is no way to know this setting.  Maybe I should ask IPython
;; developers for an API to get this from notebook server.
;;
;; 10April2014 (JMM) - The most recent documentation for the RESTful interface
;; is at:
;; https://github.com/ipython/ipython/wiki/IPEP-16%3A-Notebook-multi-directory-dashboard-and-URL-mapping


(defvar ein:notebook-pager-buffer-name-template "*ein:pager %s/%s*")
(defvar ein:notebook-buffer-name-template "*ein: %s/%s*")

(ein:deflocal ein:%notebook% nil
  "Buffer local variable to store an instance of `ein:$notebook'.")

(ein:deflocal ein:%notebook-latex-p% nil
  "Is latex preview toggled")

(define-obsolete-variable-alias 'ein:notebook 'ein:%notebook% "0.1.2")

;;; Constructor

(defun ein:notebook-new (url-or-port notebook-path pre-kernelspec &rest args)
  (let ((kernelspec
         (cond ((ein:$kernelspec-p pre-kernelspec) pre-kernelspec)
               ((consp pre-kernelspec)
                (cl-loop for (_name ks) on (ein:need-kernelspecs url-or-port) by 'cddr
                  when (and (ein:$kernelspec-p ks)
                            (string= (cdr pre-kernelspec)
                                     (cl-struct-slot-value
                                      'ein:$kernelspec (car pre-kernelspec) ks)))
                  return ks))
               (t (ein:get-kernelspec url-or-port pre-kernelspec)))))
    (apply #'make-ein:$notebook
           :url-or-port url-or-port
           :kernelspec kernelspec
           :notebook-path notebook-path
           args)))

;;; Destructor

(defun ein:notebook-del (notebook)
  "Destructor for `ein:$notebook'."
  (ein:log-ignore-errors
    (ein:kernel-del (ein:$notebook-kernel notebook))))

(defun ein:notebook-close-worksheet (notebook ws)
  "Close worksheet WS in NOTEBOOK.  If WS is the last worksheet,
call notebook destructor `ein:notebook-del'."
  (cl-symbol-macrolet ((worksheets (ein:$notebook-worksheets notebook))
                       (scratchsheets (ein:$notebook-scratchsheets notebook)))
    (cond
     ((ein:worksheet-p ws) (ein:worksheet-save-cells ws t))
     (t (setq scratchsheets (delq ws scratchsheets))))
    (unless (or (seq-filter (lambda (x)
                              (and (not (eq x ws))
                                   (ein:worksheet-has-buffer-p x)))
                            worksheets)
                scratchsheets)
      (ein:notebook-del notebook))))


;;; Notebook utility functions

(defun ein:notebook-update-url-or-port (new-url-or-port notebook)
  "Change the url and port the notebook is saved to. Calling
this will propagate the change to the kernel, trying to restart
the kernel in the process. Use case for this command is when
the jupyter server dies and restarted on a different port.

If you have enabled token or password security on server running
at the new url/port, then please be aware that this new url-port
combo must match exactly these url/port you used format
`ein:notebooklist-login'."
  (interactive (list
                (ein:notebooklist-ask-url-or-port)
                (ein:notebook--get-nb-or-error)))
  (message "Updating server info and restarting kernel for notebooklist %s"
           (ein:$notebook-notebook-name notebook))
  (setf (ein:$notebook-url-or-port notebook) new-url-or-port)
  (with-current-buffer (ein:notebook-buffer notebook)
    (ein:kernel-retrieve-session (ein:$notebook-kernel notebook))
    (rename-buffer (format ein:notebook-buffer-name-template
                           (ein:$notebook-url-or-port notebook)
                           (ein:$notebook-notebook-name notebook)))))

(defun ein:notebook-buffer (notebook)
  "Return first buffer in NOTEBOOK's worksheets."
  (cl-loop for ws in (append (ein:$notebook-worksheets notebook)
                             (ein:$notebook-scratchsheets notebook))
    if (ein:worksheet-buffer ws)
    return it))

(defun ein:notebook-buffer-list (notebook)
  "Return the buffers associated with NOTEBOOK's kernel.
The buffer local variable `default-directory' of these buffers
will be updated with kernel's cwd."
  (delete nil
          (mapcar #'ein:worksheet-buffer
                  (append (ein:$notebook-worksheets notebook)
                          (ein:$notebook-scratchsheets notebook)))))

(defun ein:notebook--get-nb-or-error ()
  (or ein:%notebook% (error "Not in notebook buffer.")))

;;;###autoload
(defalias 'ein:notebook-name 'ein:$notebook-notebook-name)

(defun ein:notebook-name-getter (notebook)
  (cons #'ein:notebook-name notebook))

;;; Open notebook

(defun ein:notebook-url (notebook)
  (ein:notebook-url-from-url-and-id (ein:$notebook-url-or-port notebook)
                                    (ein:$notebook-api-version notebook)
                                    (ein:$notebook-notebook-path notebook)))

(defun ein:notebook-url-from-url-and-id (url-or-port api-version path)
  (cond ((= api-version 2)
         (ein:url url-or-port "api/notebooks" path))
        ((>= api-version 3)
         (ein:url url-or-port "api/contents" path))))

(defun ein:notebook-open--decorate-callback (notebook existing pending-clear callback no-pop)
  "In addition to CALLBACK, also clear the pending semaphore, pop-to-buffer the new notebook, save to disk the kernelspec metadata, and put last warning in minibuffer."
  (apply-partially
   (lambda (notebook* created callback* pending-clear* no-pop*)
     (funcall pending-clear*)
     (with-current-buffer (ein:notebook-buffer notebook*)
       (ein:worksheet-focus-cell))
     (unless no-pop*
       (with-current-buffer (ein:notebook-buffer notebook*)
         (if ein:polymode
             (progn
               (pm-select-buffer (pm-innermost-span))
               (pop-to-buffer (pm-span-buffer (pm-innermost-span))))
           (pop-to-buffer (ein:notebook-buffer notebook*)))))
     (when (and (not noninteractive)
                (null (plist-member (ein:$notebook-metadata notebook*) :kernelspec)))
       (ein:aif (ein:$notebook-kernelspec notebook*)
           (progn
             (setf (ein:$notebook-metadata notebook*)
                   (plist-put (ein:$notebook-metadata notebook*)
                              :kernelspec (ein:notebook--spec-insert-name
                                           (ein:$kernelspec-name it) (ein:$kernelspec-spec it))))
             (ein:notebook-save-notebook notebook*))))
     (when callback*
       (funcall callback* notebook* created))
     (ein:and-let* ((created)
                    (buffer (get-buffer "*Warnings*"))
                    (last-warning (with-current-buffer buffer
                                    (thing-at-point 'line t))))
       (message "%s" last-warning)))
   notebook (not existing) callback pending-clear no-pop))

(defun ein:notebook-open-or-create (url-or-port path &optional kernelspec callback no-pop)
  "Same as `ein:notebook-open' but create PATH if not found."
  (let ((if-not-found (lambda (_contents _status-code) )))
    (ein:notebook-open url-or-port path kernelspec callback if-not-found no-pop)))

;;;###autoload
(defun ein:notebook-jump-to-opened-notebook (notebook)
  "List all opened notebook buffers and switch to one that the user selects."
  (interactive
   (list  (completing-read "Jump to notebook:" (ein:notebook-opened-buffer-names) nil t)))
  (switch-to-buffer notebook))

;;;###autoload
(defun ein:notebook-open (url-or-port path &optional kernelspec callback errback no-pop)
  "Returns notebook at URL-OR-PORT/PATH.

Note that notebook sends for its contents and won't have them right away.

After the notebook is opened, CALLBACK is called as::

  \(funcall CALLBACK notebook created)

where `created' indicates a new notebook or an existing one.
"
  (interactive
   (ein:notebooklist-parse-nbpath (ein:notebooklist-ask-path "notebook")))
  (unless errback (setq errback #'ignore))
  (let* ((pending-key (cons url-or-port path))
         (pending-p (gethash pending-key *ein:notebook--pending-query*))
         (pending-clear (apply-partially (lambda (pending-key* &rest _args)
                                           (remhash pending-key*
                                                    *ein:notebook--pending-query*))
                                         pending-key))
         (existing (ein:notebook-get-opened-notebook url-or-port path))
         (notebook (ein:aif existing it
                     (ein:notebook-new url-or-port path kernelspec)))
         (callback0 (ein:notebook-open--decorate-callback notebook existing pending-clear
                                                          callback no-pop)))
    (if existing
        (progn
          (ein:log 'info "Notebook %s is already open"
                   (ein:$notebook-notebook-name notebook))
          (funcall callback0))
      (if (and pending-p noninteractive)
          (ein:log 'error "Notebook %s pending open!" path)
        (when (or (not pending-p)
                  (y-or-n-p (format "Notebook %s pending open!  Retry? " path)))
          (setf (gethash pending-key *ein:notebook--pending-query*) t)
          (add-function :before (var errback) pending-clear)
          (ein:content-query-contents url-or-port path
                                      (apply-partially #'ein:notebook-open--callback
                                                       notebook callback0 (not no-pop))
                                      errback))))
    notebook))

(defun ein:notebook-open--callback (notebook callback0 q-checkpoints content)
  (ein:log 'verbose "Opened notebook %s" (ein:$notebook-notebook-path notebook))
  (let ((_notebook-path (ein:$notebook-notebook-path notebook)))
    (ein:gc-prepare-operation)
    (setf (ein:$notebook-api-version notebook) (ein:$content-notebook-version content)
          (ein:$notebook-notebook-name notebook) (ein:$content-name content))
    (ein:notebook-bind-events notebook (ein:events-new))
    (ein:notebook-maybe-set-kernelspec notebook (plist-get (ein:$content-raw-content content) :metadata))
    (ein:notebook-install-kernel notebook)
    (ein:notebook-from-json notebook (ein:$content-raw-content content))
    (if (not (with-current-buffer (ein:notebook-buffer notebook)
               (ein:get-notebook)))
        (error "ein:notebook-open--callback: notebook instantiation failed")
      ;; Start websocket only after worksheet is rendered
      ;; because ein:notification-bind-events only gets called after worksheet's
      ;; buffer local notification widget is instantiated
      (ein:kernel-retrieve-session (ein:$notebook-kernel notebook) nil
                                   (apply-partially (lambda (callback0* name* _kernel)
                                                      (funcall callback0*)
                                                      (ein:log 'info "Notebook %s is ready" name*))
                                                    callback0
                                                    (ein:$notebook-notebook-name notebook)))
      (setf (ein:$notebook-kernelinfo notebook)
            (ein:kernelinfo-new (ein:$notebook-kernel notebook)
                                (cons #'ein:notebook-buffer-list notebook)
                                (symbol-name (ein:get-mode-for-kernel (ein:$notebook-kernelspec notebook)))))
      (ein:notebook-put-opened-notebook notebook)
      (ein:notebook--check-nbformat (ein:$content-raw-content content))
      (setf (ein:$notebook-q-checkpoints notebook) q-checkpoints)
      (ein:notebook-enable-autosaves notebook)
      (ein:gc-complete-operation))))

(defun ein:notebook-maybe-set-kernelspec (notebook content-metadata)
  (ein:aif (plist-get content-metadata :kernelspec)
      (let ((kernelspec (ein:get-kernelspec (ein:$notebook-url-or-port notebook)
                                            (plist-get it :name))))
        (setf (ein:$notebook-kernelspec notebook) kernelspec))))


(defun ein:notebook--different-number (n1 n2)
  (and (numberp n1) (numberp n2) (not (= n1 n2))))

(defun ein:notebook--check-nbformat (data)
  "Warn user when nbformat is changed on server side.
See https://github.com/ipython/ipython/pull/1934 for the purpose
of minor mode."
  ;; See `Notebook.prototype.load_notebook_success'
  ;; at IPython/frontend/html/notebook/static/js/notebook.js
  (cl-destructuring-bind (&key nbformat orig_nbformat
                               nbformat_minor orig_nbformat_minor
                               &allow-other-keys)
      data
    (cond
     ((ein:notebook--different-number nbformat orig_nbformat)
      (ein:display-warning
       (format "Notebook major version updated (v%d -> v%d).
  To not update version, do not save this notebook."
               orig_nbformat nbformat)))
     ((ein:notebook--different-number nbformat_minor orig_nbformat_minor)
      (ein:display-warning
       (format "This notebook is version v%s.%s, but IPython
  server you are using only fully support up to v%s.%s.
  Some features may not be available."
               orig_nbformat orig_nbformat_minor
               nbformat nbformat_minor))))))


;;; Initialization.

(defun ein:notebook-enable-autosaves (notebook)
  "Enable automatic, periodic saving for notebook."
  (interactive
   (list (or (ein:get-notebook)
             (ein:aand (ein:notebook-opened-buffer-names)
                       (with-current-buffer (ein:completing-read
                                             "Notebook: " it nil t)
                         (ein:get-notebook))))))
  (when (and (ein:$notebook-q-checkpoints notebook)
             (> ein:notebook-autosave-frequency 0))
      (setf (ein:$notebook-autosave-timer notebook)
            (run-at-time ein:notebook-autosave-frequency
                         ein:notebook-autosave-frequency
                         #'ein:notebook-maybe-save-notebook
                         notebook))
      (ein:log 'verbose "Enabling autosaves for %s with frequency %s seconds."
               (ein:$notebook-notebook-name notebook)
               ein:notebook-autosave-frequency)))

(defun ein:notebook-disable-autosaves (notebook)
  "Disable automatic, periodic saving for current notebook."
  (interactive
   (list (or (ein:get-notebook)
             (ein:aand (ein:notebook-opened-buffer-names)
                       (with-current-buffer (ein:completing-read
                                             "Notebook: " it nil t)
                         (ein:get-notebook))))))
  (if (and notebook (ein:$notebook-autosave-timer notebook))
      (progn
        (ein:log 'verbose "Disabling auto checkpoints for notebook %s" (ein:$notebook-notebook-name notebook))
        (cancel-timer (ein:$notebook-autosave-timer notebook)))))

(defun ein:notebook-update-autosave-frequency (new-frequency notebook)
  "Change the autosaves frequency for the current notebook, or
for a notebook selected by the user if not currently inside a
notebook buffer."
  (interactive
   (list (read-number "New autosaves frequency (0 to disable): ")
         (or (ein:get-notebook)
             (ein:aand (ein:notebook-opened-buffer-names)
                       (with-current-buffer (ein:completing-read
                                             "Notebook: " it nil t)
                         (ein:get-notebook))))))
  (if notebook
      (progn
        (setq ein:notebook-autosave-frequency new-frequency)
        (ein:notebook-disable-autosaves notebook)
        (ein:notebook-enable-autosaves notebook))
    (message "Open notebook first")))

(defun ein:notebook-bind-events (notebook events)
  "Bind events related to PAGER to the event handler EVENTS."
  (setf (ein:$notebook-events notebook) events)
  (ein:worksheet-class-bind-events events)
  ;; Bind events for sub components:
  (setf (ein:$notebook-pager notebook)
        (ein:pager-new
         (format ein:notebook-pager-buffer-name-template
                 (ein:$notebook-url-or-port notebook)
                 (ein:$notebook-notebook-name notebook))
         (ein:$notebook-events notebook))))

(defalias 'ein:notebook-reconnect-kernel 'ein:notebook-reconnect-session-command "The distinction between kernel and session is a bit mysterious, all the action is now occurring in `ein:notebook-reconnect-session-command' these days, for which this function is now an alias.")

(define-obsolete-function-alias
  'ein:notebook-show-in-shared-output
  'ein:shared-output-show-code-cell-at-point "0.1.2")

(eval-when-compile (defvar outline-regexp))
(defsubst ein:notebook-toggle-latex-fragment ()
  (interactive)
  (cond (ein:polymode (ein:display-warning "ein:notebook-toggle-latex-fragment: delegate to markdown-mode"))
        ((featurep 'px)
         (let ((outline-regexp "$a")
               (kill-buffer-hook nil)) ;; outline-regexp never matches to avoid headline
           (cl-letf (((symbol-function 'px-remove) #'ignore))
             (if ein:%notebook-latex-p%
                 (progn
                   (ein:worksheet-render (ein:worksheet--get-ws-or-error))
                   (setq ein:%notebook-latex-p% nil))
               (px-preview)
               (setq ein:%notebook-latex-p% t)))))
        (t (ein:display-warning "px package not found"))))

;;; Kernel related things

(defun ein:list-available-kernels (url-or-port)
  (let ((kernelspecs (ein:need-kernelspecs url-or-port)))
    (if kernelspecs
        (cl-sort (cl-loop for (_key spec) on (ein:plist-exclude kernelspecs '(:default)) by 'cddr
                   collecting (cons (ein:$kernelspec-name spec)
                                    (ein:$kernelspec-display-name spec)))
                 #'string< :key #'cdr))))

(defun ein:notebook-switch-kernel (notebook kernel-name)
  "Change the kernel for a running notebook. If not called from a
notebook buffer then the user will be prompted to select an opened notebook."
  (interactive
   (let* ((notebook (or (ein:get-notebook)
                        (ein:completing-read
                         "Select notebook: "
                         (ein:notebook-opened-buffer-names))))
          (kernel-name (ein:completing-read
                        "Select kernel: "
                        (ein:list-available-kernels (ein:$notebook-url-or-port notebook)))))
     (list notebook kernel-name)))
  (let* ((kernelspec (ein:get-kernelspec
                      (ein:$notebook-url-or-port notebook) kernel-name)))
    (setf (ein:$notebook-kernelspec notebook) kernelspec)
    (setf (ein:$notebook-metadata notebook)
          (plist-put (ein:$notebook-metadata notebook)
                     :kernelspec (ein:notebook--spec-insert-name
                                  (ein:$kernelspec-name kernelspec) (ein:$kernelspec-spec kernelspec))))
    (ein:notebook-save-notebook notebook #'ein:notebook-kill-kernel-then-close-command
                                (list notebook))
    (cl-loop repeat 10
      until (null (ein:$kernel-websocket (ein:$notebook-kernel notebook)))
      do (sleep-for 0 500)
      finally return (ein:notebook-open (ein:$notebook-url-or-port notebook)
                                        (ein:$notebook-notebook-path notebook)))))

(defun ein:notebook-install-kernel (notebook)
  (let* ((base-url (concat ein:base-kernel-url "kernels"))
         (kernelspec (ein:$notebook-kernelspec notebook))
         (kernel (ein:kernel-new (ein:$notebook-url-or-port notebook)
                                 (ein:$notebook-notebook-path notebook)
                                 kernelspec
                                 base-url
                                 (ein:$notebook-events notebook)
                                 (ein:$notebook-api-version notebook))))
    (setf (ein:$notebook-kernel notebook) kernel)
    (when (eq (ein:get-mode-for-kernel (ein:$notebook-kernelspec notebook)) 'python)
      (ein:pytools-setup-hooks kernel notebook))))

(defun ein:notebook-reconnect-session-command ()
   "It seems convenient but undisciplined to blithely create a new session if the original one no longer exists."
   (interactive)
   (ein:kernel-reconnect-session (ein:$notebook-kernel ein:%notebook%)))

(defun ein:notebook-restart-session-command ()
   "Delete session on server side.  Start new session."
  (interactive)
  (ein:aif ein:%notebook%
           (if (y-or-n-p "Are you sure? ")
               (ein:kernel-restart-session (ein:$notebook-kernel it)))
    (message "Not in notebook buffer!")))

(define-obsolete-function-alias
  'ein:notebook-request-tool-tip-or-help-command
  'ein:pytools-request-tooltip-or-help "0.1.2")

(defun ein:notebook-ac-dot-complete ()
  "Insert dot and request completion."
  (interactive)
  (if (and (ein:get-notebook)
           (ein:codecell-p (ein:get-cell-at-point)))
      (call-interactively #'ein:ac-dot-complete)
    (insert ".")))

(defun ein:notebook-kernel-interrupt-command ()
  "Interrupt the kernel.
This is equivalent to do ``C-c`` in the console program."
  (interactive)
  (ein:kernel-interrupt (ein:$notebook-kernel ein:%notebook%)))

;; autoexec

(defun ein:notebook-execute-autoexec-cells (notebook)
  "Execute cells of which auto-execution flag is on."
  (interactive (list (or ein:%notebook% (error "Not in notebook buffer!"))))
  (mapc #'ein:worksheet-execute-autoexec-cells
        (ein:$notebook-worksheets notebook)))

(define-obsolete-function-alias
  'ein:notebook-eval-string
  'ein:shared-output-eval-string "0.1.2")


;;; Persistence and loading

(defun ein:notebook-set-notebook-name (notebook name)
  "Check NAME and change the name of NOTEBOOK to it."
  (if (ein:notebook-test-notebook-name name)
      (setf (ein:$notebook-notebook-name notebook) name
            (ein:$notebook-notebook-id notebook) name)
    (ein:log 'error "%S is not a good notebook name." name)
    (error "%S is not a good notebook name." name)))

(defun ein:notebook-test-notebook-name (name)
  (and (stringp name)
       (> (length name) 0)
       (not (string-match "[\\/\\\\:]" name))))

(cl-defun ein:notebook--worksheet-new (notebook &optional (func #'ein:worksheet-new))
  (funcall func
           (ein:$notebook-nbformat notebook)
           (ein:notebook-name-getter notebook)
           (cons (lambda (notebook cell)
                   (ein:notebook-discard-output-p notebook cell))
                 notebook)
           (ein:$notebook-kernel notebook)
           (ein:$notebook-events notebook)))

(defun ein:notebook--worksheet-render (notebook ws)
  (ein:worksheet-render ws)
  (with-current-buffer (ein:worksheet-buffer ws)
    (let (multilang-failed)
      (if ein:polymode
          (poly-ein-mode)
        ;; Changing major mode here is super dangerous as it
        ;; kill-all-local-variables.
        ;; Our saviour has been `ein:deflocal' which applies 'permanent-local
        ;; to variables assigned up to this point, but we ought not rely on it
        (funcall (ein:notebook-choose-mode))
        (ein:worksheet-reinstall-undo-hooks ws)
        (condition-case err
            (ein:aif (ein:$notebook-kernelspec notebook)
                (ein:ml-lang-setup it))
          (error (ein:log 'error (error-message-string err))
                 (setq multilang-failed t))))
      (unless multilang-failed
        (ein:notebook-mode)
        (ein:notebook--notification-setup notebook)
        (ein:notebook-setup-kill-buffer-hook)
        (setq ein:%notebook% notebook)
        (when ein:polymode
          (poly-ein-fontify-buffer (ein:notebook-buffer notebook)))))))

(defun ein:notebook--notification-setup (notebook)
  (ein:notification-setup
   (current-buffer)
   (ein:$notebook-events notebook)
   :get-list
   (lambda () (ein:$notebook-worksheets ein:%notebook%))
   :get-current
   (lambda () ein:%worksheet%)
   :get-name
   #'ein:worksheet-name
   :get-buffer
   (lambda (ws)
     (ein:notebook-worksheet--render-maybe ein:%notebook% ws "clicked")
     (ein:worksheet-buffer ws))
   :delete
   (lambda (ws)
     (ein:notebook-worksheet-delete ein:%notebook% ws t))
   :insert-prev
   (lambda (ws) (ein:notebook-worksheet-insert-prev ein:%notebook% ws))
   :insert-next
   (lambda (ws) (ein:notebook-worksheet-insert-next ein:%notebook% ws))
   :move-prev
   (lambda (ws) (ein:notebook-worksheet-move-prev ein:%notebook% ws))
   :move-next
   (lambda (ws) (ein:notebook-worksheet-move-next ein:%notebook% ws))
   ))

(defun ein:notebook-set-buffer-file-name-maybe (_notebook)
  (ein:log 'warn "This function is deprecated. Who could be calling me?"))

;; (defun ein:notebook-set-buffer-file-name-maybe (notebook)
;;   "Set `buffer-file-name' of the current buffer to ipynb file
;; of NOTEBOOK."
;;   (when ein:notebook-set-buffer-file-name
;;     (ein:notebook-fetch-data
;;      notebook
;;      (lambda (data notebook buffer)
;;        (with-current-buffer buffer
;;          (cl-destructuring-bind (&key project &allow-other-keys)
;;              data
;;            (setq buffer-file-name
;;                  (expand-file-name
;;                   (format "%s.ipynb"
;;                           (ein:$notebook-notebook-name notebook))
;;                   project)))))
;;      (list notebook (current-buffer)))))

(defun ein:notebook-from-json (notebook data)
  (cl-destructuring-bind (&key metadata nbformat nbformat_minor
                               &allow-other-keys)
      data
    (setf (ein:$notebook-metadata notebook) metadata)
    (setf (ein:$notebook-nbformat notebook) nbformat)
    (setf (ein:$notebook-nbformat-minor notebook) nbformat_minor))
  (setf (ein:$notebook-worksheets notebook)
        (cl-case (ein:$notebook-nbformat notebook)
          (3 (ein:read-nbformat3-worksheets notebook data))
          (4 (ein:read-nbformat4-worksheets notebook data))
          (t (ein:log 'error "nbformat version %s unsupported"
                      (ein:$notebook-nbformat notebook)))))
  (ein:notebook--worksheet-render notebook (car (ein:$notebook-worksheets notebook)))
  notebook)

(defun ein:read-nbformat3-worksheets (notebook data)
  (mapcar (lambda (ws-data)
                    (ein:worksheet-from-json
                     (ein:notebook--worksheet-new notebook)
                     ws-data))
          (or (plist-get data :worksheets)
              (list nil))))

;; nbformat4 gets rid of the concept of worksheets. That means, for the moment,
;; ein will no longer support worksheets. There may be a path forward for
;; reimplementing this feature, however.  The nbformat 4 json definition says
;; that cells are allowed to have tags. Clever use of this feature may lead to
;; good things.

(defun ein:read-nbformat4-worksheets (notebook data)
  "Convert a notebook in nbformat4 to a list of worksheet-like
  objects suitable for processing in ein:notebook-from-json."
  (let* ((cells (plist-get data :cells))
         (ws-cells (mapcar (lambda (data) (ein:cell-from-json data)) cells))
         (worksheet (ein:notebook--worksheet-new notebook)))
    (oset worksheet :saved-cells ws-cells)
    ;(mapcar (lambda (data) (message "test %s" (slot-value data 'metadata))) ws-cells)
    (list worksheet)))

(defun ein:notebook-to-json (notebook)
  "Return json-ready alist."
  (let ((data
         (cl-case (ein:$notebook-nbformat notebook)
           (3 (ein:write-nbformat3-worksheets notebook))
           (4 (ein:write-nbformat4-worksheets notebook))
           (t (ein:log 'error "nbformat version %s unsupported"
                       (ein:$notebook-nbformat notebook))))))
    ;; Apparently metadata can be either a hashtable or a plist...
    (let ((metadata (cdr (assq 'metadata data))))
      (if (hash-table-p metadata)
          (setf (gethash 'name metadata) (ein:$notebook-notebook-name notebook))
        (plist-put metadata
                   :name (ein:$notebook-notebook-name notebook)))
      (ein:aif (ein:$notebook-nbformat-minor notebook)
          ;; Do not set nbformat when it is not given from server.
          (push `(nbformat_minor . ,it) data))
      (push `(nbformat . ,(ein:$notebook-nbformat notebook)) data)
      data)))


(defun ein:write-nbformat3-worksheets (notebook)
  (let ((worksheets (mapcar #'ein:worksheet-to-json
                            (ein:$notebook-worksheets notebook))))
    `((worksheets . ,(apply #'vector worksheets))
      (metadata . ,(ein:$notebook-metadata notebook))
      )))

(defsubst ein:notebook--spec-insert-name (name spec)
  "Add kernel NAME, e.g., 'python2', to the kernelspec member of ipynb metadata."
  (if (plist-member spec :name)
      spec
    (plist-put spec :name name)))

(defun ein:write-nbformat4-worksheets (notebook)
  (let ((all-cells (cl-loop for ws in (ein:$notebook-worksheets notebook)
                     for i from 0
                     append (ein:worksheet-to-nb4-json ws i))))
    ;; should be in notebook constructor, not here
    (ein:aif (ein:$notebook-kernelspec notebook)
        (setf (ein:$notebook-metadata notebook)
              (plist-put (ein:$notebook-metadata notebook)
                         :kernelspec (ein:notebook--spec-insert-name
                                      (ein:$kernelspec-name it) (ein:$kernelspec-spec it)))))
    `((metadata . ,(ein:aif (ein:$notebook-metadata notebook)
                       it
                     (make-hash-table)))
      (cells . ,(apply #'vector all-cells)))))

(defun ein:notebook-maybe-save-notebook (notebook &optional callback cbargs)
  (if (cl-some #'(lambda (ws)
                   (buffer-modified-p
                    (ein:worksheet-buffer ws)))
               (ein:$notebook-worksheets notebook))
      (ein:notebook-save-notebook notebook callback cbargs)))

(defun ein:notebook-save-notebook (notebook &optional callback cbargs errback)
  (unless (ein:notebook-buffer notebook)
    (let ((buf (format ein:notebook-buffer-name-template
                       (ein:$notebook-url-or-port notebook)
                       (ein:$notebook-notebook-name notebook))))
      (ein:log 'error "ein:notebook-save-notebook: notebook %s has no buffer!" buf)
      (setf (ewoc--buffer (ein:worksheet--ewoc
                           (car (ein:$notebook-worksheets notebook))))
            (get-buffer buf))))
  (condition-case err
      (with-current-buffer (ein:notebook-buffer notebook)
        (cl-letf (((symbol-function 'delete-trailing-whitespace) #'ignore))
          (run-hooks 'before-save-hook)))
    (error (ein:log 'warn "ein:notebook-save-notebook: Saving despite '%s'."
                    (error-message-string err))))
  (let ((content (ein:content-from-notebook notebook)))
    (ein:events-trigger (ein:$notebook-events notebook)
                        'notebook_saving.Notebook)
    (ein:content-save content
                      #'ein:notebook-save-notebook-success
                      (list notebook callback cbargs)
                      #'ein:notebook-save-notebook-error
                      (list notebook errback))))

(defun ein:notebook-save-notebook-command ()
  "Save the notebook."
  (interactive)
  (ein:notebook-save-notebook ein:%notebook%))

(defun ein:notebook-save-notebook-success (notebook &optional callback cbargs)
  (ein:log 'verbose "Notebook is saved.")
  (setf (ein:$notebook-dirty notebook) nil)
  (mapc (lambda (ws)
          (ein:worksheet-save-cells ws) ; [#]_
          (ein:worksheet-set-modified-p ws nil))
        (ein:$notebook-worksheets notebook))
  (ein:events-trigger (ein:$notebook-events notebook)
                      'notebook_saved.Notebook)
  (when ein:notebook-create-checkpoint-on-save
    (ein:notebook-create-checkpoint notebook))
  (when callback
    (apply callback cbargs)))

;; .. [#] Consider the following case.
;;    (1) Open worksheet WS0 and other worksheets.
;;    (2) Edit worksheet WS0 then save the notebook.
;;    (3) Edit worksheet WS0.
;;    (4) Kill WS0 buffer by discarding the edit.
;;    (5) Save the notebook.
;;    This should save the latest WS0.  To do so, WS0 at the point (2)
;;    must be cached in the worksheet slot `:saved-cells'.

(cl-defun ein:notebook-save-notebook-error (notebook &key symbol-status &allow-other-keys)
  (if (eq symbol-status 'user-cancel)
      (ein:log 'info "Cancel saving notebook.")
    (ein:log 'info "Failed to save notebook!")
    (ein:events-trigger (ein:$notebook-events notebook)
                        'notebook_save_failed.Notebook)))

(defun ein:notebook-rename-command (path)
  "Rename current notebook and save it immediately.

NAME is any non-empty string that does not contain '/' or '\\'."
  (interactive
   (list (read-string "Rename to: "
                      (ein:$notebook-notebook-path ein:%notebook%))))
  (unless (and (string-match "\\.ipynb" path) (= (match-end 0) (length path)))
    (setq path (format "%s.ipynb" path)))
  (let* ((notebook (ein:notebook--get-nb-or-error))
         (content (ein:content-from-notebook notebook)))
    (ein:log 'verbose "Renaming notebook %s to '%s'" (ein:notebook-url notebook) path)
    (ein:content-rename content path #'ein:notebook-rename-success
                        (list notebook content))))

(defun ein:notebook-save-to-command (path)
  "Make a copy of the notebook and save it to a new path specified by NAME.
NAME is any non-empty string that does not contain '/' or '\\'.
"
  (interactive
   (list (read-string "Save copy to: " (ein:$notebook-notebook-path ein:%notebook%))))
  (unless (and (string-match ".ipynb" path) (= (match-end 0) (length path)))
    (setq path (format "%s.ipynb" path)))
  (let* ((content (ein:content-from-notebook ein:%notebook%))
         (name (substring path (or (cl-position ?/ path :from-end t) 0))))
    (setf (ein:$content-path content) path
          (ein:$content-name content) name)
    (ein:content-save content #'ein:notebook-open
                      (list (ein:$notebook-url-or-port ein:%notebook%)
                            path))))

(cl-defun ein:notebook-rename-success (notebook content)
  (ein:notebook-remove-opened-notebook notebook)
  (ein:notebook-set-notebook-name notebook (ein:$content-name content))
  (setf (ein:$notebook-notebook-path notebook) (ein:$content-path content))
  (ein:notebook-put-opened-notebook notebook)
  (mapc #'ein:worksheet-set-buffer-name
        (append (ein:$notebook-worksheets notebook)
                (ein:$notebook-scratchsheets notebook)))
  (ein:and-let* ((kernel (ein:$notebook-kernel notebook)))
    (ein:session-rename (ein:$kernel-url-or-port kernel)
                        (ein:$kernel-session-id kernel)
                        (ein:$content-path content))
    (setf (ein:$kernel-path kernel) (ein:$content-path content)))
  (ein:log 'info "Notebook renamed to %s." (ein:$content-name content)))

(defmacro ein:notebook-avoid-recursion (&rest body)
  `(let ((kill-buffer-query-functions
          (remove 'ein:notebook-kill-buffer-query kill-buffer-query-functions)))
     ,@body))

(defun ein:notebook-kill-notebook-buffers (notebook)
  "Kill all of NOTEBOOK's buffers"
  (mapc #'ein:notebook-kill-current-buffer (ein:notebook-buffer-list notebook)))

(defun ein:notebook-kill-current-buffer (buf)
  "Kill BUF and avoid recursion in kill-buffer-query-functions"
  (ein:notebook-avoid-recursion
   (let ((notebook (buffer-local-value 'ein:%notebook% buf)))
     (when (kill-buffer buf)
       (ein:notebook-tidy-opened-notebooks notebook)))))

(defsubst ein:notebook-kill-buffer-query ()
  (ein:aif (ein:get-notebook--notebook)
      (let ((buf (or (buffer-base-buffer (current-buffer))
                     (current-buffer))))
        (ein:notebook-ask-save it (apply-partially
                                   #'ein:notebook-kill-current-buffer
                                   buf))
        ;; don't kill buffer!
        nil)
    ;; kill buffer!
    t))

(defun ein:notebook-ask-save (notebook callback0)
  (unless callback0
    (setq callback0 #'ignore))
  (if (and (ein:notebook-modified-p notebook)
           (not (ob-ein-anonymous-p (ein:$notebook-notebook-path notebook))))
      (if (y-or-n-p (format "Save %s?" (ein:$notebook-notebook-name notebook)))
          (let ((success-positive 0))
            (add-function :before (var callback0) (lambda () (setq success-positive 1)))
            (ein:notebook-save-notebook notebook callback0 nil
                                        (lambda () (setq success-positive -1)))
            (cl-loop repeat 10
              until (not (zerop success-positive))
              do (sleep-for 0 200)
              finally return (> success-positive 0)))
        (when (ein:worksheet-p ein:%worksheet%)
          (ein:worksheet-dont-save-cells ein:%worksheet%)) ;; TODO de-obfuscate
        (funcall callback0)
        t)
    (funcall callback0)
    t))

(defun ein:notebook-close (notebook &optional callback &rest cbargs)
  (interactive (list (ein:notebook--get-nb-or-error)))
  (let* ((notebook (or notebook (ein:notebook--get-nb-or-error)))
         (callback0 (apply-partially #'ein:notebook-kill-notebook-buffers notebook)))
    (when callback
      (add-function :after (var callback0)
                    (apply #'apply-partially callback cbargs)))
    (ein:notebook-ask-save notebook callback0)))

(defun ein:notebook-kill-kernel-then-close-command (notebook)
  "Kill kernel and then kill notebook buffer.
To close notebook without killing kernel, just close the buffer
as usual."
  (interactive (list (ein:notebook--get-nb-or-error)))
  (let ((kernel (ein:$notebook-kernel notebook))
        (callback1 (apply-partially
                    (lambda (notebook* _kernel)
                      (ein:notebook-close notebook*))
                    notebook)))
    (if (ein:kernel-live-p kernel)
        (ein:message-whir "Ending session"
                          (add-function :before (var callback1) done-callback)
                          (ein:kernel-delete-session kernel callback1))
      (funcall callback1 nil))))

(defun ein:fast-content-from-notebook (notebook)
  "Quickly generate a basic content structure from notebook. This
function does not generate the full json representation of the
notebook worksheets."
  (make-ein:$content :name (ein:$notebook-notebook-name notebook)
                     :path (ein:$notebook-notebook-path notebook)
                     :url-or-port (ein:$notebook-url-or-port notebook)
                     :type "notebook"
                     :notebook-version (ein:$notebook-api-version notebook)))

(defun ein:notebook-create-checkpoint (notebook)
  "Create checkpoint for current notebook based on most recent save."
  (interactive (list (ein:get-notebook)))
  (if (ein:$notebook-q-checkpoints notebook)
      (ein:content-create-checkpoint
       (ein:fast-content-from-notebook notebook)
       (let ((notebook notebook))
         #'(lambda (content)
             (ein:log 'verbose "Checkpoint %s for %s generated."
                      (plist-get (car (ein:$content-checkpoints content)) :id)
                      (ein:$notebook-notebook-name notebook))
             (setf (ein:$notebook-checkpoints notebook)
                   (ein:$content-checkpoints content)))))))

(defun ein:notebook-list-checkpoint-ids (notebook)
  (unless (ein:$notebook-checkpoints notebook)
    (ein:content-query-checkpoints (ein:fast-content-from-notebook notebook)
                                   (let ((notebook notebook))
                                     #'(lambda (content)
                                         (setf (ein:$notebook-checkpoints notebook)
                                               (ein:$content-checkpoints content)))))
    (sleep-for 0.5))
  (cl-loop for cp in (ein:$notebook-checkpoints notebook)
    collecting (plist-get cp :last_modified)))

(defun ein:notebook-restore-to-checkpoint (notebook checkpoint)
  "Restore notebook to previous checkpoint saved on the Jupyter
server. Note that if there are multiple checkpoints the user will
be prompted on which one to use."
  (interactive
   (let* ((notebook (ein:get-notebook))
          (checkpoint (ein:completing-read
                       "Select checkpoint: "
                       (ein:notebook-list-checkpoint-ids notebook))))
     (list notebook checkpoint)))
  (ein:content-restore-checkpoint (ein:fast-content-from-notebook notebook)
                                  checkpoint)
  (ein:notebook-close notebook)
  (ein:notebook-open (ein:$notebook-url-or-port notebook)
                     (ein:$notebook-notebook-path notebook)))


;;; Worksheet

(defmacro ein:notebook--worksheet-render-new (notebook type)
  "Create new worksheet of TYPE in NOTEBOOK."
  (let ((func (intern (format "ein:%s-new" type)))
        (slot (list (intern (format "ein:$notebook-%ss" type)) notebook)))
    `(let ((ws (ein:notebook--worksheet-new ,notebook #',func)))
       (setf ,slot (append ,slot (list ws)))
       (ein:notebook--worksheet-render ,notebook ws)
       ws)))

(defun ein:notebook-worksheet-render-new (notebook)
  "Create new worksheet in NOTEBOOK."
  (ein:notebook--worksheet-render-new notebook worksheet))

(defun ein:notebook-worksheet-open-next-or-new (notebook ws &optional show)
  "Open next worksheet.  Create new if none.

Try to open the worksheet to the worksheet WS using the function
`ein:notebook-worksheet-open-next', open a new worksheet if not
found.

SHOW is a function to be called with the worksheet buffer if
given."
  (interactive (list (ein:notebook--get-nb-or-error)
                     (ein:worksheet--get-ws-or-error)
                     #'switch-to-buffer))
  (let ((next (ein:notebook-worksheet-open-next notebook ws)))
    (unless next
      (ein:log 'info "Creating new worksheet...")
      (setq next (ein:notebook-worksheet-render-new notebook))
      (ein:log 'info "Creating new worksheet... Done."))
    (when show
      (funcall show (ein:worksheet-buffer next)))))

(defun ein:notebook-worksheet-open-next-or-first (notebook ws &optional show)
  "Open next or first worksheet.

Try to open the worksheet to the worksheet WS using the function
`ein:notebook-worksheet-open-next', open the first worksheet if
not found.

SHOW is a function to be called with the worksheet buffer if
given."
  (interactive (list (ein:notebook--get-nb-or-error)
                     (ein:worksheet--get-ws-or-error)
                     #'switch-to-buffer))
  (let ((next (ein:notebook-worksheet-open-next notebook ws)))
    (unless next
      (setq next (car (ein:$notebook-worksheets notebook))))
    (when show
      (funcall show (ein:worksheet-buffer next)))))

(defun ein:notebook-worksheet-open-prev-or-last (notebook ws &optional show)
  "Open previous or last worksheet.
See also `ein:notebook-worksheet-open-next-or-first' and
`ein:notebook-worksheet-open-prev'."
  (interactive (list (ein:notebook--get-nb-or-error)
                     (ein:worksheet--get-ws-or-error)
                     #'switch-to-buffer))
  (let ((prev (ein:notebook-worksheet-open-prev notebook ws)))
    (unless prev
      (setq prev (car (last (ein:$notebook-worksheets notebook)))))
    (when show
      (funcall show (ein:worksheet-buffer prev)))))

(cl-defun ein:notebook-worksheet--render-maybe
    (notebook ws &optional (adj "next"))
  "Render worksheet WS of NOTEBOOK if it does not have buffer.
ADJ is a adjective to describe worksheet to be rendered."
  (if (ein:worksheet-has-buffer-p ws)
      (ein:log 'verbose "The worksheet already has a buffer.")
    (ein:log 'verbose "Rendering %s worksheet..." adj)
    (ein:notebook--worksheet-render notebook ws)
    (ein:log 'verbose "Rendering %s worksheet... Done." adj)))

(cl-defun ein:notebook-worksheet--open-new
    (notebook new &optional (adj "next") show)
  "Open (possibly new) worksheet NEW of NOTEBOOK with SHOW function.
ADJ is a adjective to describe worksheet to be opened.
SHOW is a function to be called with worksheet buffer if given."
  (when new
    (ein:notebook-worksheet--render-maybe notebook new adj))
  (when show
    (cl-assert (ein:worksheet-p new) nil "No %s worksheet." adj)
    (funcall show (ein:worksheet-buffer new))))

(defun ein:notebook-worksheet-open-next (notebook ws &optional show)
  "Open next worksheet.

Search the worksheet after the worksheet WS, render it if it is
not yet, then return the worksheet.  If there is no such
worksheet, return nil.  Open the first worksheet if the worksheet
WS is an instance of `ein:scratchsheet'.

SHOW is a function to be called with the worksheet buffer if
given."
  (interactive (list (ein:notebook--get-nb-or-error)
                     (ein:worksheet--get-ws-or-error)
                     #'switch-to-buffer))
  (let ((next (if (ein:scratchsheet-p ws)
                  (car (ein:$notebook-worksheets notebook))
                (cl-loop with worksheets = (ein:$notebook-worksheets notebook)
                  for current in worksheets
                  for next in (cdr worksheets)
                  when (eq current ws) return next))))
    (ein:notebook-worksheet--open-new notebook next "next" show)
    next))

(defun ein:notebook-worksheet-open-prev (notebook ws &optional show)
  "Open previous worksheet.
See also `ein:notebook-worksheet-open-next'."
  (interactive (list (ein:notebook--get-nb-or-error)
                     (ein:worksheet--get-ws-or-error)
                     #'switch-to-buffer))
  (let ((prev (if (ein:scratchsheet-p ws)
                  (car (last (ein:$notebook-worksheets notebook)))
                (cl-loop for (prev current) on (ein:$notebook-worksheets notebook)
                  when (eq current ws) return prev))))
    (ein:notebook-worksheet--open-new notebook prev "previous" show)
    prev))

(defun ein:notebook-worksheet-open-ith (notebook i &optional show)
  "Open I-th (zero-origin) worksheet."
  (let ((ws (nth i (ein:$notebook-worksheets notebook))))
    (unless ws (error "No %s-th worksheet" (1+ i)))
    (ein:notebook-worksheet--open-new notebook ws (format "%s-th" i) show)))

(defmacro ein:notebook-worksheet--defun-open-nth (n)
  "Define a command to open N-th (one-origin) worksheet."
  (cl-assert (and (integerp n) (> n 0)) t "Bad nth worksheet n=%s" n)
  (let ((func (intern (format "ein:notebook-worksheet-open-%sth" n))))
    `(defun ,func (notebook &optional show)
       ,(format "Open %d-th worksheet." n)
       (interactive (list (ein:notebook--get-nb-or-error)
                          #'switch-to-buffer))
       (ein:notebook-worksheet-open-ith notebook ,(1- n) show))))

(defmacro ein:notebook-worksheet--defun-all-open-nth (min max)
  `(progn
     ,@(cl-loop for n from min to max
         collect `(ein:notebook-worksheet--defun-open-nth ,n))))

(ein:notebook-worksheet--defun-all-open-nth 1 8)

(defun ein:notebook-worksheet-open-last (notebook &optional show)
  "Open the last worksheet."
  (interactive (list (ein:notebook--get-nb-or-error)
                     #'switch-to-buffer))
  (let ((last (car (last (ein:$notebook-worksheets notebook)))))
    (ein:notebook-worksheet--open-new notebook last "last" show)
    last))

(defun ein:notebook-worksheet-insert-new (notebook ws &optional render show
                                                   inserter)
  (let ((new (ein:notebook--worksheet-new notebook)))
    (setf (ein:$notebook-worksheets notebook)
          (funcall inserter (ein:$notebook-worksheets notebook) ws new))
    (when (or render show)
      (ein:notebook--worksheet-render notebook new))
    (when show
      (funcall show (ein:worksheet-buffer new)))
    new))

(cl-defun ein:notebook-worksheet-insert-next
    (notebook ws &optional (render t) (show #'switch-to-buffer))
  "Insert a new worksheet after this worksheet and open it.
See also `ein:notebook-worksheet-insert-prev'.

.. The worksheet WS is searched in the worksheets slot of
   NOTEBOOK and a newly created worksheet is inserted after WS.
   Worksheet buffer is created when RENDER or SHOW is non-`nil'.
   SHOW is a function which take a buffer."
  (interactive (list (ein:notebook--get-nb-or-error)
                     (ein:worksheet--get-ws-or-error)))
  (ein:notebook-worksheet-insert-new notebook ws render show
                                     #'ein:list-insert-after))

(cl-defun ein:notebook-worksheet-insert-prev
    (notebook ws &optional (render t) (show #'switch-to-buffer))
  "Insert a new worksheet before this worksheet and open it.
See also `ein:notebook-worksheet-insert-next'."
  (interactive (list (ein:notebook--get-nb-or-error)
                     (ein:worksheet--get-ws-or-error)))
  (ein:notebook-worksheet-insert-new notebook ws render show
                                     #'ein:list-insert-before))

(defun ein:notebook-worksheet-delete (notebook ws &optional confirm)
  "Delete the current worksheet.
When used as a lisp function, delete worksheet WS from NOTEBOOk."
  (interactive (list (ein:notebook--get-nb-or-error)
                     (ein:worksheet--get-ws-or-error)
                     t))
  (when confirm
    (unless (y-or-n-p
             "Really remove this worksheet? There is no undo.")
      (error "Quit deleting the current worksheet.")))
  (setf (ein:$notebook-worksheets notebook)
        (delq ws (ein:$notebook-worksheets notebook)))
  (setf (ein:$notebook-dirty notebook) t)
  (kill-buffer (ein:worksheet-buffer ws)))

(defun ein:notebook-worksheet-move-prev (notebook ws)
  "Switch the current worksheet with the previous one."
  (interactive (list (ein:notebook--get-nb-or-error)
                     (ein:worksheet--get-ws-or-error)))
  (cl-assert (ein:worksheet-p ws) nil "Not worksheet.")
  (setf (ein:$notebook-worksheets notebook)
        (ein:list-move-left (ein:$notebook-worksheets notebook) ws)))

(defun ein:notebook-worksheet-move-next (notebook ws)
  "Switch the current worksheet with the previous one."
  (interactive (list (ein:notebook--get-nb-or-error)
                     (ein:worksheet--get-ws-or-error)))
  (cl-assert (ein:worksheet-p ws) nil "Not worksheet.")
  (setf (ein:$notebook-worksheets notebook)
        (ein:list-move-right (ein:$notebook-worksheets notebook) ws)))

(cl-defun ein:notebook-worksheet-index
    (&optional (notebook ein:%notebook%)
               (ws ein:%worksheet%))
  "Return an index of the worksheet WS in NOTEBOOK."
  (cl-loop for i from 0
    for ith-ws in (ein:$notebook-worksheets notebook)
    when (eq ith-ws ws)
    return i))


;;; Scratch sheet

(defun ein:notebook-scratchsheet-render-new (notebook)
  "Create new scratchsheet in NOTEBOOK."
  (ein:notebook--worksheet-render-new notebook scratchsheet))

(defun ein:notebook-scratchsheet-open (notebook &optional new popup)
  "Open \"scratch sheet\".
Open a new one when prefix argument is given.
Scratch sheet is almost identical to worksheet.  However, EIN
will not save the buffer.  Use this buffer like of normal IPython
console.  Note that you can always copy cells into the normal
worksheet to save result."
  (interactive (list (ein:notebook--get-nb-or-error)
                     current-prefix-arg
                     t))
  (let ((ss (or (unless new
                  (car (ein:$notebook-scratchsheets notebook)))
                (ein:notebook-scratchsheet-render-new notebook))))
    (when popup
      (pop-to-buffer (ein:worksheet-buffer ss)))
    ss))


;;; Opened notebooks

(defvar ein:notebook--opened-map (make-hash-table :test 'equal)
  "A map: (URL-OR-PORT NOTEBOOK-ID) => notebook instance.")

(defun ein:notebook-get-opened-notebook (url-or-port path)
  (gethash (list url-or-port path) ein:notebook--opened-map))

(defun ein:notebook-get-opened-buffer (url-or-port path)
  (ein:aand (ein:notebook-get-opened-notebook url-or-port path)
            (ein:notebook-buffer it)))

(defun ein:notebook-put-opened-notebook (notebook)
  (puthash (list (ein:$notebook-url-or-port notebook)
                 (ein:$notebook-notebook-path notebook))
           notebook
           ein:notebook--opened-map))

(defun ein:notebook-tidy-opened-notebooks (notebook)
  "Remove NOTEBOOK from ein:notebook--opened-map if it's not ein:notebook-live-p"
  (unless (ein:notebook-live-p notebook)
    (ein:notebook-remove-opened-notebook notebook)))

(defun ein:notebook-remove-opened-notebook (notebook)
  (remhash (list (ein:$notebook-url-or-port notebook)
                 (ein:$notebook-notebook-path notebook))
           ein:notebook--opened-map))

(defun ein:notebook-opened-notebooks (&optional predicate)
  "Return list of opened notebook instances.
If PREDICATE is given, notebooks are filtered by PREDICATE.
PREDICATE is called with each notebook and notebook is included
in the returned list only when PREDICATE returns non-nil value."
  (let ((notebooks (hash-table-values ein:notebook--opened-map)))
    (if predicate
        (seq-filter predicate notebooks)
      notebooks)))

(defun ein:notebook-opened-buffers (&optional predicate)
  "Return list of opened notebook buffers."
  (mapcar #'ein:notebook-buffer (ein:notebook-opened-notebooks predicate)))

(defun ein:notebook-opened-buffer-names (&optional predicate)
  "Return list of opened notebook buffer names.
If PREDICATE is given, the list is filtered by PREDICATE.
PREDICATE is called with the buffer name for each opened notebook."
  (let ((notebooks (mapcar #'buffer-name (ein:notebook-opened-buffers))))
    (if predicate
        (seq-filter predicate notebooks)
      notebooks)))


;;; Generic getter

(defun ein:get-url-or-port--notebook ()
  (when ein:%notebook% (ein:$notebook-url-or-port ein:%notebook%)))

(defun ein:get-notebook--notebook ()
  ein:%notebook%)

(defun ein:get-kernel--notebook ()
  (when (ein:$notebook-p ein:%notebook%)
    (ein:$notebook-kernel ein:%notebook%)))


;;; Predicate

(defun ein:notebook-live-p (notebook)
  "Return non-`nil' if NOTEBOOK has live buffer."
  (buffer-live-p (ein:notebook-buffer notebook)))

(defun ein:notebook-modified-p (&optional notebook)
  "Return non-nil if NOTEBOOK is modified.
If NOTEBOOK is not given or nil then consider the notebook
associated with current buffer (if any)."
  (unless notebook (setq notebook ein:%notebook%))
  (and (ein:$notebook-p notebook)
       (ein:notebook-live-p notebook)
       (or (ein:$notebook-dirty notebook)
           (cl-loop for ws in (ein:$notebook-worksheets notebook)
             when (ein:worksheet-modified-p ws)
             return t))))


;;; Notebook mode

(defcustom ein:notebook-modes
  '(ein:notebook-multilang-mode)
  "Notebook modes to use \(in order of preference).

When the notebook is opened, mode in this value is checked one by one
and the first usable mode is used.

Available modes:

* `ein:notebook-multilang-mode'
* `ein:notebook-mumamo-mode'
* `ein:notebook-python-mode'
* `ein:notebook-plain-mode'

Examples:

Use MuMaMo if it is installed.  Otherwise, use plain mode.
This is the old default setting::

  (setq ein:notebook-modes '(ein:notebook-mumamo-mode ein:notebook-plain-mode))

Avoid using MuMaMo even when it is installed::

  (setq ein:notebook-modes '(ein:notebook-plain-mode))

Use simple `python-mode' based notebook mode when MuMaMo is not installed::

  (setq ein:notebook-modes '(ein:notebook-mumamo-mode ein:notebook-python-mode))
"
  :type '(repeat (choice (const :tag "Multi-lang" ein:notebook-multilang-mode)
                         (const :tag "MuMaMo" ein:notebook-mumamo-mode)
                         (const :tag "Only Python" ein:notebook-python-mode)
                         (const :tag "Plain" ein:notebook-plain-mode)))
  :group 'ein)


(defun ein:notebook-choose-mode ()
  "Return usable (defined) notebook mode."
  (autoload 'ein:notebook-multilang-mode "ein-multilang")
  (cl-loop for mode in ein:notebook-modes
    if (functionp mode)
    return mode))

(defvar ein:notebook-mode-map (make-sparse-keymap))

(with-eval-after-load "ein-smartrep"
  (ein:smartrep-config ein:notebook-mode-map))


(defmacro ein:notebook--define-key (keymap key defn)
  "Ideally we could override just the keymap binding with a (string . wrapped) cons pair (as opposed to messing with the DEFN itself), but then describe-minor-mode unhelpfully shows ?? for the keymap commands."
  `(progn
     (when (functionp ,defn)
       (add-function :around (symbol-function ,defn)
                     (lambda (f &rest args)
                       (poly-ein-base (apply f args)))))
     (define-key ,keymap ,key ,defn)))

(let ((map ein:notebook-mode-map))
  (ein:notebook--define-key map "\C-ci" 'ein:inspect-object)
  (ein:notebook--define-key map "\C-c'" 'ein:edit-cell-contents)
  (ein:notebook--define-key map "\C-c\C-c" 'ein:worksheet-execute-cell)
  (ein:notebook--define-key map (kbd "M-RET") 'ein:worksheet-execute-cell-and-goto-next)
  (ein:notebook--define-key map (kbd "<M-S-return>")
    'ein:worksheet-execute-cell-and-insert-below)
  (ein:notebook--define-key map (kbd "C-c C-'") 'ein:worksheet-turn-on-autoexec)
  (ein:notebook--define-key map "\C-c\C-e" 'ein:worksheet-toggle-output)
  (ein:notebook--define-key map "\C-c\C-v" 'ein:worksheet-set-output-visibility-all)
  (ein:notebook--define-key map "\C-c\C-l" 'ein:worksheet-clear-output)
  (ein:notebook--define-key map (kbd "C-c C-S-l") 'ein:worksheet-clear-all-output)
  (ein:notebook--define-key map (kbd "C-c C-;") 'ein:shared-output-show-code-cell-at-point)
  (ein:notebook--define-key map "\C-c\C-k" 'ein:worksheet-kill-cell)
  (ein:notebook--define-key map "\C-c\M-w" 'ein:worksheet-copy-cell)
  (ein:notebook--define-key map "\C-c\C-w" 'ein:worksheet-copy-cell)
  (ein:notebook--define-key map "\C-c\C-y" 'ein:worksheet-yank-cell)
  (ein:notebook--define-key map "\C-c\C-a" 'ein:worksheet-insert-cell-above)
  (ein:notebook--define-key map "\C-c\C-b" 'ein:worksheet-insert-cell-below)
  (ein:notebook--define-key map "\C-c\C-t" 'ein:worksheet-toggle-cell-type)
  (ein:notebook--define-key map "\C-cS" 'ein:worksheet-toggle-slide-type)
  (ein:notebook--define-key map "\C-c\C-u" 'ein:worksheet-change-cell-type)
  (ein:notebook--define-key map "\C-c\C-s" 'ein:worksheet-split-cell-at-point)
  (ein:notebook--define-key map "\C-c\C-m" 'ein:worksheet-merge-cell)
  (ein:notebook--define-key map "\C-c\C-n" 'ein:worksheet-goto-next-input)
  (ein:notebook--define-key map "\C-c\C-p" 'ein:worksheet-goto-prev-input)
  (ein:notebook--define-key map (kbd "C-<up>") 'ein:worksheet-goto-prev-input)
  (ein:notebook--define-key map (kbd "C-<down>") 'ein:worksheet-goto-next-input)
  (ein:notebook--define-key map (kbd "C-c <up>") 'ein:worksheet-move-cell-up)
  (ein:notebook--define-key map (kbd "C-c <down>") 'ein:worksheet-move-cell-down)
  (ein:notebook--define-key map (kbd "M-<up>") 'ein:worksheet-move-cell-up)
  (ein:notebook--define-key map (kbd "M-<down>") 'ein:worksheet-move-cell-down)
  (ein:notebook--define-key map "\C-c\C-h" 'ein:pytools-request-tooltip-or-help)
  (ein:notebook--define-key map "\C-c\C-i" 'ein:completer-complete)
  (ein:notebook--define-key map (kbd "C-c C-$") 'ein:tb-show)
  (ein:notebook--define-key map "\C-c\C-x" nil)
  (ein:notebook--define-key map "\C-c\C-x\C-l" 'ein:notebook-toggle-latex-fragment)
  (ein:notebook--define-key map "\C-c\C-x\C-r" 'ein:notebook-restart-session-command)
  (ein:notebook--define-key map "\C-c\C-r" 'ein:notebook-reconnect-session-command)
  (ein:notebook--define-key map "\C-c\C-z" 'ein:notebook-kernel-interrupt-command)
  (ein:notebook--define-key map "\C-c\C-q" 'ein:notebook-kill-kernel-then-close-command)
  (ein:notebook--define-key map (kbd "C-c C-#") 'ein:notebook-close)
  (ein:notebook--define-key map (kbd "C-:") 'ein:shared-output-eval-string)
  (ein:notebook--define-key map "\C-c\C-f" 'ein:file-open)
  (ein:notebook--define-key map "\C-c\C-o" 'ein:notebook-open)
  (ein:notebook--define-key map "\C-x\C-s" 'ein:notebook-save-notebook-command)
  (ein:notebook--define-key map "\C-x\C-w" 'ein:notebook-rename-command)
  (define-key map "\M-."          'ein:pytools-jump-to-source-command)
  (define-key map (kbd "C-c C-.") 'ein:pytools-jump-to-source-command)
  (define-key map "\M-,"          'ein:pytools-jump-back-command)
  (define-key map (kbd "C-c C-,") 'ein:pytools-jump-back-command)
  (ein:notebook--define-key map "\M-p"          'ein:worksheet-previous-input-history)
  (ein:notebook--define-key map "\M-n"          'ein:worksheet-next-input-history)
  (ein:notebook--define-key map (kbd "C-c C-/") 'ein:notebook-scratchsheet-open)
  ;; Worksheets
  (ein:notebook--define-key map (kbd "C-c !")     'ein:worksheet-rename-sheet)
  (ein:notebook--define-key map (kbd "C-c {")     'ein:notebook-worksheet-open-prev-or-last)
  (ein:notebook--define-key map (kbd "C-c }")     'ein:notebook-worksheet-open-next-or-first)
  (ein:notebook--define-key map (kbd "C-c M-{")   'ein:notebook-worksheet-move-prev)
  (ein:notebook--define-key map (kbd "C-c M-}")   'ein:notebook-worksheet-move-next)
  (ein:notebook--define-key map (kbd "C-c +")     'ein:notebook-worksheet-insert-next)
  (ein:notebook--define-key map (kbd "C-c M-+")   'ein:notebook-worksheet-insert-prev)
  (ein:notebook--define-key map (kbd "C-c -")     'ein:notebook-worksheet-delete)
  (ein:notebook--define-key map "\C-c1" 'ein:notebook-worksheet-open-1th)
  (ein:notebook--define-key map "\C-c2" 'ein:notebook-worksheet-open-2th)
  (ein:notebook--define-key map "\C-c3" 'ein:notebook-worksheet-open-3th)
  (ein:notebook--define-key map "\C-c4" 'ein:notebook-worksheet-open-4th)
  (ein:notebook--define-key map "\C-c5" 'ein:notebook-worksheet-open-5th)
  (ein:notebook--define-key map "\C-c6" 'ein:notebook-worksheet-open-6th)
  (ein:notebook--define-key map "\C-c7" 'ein:notebook-worksheet-open-7th)
  (ein:notebook--define-key map "\C-c8" 'ein:notebook-worksheet-open-8th)
  (ein:notebook--define-key map "\C-c9" 'ein:notebook-worksheet-open-last)
  ;; Menu
  (easy-menu-define ein:notebook-menu map "EIN Notebook Mode Menu"
    `("EIN Notebook"
      ("File"
       ,@(ein:generate-menu
          '(("Save notebook" ein:notebook-save-notebook-command)
            ("Copy and rename notebook" ein:notebook-save-to-command)
            ("Rename notebook" ein:notebook-rename-command)
            ("Close notebook" ein:notebook-close)
            ("Kill kernel then close notebook"
             ein:notebook-kill-kernel-then-close-command))))
      ("Edit"
       ,@(ein:generate-menu
          '(("Kill cell" ein:worksheet-kill-cell)
            ("Copy cell" ein:worksheet-copy-cell)
            ("Yank cell" ein:worksheet-yank-cell)
            ("Insert cell above" ein:worksheet-insert-cell-above)
            ("Insert cell below" ein:worksheet-insert-cell-below)
            ("Toggle cell type" ein:worksheet-toggle-cell-type)
            ("Toggle slide type" ein:worksheet-toggle-slide-type)
            ("Change cell type" ein:worksheet-change-cell-type)
            ("Split cell at point" ein:worksheet-split-cell-at-point)
            ("Merge cell" ein:worksheet-merge-cell)
            ("Go to next cell" ein:worksheet-goto-next-input)
            ("Go to previous cell" ein:worksheet-goto-prev-input)
            ("Move cell up" ein:worksheet-move-cell-up)
            ("Move cell down" ein:worksheet-move-cell-down)
            ("Dedent text in CELL" ein:worksheet-dedent-cell-text)
            )))
      ("Cell/Code"
       ,@(ein:generate-menu
          '(("Edit cell contents in dedicated buffer" ein:edit-cell-contents)
            ("Execute cell" ein:worksheet-execute-cell
             :active (ein:worksheet-at-codecell-p))
            ("Execute cell and go to next"
             ein:worksheet-execute-cell-and-goto-next
             :active (ein:worksheet-at-codecell-p))
            ("Execute cell and insert below"
             ein:worksheet-execute-cell-and-insert-below
             :active (ein:worksheet-at-codecell-p))
            ("Execute all cells"
             ein:worksheet-execute-all-cells)
	    ("Execute all cells above"
             ein:worksheet-execute-all-cells-above)
	    ("Execute all cells below"
             ein:worksheet-execute-all-cells-below)
            ("Turn on auto execution flag" ein:worksheet-turn-on-autoexec
             :active (ein:worksheet-at-codecell-p))
            ("Evaluate code in minibuffer" ein:shared-output-eval-string)
            ("Toggle instant cell execution mode" ein:iexec-mode)
            ))
       "---"
       ,@(ein:generate-menu
          '(("Toggle output visibility" ein:worksheet-toggle-output
             :active (ein:worksheet-at-codecell-p))
            ("Show all output"
             ein:worksheet-set-output-visibility-all)
            ("Discard output" ein:worksheet-clear-output
             :active (ein:worksheet-at-codecell-p))
            ("Discard all output" ein:worksheet-clear-all-output)
            ("Show full output" ein:shared-output-show-code-cell-at-point
             :active (ein:worksheet-at-codecell-p))
            ("Traceback viewer" ein:tb-show)
            ))
       "---"
       ,@(ein:generate-menu
          '(("Show object help"
             ein:pytools-request-tooltip-or-help)
            ("Complete code" ein:completer-complete
             :active (ein:worksheet-at-codecell-p))
            ("Jump to definition" ein:pytools-jump-to-source-command)
            ("Go back to the previous jump point"
             ein:pytools-jump-back-command)
            ("Previous input history"
             ein:worksheet-previous-input-history)
            ("Next input history"
             ein:worksheet-next-input-history))))
      ("Kernel"
       ,@(ein:generate-menu
          '(("Restart session" ein:notebook-restart-session-command)
            ("Reconnect session" ein:notebook-reconnect-session-command)
            ("Switch kernel" ein:notebook-switch-kernel)
            ("Interrupt kernel" ein:notebook-kernel-interrupt-command))))
      ("Worksheets [Experimental]"
       ,@(ein:generate-menu
          '(("Rename worksheet" ein:worksheet-rename-sheet)
            ("Insert next worksheet"
             ein:notebook-worksheet-insert-next)
            ("Insert previous worksheet"
             ein:notebook-worksheet-insert-prev)
            ("Delete worksheet" ein:notebook-worksheet-delete)
            ("Move worksheet left"  ein:notebook-worksheet-move-prev)
            ("Move worksheet right" ein:notebook-worksheet-move-next)
            ))
       "---"
       ,@(ein:generate-menu
          '(("Open previous worksheet"
             ein:notebook-worksheet-open-prev)
            ("Open previous or last worksheet"
             ein:notebook-worksheet-open-prev-or-last)
            ("Open next worksheet"
             ein:notebook-worksheet-open-next)
            ("Open next or first worksheet"
             ein:notebook-worksheet-open-next-or-first)
            ("Open next or new worksheet"
             ein:notebook-worksheet-open-next-or-new)
            ))
       "---"
       ,@(ein:generate-menu
          (append
           (cl-loop for n from 1 to 8
             collect
               (list
                (format "Open %d-th worksheet" n)
                (intern (format "ein:notebook-worksheet-open-%sth" n))))
           '(("Open last worksheet" ein:notebook-worksheet-open-last)))))
      ;; Misc:
      ,@(ein:generate-menu
         '(("Open regular IPython console" ein:console-open)
           ("Open scratch sheet" ein:notebook-scratchsheet-open)
           ("Toggle pseudo console mode" ein:pseudo-console-mode)
           ))
      ))
  map)

(defcustom ein:enable-eldoc-support nil
  "Enable experimental support for eldoc in notebook buffers.

Disabled by default, but if you want to help debug this feature set it to T and
watch the fireworks!"
  :type 'boolean
  :group 'ein)

(define-minor-mode ein:notebook-mode
  "A mode for jupyter notebooks.

\\{ein:notebook-mode-map}
"
  :init-value nil
  :lighter " Notebook"
  :keymap ein:notebook-mode-map
  :group 'ein

  ;; BODY contains code to execute each time the mode is enabled or disabled.
  ;; It is executed after toggling the mode, and before running MODE-hook.

  (when ein:notebook-mode
    (cl-case ein:completion-backend
      (ein:use-ac-backend
       (ein:ac-install-backend)
       (ein:notebook--define-key ein:notebook-mode-map "." 'ein:notebook-ac-dot-complete)
       (auto-complete-mode))
      (ein:use-company-backend
       (add-to-list 'company-backends 'ein:company-backend)
       (ein:notebook--define-key ein:notebook-mode-map "." nil)
       (company-mode)))
    (ein:aif ein:helm-kernel-history-search-key
        (ein:notebook--define-key ein:notebook-mode-map it 'helm-ein-kernel-history))
    (ein:aif ein:anything-kernel-history-search-key
        (ein:notebook--define-key ein:notebook-mode-map it 'anything-ein-kernel-history))
    (setq indent-tabs-mode nil) ;; Being T causes problems with Python code.
    (when (and (featurep 'eldoc) ein:enable-eldoc-support)
        (add-function :before-until (local 'eldoc-documentation-function)
                      #'ein:completer--get-eldoc-signature)
        (eldoc-mode))
    (ein:worksheet-imenu-setup)
    (when ein:use-smartrep
      (require 'ein-smartrep))))

;; To avoid MuMaMo to discard `ein:notebook-mode', make it
;; permanent local.
(put 'ein:notebook-mode 'permanent-local t)

(define-derived-mode ein:notebook-plain-mode fundamental-mode "EIN[plain]"
  "IPython notebook mode without fancy coloring."
  (font-lock-mode))

(define-derived-mode ein:notebook-python-mode python-mode "EIN[python]"
  "Use `python-mode' for whole notebook buffer.")

(defun ein:notebook-open-in-browser (&optional print)
  "Open current notebook in web browser.
When the prefix argument (``C-u``) is given, print page is opened.
Note that print page is not supported in IPython 0.12.1."
  (interactive "P")
  (let ((url (apply #'ein:url
                    (ein:$notebook-url-or-port ein:%notebook%)
                    (if (>= (ein:$notebook-api-version ein:%notebook%) 3)
                        "notebooks")
                    (ein:$notebook-notebook-path ein:%notebook%)
                    (if print (list "print")))))
    (message "Opening %s in browser" url)
    (browse-url url)))

(defun ein:notebook-fetch-data (notebook callback &optional cbargs)
  "Fetch data in body tag of NOTEBOOK html page.
CALLBACK is called with a plist with data in the body tag as
the first argument and CBARGS as the rest of arguments."
  (let ((url-or-port (ein:$notebook-url-or-port notebook))
        (notebook-id (ein:$notebook-notebook-id notebook)))
    (ein:query-singleton-ajax
     (list 'notebook-fetch-data url-or-port notebook-id)
     (ein:url url-or-port notebook-id)
     :parser
     (lambda ()
       (list
        :project
        (ein:html-get-data-in-body-tag "data-project")
        :base-project-url
        (ein:html-get-data-in-body-tag "data-base-project-url")
        :base-kernel-url
        (ein:html-get-data-in-body-tag "data-base-kernel-url")
        :read-only
        (ein:html-get-data-in-body-tag "data-read-only")
        :notebook-id
        (ein:html-get-data-in-body-tag "data-notebook-id")))
     :success
     (apply-partially (cl-function
                       (lambda (callback cbargs &key data &allow-other-keys)
                         (apply callback data cbargs)))
                      callback cbargs))))

;;; Buffer and kill hooks
(add-hook 'kill-buffer-query-functions 'ein:notebook-kill-buffer-query)

(defun ein:notebook-close-notebooks (&optional blithely)
  "Used in `ein:jupyter-server-stop' and `kill-emacs-query-functions' hook."
  (ein:aif (ein:notebook-opened-notebooks)
      (if (and (cl-notevery #'identity (mapcar #'ein:notebook-close it))
               (not blithely))
          (y-or-n-p "Some notebooks could not be saved.  Exit anyway?")
        t)
    t))

(add-hook 'kill-emacs-query-functions 'ein:notebook-close-notebooks t)

(defun ein:notebook-kill-buffer-callback ()
  "Call notebook destructor.  This function is called via `kill-buffer-hook'."
  ;; TODO - it remains a bug that neither `ein:notebook-kill-buffer-callback'
  ;; nor `ein:notebook-close' updates ein:notebook--opened-map
  (ein:log 'debug "ein:notebook-kill-buffer-callback called")
  (when (ein:$notebook-p ein:%notebook%)
    (ein:notebook-disable-autosaves ein:%notebook%)
    (ein:notebook-close-worksheet ein:%notebook% ein:%worksheet%)))

(defun ein:notebook-setup-kill-buffer-hook ()
  "Add \"notebook destructor\" to `kill-buffer-hook'."
  (add-hook 'kill-buffer-hook 'ein:notebook-kill-buffer-callback nil t))

(let* ((the-mode (ein:notebook-choose-mode))
       (incompatible-func (lambda ()
                            (when (boundp 'undo-tree-incompatible-major-modes)
                              (nconc undo-tree-incompatible-major-modes
                                     (list the-mode))))))
  (unless (funcall incompatible-func)
    (with-eval-after-load 'undo-tree
      (funcall incompatible-func))))

(provide 'ein-notebook)

;;; ein-notebook.el ends here