/*
 * laydomino.c: code for performing a domino (2x1 tile) layout of
 * a given area of code.
 */

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>

#include "puzzles.h"

/*
 * This function returns an array size w x h representing a grid:
 * each grid[i] = j, where j is the other end of a 2x1 domino.
 * If w*h is odd, one square will remain referring to itself.
 */

int *domino_layout(int w, int h, random_state *rs)
{
    int *grid, *grid2, *list;
    int wh = w*h;

    /*
     * Allocate space in which to lay the grid out.
     */
    grid = snewn(wh, int);
    grid2 = snewn(wh, int);
    list = snewn(2*wh, int);

    domino_layout_prealloc(w, h, rs, grid, grid2, list);

    sfree(grid2);
    sfree(list);

    return grid;
}

/*
 * As for domino_layout, but with preallocated buffers.
 * grid and grid2 should be size w*h, and list size 2*w*h.
 */
void domino_layout_prealloc(int w, int h, random_state *rs,
                            int *grid, int *grid2, int *list)
{
    int i, j, k, m, wh = w*h, todo, done;

    /*
     * To begin with, set grid[i] = i for all i to indicate
     * that all squares are currently singletons. Later we'll
     * set grid[i] to be the index of the other end of the
     * domino on i.
     */
    for (i = 0; i < wh; i++)
        grid[i] = i;

    /*
     * Now prepare a list of the possible domino locations. There
     * are w*(h-1) possible vertical locations, and (w-1)*h
     * horizontal ones, for a total of 2*wh - h - w.
     *
     * I'm going to denote the vertical domino placement with
     * its top in square i as 2*i, and the horizontal one with
     * its left half in square i as 2*i+1.
     */
    k = 0;
    for (j = 0; j < h-1; j++)
        for (i = 0; i < w; i++)
            list[k++] = 2 * (j*w+i);   /* vertical positions */
    for (j = 0; j < h; j++)
        for (i = 0; i < w-1; i++)
            list[k++] = 2 * (j*w+i) + 1;   /* horizontal positions */
    assert(k == 2*wh - h - w);

    /*
     * Shuffle the list.
     */
    shuffle(list, k, sizeof(*list), rs);

    /*
     * Work down the shuffled list, placing a domino everywhere
     * we can.
     */
    for (i = 0; i < k; i++) {
        int horiz, xy, xy2;

        horiz = list[i] % 2;
        xy = list[i] / 2;
        xy2 = xy + (horiz ? 1 : w);

        if (grid[xy] == xy && grid[xy2] == xy2) {
            /*
             * We can place this domino. Do so.
             */
            grid[xy] = xy2;
            grid[xy2] = xy;
        }
    }

#ifdef GENERATION_DIAGNOSTICS
    printf("generated initial layout\n");
#endif

    /*
     * Now we've placed as many dominoes as we can immediately
     * manage. There will be squares remaining, but they'll be
     * singletons. So loop round and deal with the singletons
     * two by two.
     */
    while (1) {
#ifdef GENERATION_DIAGNOSTICS
        for (j = 0; j < h; j++) {
            for (i = 0; i < w; i++) {
                int xy = j*w+i;
                int v = grid[xy];
                int c = (v == xy+1 ? '[' : v == xy-1 ? ']' :
                         v == xy+w ? 'n' : v == xy-w ? 'U' : '.');
                putchar(c);
            }
            putchar('\n');
        }
        putchar('\n');
#endif

        /*
         * Our strategy is:
         *
         * First find a singleton square.
         *
         * Then breadth-first search out from the starting
         * square. From that square (and any others we reach on
         * the way), examine all four neighbours of the square.
         * If one is an end of a domino, we move to the _other_
         * end of that domino before looking at neighbours
         * again. When we encounter another singleton on this
         * search, stop.
         *
         * This will give us a path of adjacent squares such
         * that all but the two ends are covered in dominoes.
         * So we can now shuffle every domino on the path up by
         * one.
         *
         * (Chessboard colours are mathematically important
         * here: we always end up pairing each singleton with a
         * singleton of the other colour. However, we never
         * have to track this manually, since it's
         * automatically taken care of by the fact that we
         * always make an even number of orthogonal moves.)
         */
        k = 0;
        for (j = 0; j < wh; j++) {
            if (grid[j] == j) {
                k++;
                i = j;          /* start BFS here. */
            }
        }
        if (k == (wh % 2))
            break;              /* if area is even, we have no more singletons;
                                   if area is odd, we have one singleton.
                                   either way, we're done. */

#ifdef GENERATION_DIAGNOSTICS
        printf("starting b.f.s. at singleton %d\n", i);
#endif
        /*
         * Set grid2 to -1 everywhere. It will hold our
         * distance-from-start values, and also our
         * backtracking data, during the b.f.s.
         */
        for (j = 0; j < wh; j++)
            grid2[j] = -1;
        grid2[i] = 0;              /* starting square has distance zero */

        /*
         * Start our to-do list of squares. It'll live in
         * `list'; since the b.f.s can cover every square at
         * most once there is no need for it to be circular.
         * We'll just have two counters tracking the end of the
         * list and the squares we've already dealt with.
         */
        done = 0;
        todo = 1;
        list[0] = i;

        /*
         * Now begin the b.f.s. loop.
         */
        while (done < todo) {
            int d[4], nd, x, y;

            i = list[done++];

#ifdef GENERATION_DIAGNOSTICS
            printf("b.f.s. iteration from %d\n", i);
#endif
            x = i % w;
            y = i / w;
            nd = 0;
            if (x > 0)
                d[nd++] = i - 1;
            if (x+1 < w)
                d[nd++] = i + 1;
            if (y > 0)
                d[nd++] = i - w;
            if (y+1 < h)
                d[nd++] = i + w;
            /*
             * To avoid directional bias, process the
             * neighbours of this square in a random order.
             */
            shuffle(d, nd, sizeof(*d), rs);

            for (j = 0; j < nd; j++) {
                k = d[j];
                if (grid[k] == k) {
#ifdef GENERATION_DIAGNOSTICS
                    printf("found neighbouring singleton %d\n", k);
#endif
                    grid2[k] = i;
                    break;         /* found a target singleton! */
                }

                /*
                 * We're moving through a domino here, so we
                 * have two entries in grid2 to fill with
                 * useful data. In grid[k] - the square
                 * adjacent to where we came from - I'm going
                 * to put the address _of_ the square we came
                 * from. In the other end of the domino - the
                 * square from which we will continue the
                 * search - I'm going to put the distance.
                 */
                m = grid[k];

                if (grid2[m] < 0 || grid2[m] > grid2[i]+1) {
#ifdef GENERATION_DIAGNOSTICS
                    printf("found neighbouring domino %d/%d\n", k, m);
#endif
                    grid2[m] = grid2[i]+1;
                    grid2[k] = i;
                    /*
                     * And since we've now visited a new
                     * domino, add m to the to-do list.
                     */
                    assert(todo < wh);
                    list[todo++] = m;
                }
            }

            if (j < nd) {
                i = k;
#ifdef GENERATION_DIAGNOSTICS
                printf("terminating b.f.s. loop, i = %d\n", i);
#endif
                break;
            }

            i = -1;                /* just in case the loop terminates */
        }

        /*
         * We expect this b.f.s. to have found us a target
         * square.
         */
        assert(i >= 0);

        /*
         * Now we can follow the trail back to our starting
         * singleton, re-laying dominoes as we go.
         */
        while (1) {
            j = grid2[i];
            assert(j >= 0 && j < wh);
            k = grid[j];

            grid[i] = j;
            grid[j] = i;
#ifdef GENERATION_DIAGNOSTICS
            printf("filling in domino %d/%d (next %d)\n", i, j, k);
#endif
            if (j == k)
                break;             /* we've reached the other singleton */
            i = k;
        }
#ifdef GENERATION_DIAGNOSTICS
        printf("fixup path completed\n");
#endif
    }
}

/* vim: set shiftwidth=4 :set textwidth=80: */