(defpackage :fwoar.raft
  (:use :cl )
  (:export ))
(in-package :fwoar.raft)

(defun take-keys (h-t &rest keys)
  (mapcar (lambda (key)
            (gethash key h-t))
          keys))

(defclass node ()
  ((%current-term :accessor term :initform 0 :initarg :current-term)
   (%voted-for    :accessor voted-for    :initform nil :initarg :leader-id)
   (%e-log        :accessor e-log
                  :initform (make-array 100 :adjustable t :fill-pointer 0))
   (%client-id    :accessor id)
   (%committed-index :accessor commit-index :initform 0)
   (%last-applied :accessor last-applied :initform 0)))


(defclass leader (node)
  ((%next-index  :accessor next-index  :initform ())
   (%match-index :accessor match-index :initform ())))

(defclass append-entry-arguments ()
  ((%term :initarg :term :reader term)
   (%leader-id :initarg :leader-id :reader leader-id)
   (%prev-log-index :initarg :prev-log-index :reader prev-log-index)
   (%prev-log-term :initarg :prev-log-term :reader prev-log-term)
   (%entries :initarg :entries :reader entries)
   (%leader-commit :initarg :leader-commit :reader leader-commit)))

(defclass entry ()
  ((%term :initarg :term :accessor term)
   (%data :initarg :data :accessor data)))

(defmethod print-object ((o entry) s)
  (print-unreadable-object (o s :type t :identity t)
    (format s "term: ~s data: ~s"
            (term o)
            (data o))))

(defun entry (term data)
  (make-instance 'entry
                 :term term
                 :data data))

(defun add-log-entry (node entry)
  (assert (= (term entry) (term node))
          (entry node)
          "term-mismatch ~s ~s"
          (term entry)
          (term node))
  (vector-push-extend entry (e-log node)))

(defun get-log-entry (follower idx)
  (elt (e-log follower)
       idx))

(defgeneric append-entries (follower args)
  (:method ((follower node) (args append-entry-arguments))
    (with-accessors ((term term)
                     (leader-id leader-id)
                     (prev-log-index prev-log-index)
                     (prev-log-term prev-log-term)
                     (entries entries)
                     (leader-commit leader-commit)) args
      
      (when (< term (term follower))
        (return-from append-entries
          (values term nil)))

      (when (/= (term (get-log-entry follower prev-log-index))
                prev-log-term)
        (return-from append-entries
          (values term nil)))

      #|If an existing entry conflicts with a new one (same index but|#
      #|   different terms), delete the existing entry and all that  |#
      #|   follow it (§5.3)                                          |#

      (loop for new-entries-index from (1+ prev-log-index)
            for (entry . rest-entries) on entries
            for existing-entry in (subseq (e-log follower) (1+ prev-log-index))
            until (/= (term entry)
                      (term existing-entry))
            finally
               (when (< new-entries-index (length (e-log follower)))
                 (setf (fill-pointer (e-log follower)) new-entries-index))

               (map nil
                    (lambda (el)
                      (vector-push-extend el (e-log follower)))
                    rest-entries))

      (when (> leader-commit (commit-index follower))
        (setf (commit-index follower)
              (min leader-commit
                   (1- (length (e-log follower))))))

      (values (term follower)
              t))))