(autoload 'flashcard-mode "flashcard" nil t)
(add-to-list 'auto-mode-alist '("\\.deck\\'" . flashcard-mode))

(defun sacha/flashcard-method-leitner-check-answer (card answer)
  "Check answer for correctness. Allow multiple correct answers and provide feedback."
  (flashcard-insert "Answer is:\n"
                    (propertize (flashcard-card-answer card)
                                'face 'flashcard-answer-face
                                'rear-nonsticky t)
                    "\n")
  (cond
   ((string= answer "")
    (y-or-n-p "Was your answer correct? "))
   ((string= answer "x")
    nil)
   (t
    (or (let ((case-fold-search t))
          (string-match answer (flashcard-card-answer card)))
        (y-or-n-p "Was your answer correct? ")))))

(defun sacha/flashcard-method-fortune-feedback (result)
  "Display a fortune on correct answers."
  (require 'fortune)
  (when result
    (with-temp-buffer
      (if (get-buffer fortune-buffer-name)
          (fortune-in-buffer t)
        (fortune)))))

(eval-after-load 'flashcard
  '(progn
     (setq flashcard-method-check-answer-function 'sacha/flashcard-method-leitner-check-answer)
     (add-hook 'flashcard-mode-hook 'flashcard-add-scroll-to-bottom)
     (add-hook 'flashcard-positive-feedback-functions 'flashcard-feedback-highlight-answer)
     (add-hook 'flashcard-positive-feedback-functions 'flashcard-feedback-congratulate)
     (add-hook 'flashcard-positive-feedback-functions 'flashcard-method-leitner-positive-feedback)
     (eval-after-load 'fortune
       '(add-hook 'flashcard-positive-feedback-functions 'sacha/flashcard-method-fortune-feedback))))


(defun sacha/kanji/get-ordered-kanji-list ()
  "Return a list of characters in the buffer."
  (goto-char (point-min))
  (let (kanji-list)                      
    (while (not (eobp))
      (let ((c (char-after (point))))
        (when (>= c ?亜) (add-to-list 'kanji-list c)))
      (forward-char 1))
    kanji-list))

(defun sacha/kanji/to-flashcard-j2e (&optional list)
  "Return a Japanese-English flashcard set.
If LIST is non-nil, use that instead of the current buffer."
  (interactive (list (sacha/kanji/get-ordered-kanji-list)))
  (unless list (setq list (sacha/kanji/get-ordered-kanji-list)))
  (let ((result
         (with-current-buffer (find-file-noselect "/usr/share/edict/kanjidic")
           (mapconcat
            (lambda (kanji)
              (goto-char (point-min))
              (when (re-search-forward (format "^%c.*?{\\(.*\\)}" kanji) nil t)
                (format "%c : %s\n"
                        kanji
                        (replace-regexp-in-string "}\\s-+{" "," (match-string 1)))))
            list
            ""))))
    (if (interactive-p) (kill-new result) result)))

(defun flashcard-import-from-kill (deck) 
  "Import cards for DECK from the clipboard, which should be colon-separated.

Question : Answer"
  (interactive (list flashcard-deck))
  (unless (eq major-mode 'flashcard-mode)
    (error "You're not in a deckfile."))
  (with-temp-buffer
    (yank)
    (goto-char (point-min))
    (while (re-search-forward "^ *\\(.*\\) *: *\\(.*\\)$" nil t)
      (flashcard-add-card deck
                          (flashcard-make-card (match-string 1)
                                               (match-string 2)))))
  (when (and (interactive-p)
             (not flashcard-card))
    (flashcard-ask)))

(defun sacha/kanji/uniquify ()
  "Uniquify based on first field."
  (interactive)
  (goto-char (point-min))
  (let (list)
    (while (not (eobp))
      (when (looking-at "[^:]+")
        (if (member (match-string-no-properties 0) list)
            (delete-region (line-beginning-position) (1+ (line-end-position)))
          (add-to-list 'list (match-string-no-properties 0) list)))
      (forward-line))))

(defun sacha/kanji/lookup-word (word)
  "Return the best definition for WORD."
  (interactive "MWord: ")
  (let ((results (edict-search word edict-buffer))
        result)
    (while results
      (if (string-match (concat "^" word " ")
                        (car results))
          (progn
            (setq result (car results))
            (setq results nil))
        (setq results (cdr results))))
    (if (interactive-p)
        (insert result)
      result)))

(defun sacha/kanji/fix-line ()
  (interactive)
  (goto-char (line-beginning-position))
  (when (looking-at "[^:]+")
    (let ((word (match-string 0)))
      (goto-char (line-end-position))
      (insert " " (sacha/kanji/lookup-word word)))))
  
(setq fortune-file "/usr/share/games/fortunes/computers")

(defun sacha/study-for-mie1407f ()
  (interactive)
  (let ((file (buffer-file-name)))
    (save-buffer)
    (find-file "~/notebook/school/current/mie1407.deck")
    (flashcard-mode)
    (flashcard-import-from-colon-file flashcard-deck file)))