;; primitiver för spelplan

(defun skapa-spelplan (hojd bredd)
  (setq ligist
	(make-array `(,hojd ,bredd) :initial-element 0)))

(defun markera-som-svart (rad kolumn)
  (setf (aref ligist rad kolumn) 1))

(defun markera-som-vit (rad kolumn)
  (setf (aref ligist rad kolumn) 2))

(defun plocka-ut-rad (rad-nr)
  (setq res-array (make-array (second (array-dimensions ligist))))
  (dotimes (var (second (array-dimensions ligist)) res-array)
    (setf (aref res-array var) (aref ligist rad-nr var))))

(defun plocka-ut-kolumn (kol-nr)
  (setq res-array (make-array (first (array-dimensions ligist))))
  (dotimes (var (first (array-dimensions ligist)) res-array)
    (setf (aref res-array var) (aref ligist var kol-nr))))


;; primitiver till rad

;;(defun mojlig-placering? (vektor langd plats)
;;  (cond ((zerop langd) t)
;;	((= (aref vektor plats) 2) nil)
;;	(t (mojlig-placering? vektor (1- langd) (1+ plats)))))

(defun mojlig-placering? (vektor langd plats)
  (if (or (> (+ langd plats) (first (array-dimensions vektor)))
	  (and (plusp plats)
	       (= 1 (aref vektor (1- plats))))
	  (and (< (+ langd plats) (first (array-dimensions vektor)))
	       (= 1 (aref vektor (+ langd plats)))))
      nil
    (labels ((mojlig-int
	      (vektor langd plats)
	      (cond ((zerop langd) t)
		    ((= 2 (aref vektor plats)) nil)
		    (t (mojlig-int vektor (1- langd) (1+ plats))))))
      (mojlig-int vektor langd plats))))


(defun overlappar? (block1 block2)
  (>= (+ (first block1) (second block1))
      (first block2)))

;;(defun grundplacering (vektor inrad)
;;  (let ((start 0)
;;	(res '()))
;;   (dotimes (var (length inrad) res)
;;      (let ((plats (forsta-plats
;;		    vektor
;;		    (nth var inrad)
;;		    start
;;		    (first (array-dimensions vektor))))
;;	    (langd (nth var inrad)))
;;	(setq res (append res (list (list plats langd))))
;;	(setq start (+ plats langd 1))))))

(defun forsta-plats (vektor langd start slut)
  (cond ((mojlig-placering? vektor langd start)
	 start)
	((>= (+ start langd)
	     slut)
	 nil)
	(t (forsta-plats vektor langd (1+ start) slut))))

(defun nasta-placering (vektor rad block-nr)
  (if (zerop block-nr) (- 1)
    (let ((nasta-plats (forsta-plats
			vektor
			(second (nth block-nr rad))
			(1+ (first (nth block-nr rad)))
			(if (endp (nth (1+ block-nr) rad))
			    (first (array-dimensions vektor))
			  (first (1- (nth (1+ block-nr) rad)))))))
      (cond ((endp nasta-plats)
	     (nasta-placering vektor rad (1- block-nr)))
	    (t (nollstall-efter (flytta-till rad block-nr nasta-plats) block-nr))))))

(defun next-placering (vektor rad &optional (block-nr (1- (length rad))))
  (if (zerop block-nr) nil
    (let ((nasta-plats (forsta-plats
			vektor
			(second (nth block-nr rad))
			(1+ (first (nth block-nr rad)))
			(if (endp (nth (1+ block-nr) rad))
			    (first (array-dimensions vektor))
			  (first (nth (1+ block-nr) rad))))))
      (if (minusp nasta-plats)
	  (next-placering vektor rad (1- block-nr))
	(let ((fonkar (nollstall-efter
		       vektor
		       (flytta-till rad block-nr nasta-plats)
		       block-nr)))
	  (cond ((endp fonkar)
		 (next-placering vektor rad (1- block-nr)))
		(t 
	     

      (cond ((minusp nasta-plats)
	     (next-placering vektor rad (1- block-nr)))
	    (t (flytta-till rad block-nr nasta-plats))))))

;(defun nollstall-efter (rad nr)
;  (cond ((zerop nr)
;	 (nollstall-efter (rest rad) (1- nr)))
;	(
  
(defun flytta-till (rad block-nr nasta-plats)
  (cond ((endp rad) nil)
	((zerop block-nr)
	 (cons (list nasta-plats (second (first rad)))
	       (rest rad)))
	(t (cons (first rad)
		 (flytta-till (rest rad) (1- block-nr) nasta-plats)))))