/**
* This module defines the notion of a $(LATTICE). A $(LATTICE) is the
* data structure in wich all the $(I cells) are stored. Each generation,
* a $(RULE) changes the cells in the $(LATTICE). The most common example
* of a $(LATTICE) is a infinite square grid. Each square is the $(I cell) and it
* can contain any data such as a number or color. All of the $(I cells) then
* have a x,y coordinates associated with them. But some $(LATTICE)s can have
* other $(I dimensions), like a 3-dimensional grid of cubes where each cube have an
* x,y,z coordinate. Or it can have som other shape, like a grid with hexagons
* instead of squares. The only limitation is that the coordinates must be integers.
*
* This module provides templates for testing whether a given object is a $(LATTICE),
* and what kind of $(LATTICE) it is.
*
* $(CALIB_ABSTRACT_DESC)
*
* Macros:
* IS_ANY = 
*     Tests if something is a $(B $0).
*     $(DDOC_BLANKLINE)
*     returns $(DDOC_BACKQUOTED true) if $(DDOC_BACKQUOTED T) is a $(B $0). of
*     any $(I dimension), Storing any type of cells.
*     $(DDOC_BLANKLINE)
*     This template is the same as $(B is$0) but the $(I dimension) and type
*     of cells need not be specified. Refer to $(B is$0) for more details about
*     what a $(B $0) is.
*     $(DDOC_BLANKLINE)
*     $(DDOC_PARAMS T type to be tested)
*     $(DDOC_RETURNS $(B true) if $(B T) is any $(B $0), $(B false) if not)
*/

module caLib_abstract.lattice;

import std.meta : Repeat;
import caLib_abstract.util : hasCellStateType, hasDimension, hasNeighbourhoodType;
import caLib_abstract.neighbourhood : isNeighbourhood;
import caLib_abstract.neighbourhood : Neighbourhood;



/**
* Tests if something is a $(B Lattice).
*
* returns `true` if `T` is a $(B Lattice) of $(I dimension) `N`, Storing cells of type `Ct`.
*
* A $(B Lattice) is the most basic form of a $(LATTICE). 
* It must define the functions: $(BR)
* `Ct get(string)(Coord)`, `Ct get(Coord)`, $(BR)
* `void set(string)(Coord, Ct)`, `void set(Coord, Ct)`, $(BR)
* `Ct[] getNeighbours(string)(Coord)`, `Ct[] getNeighbours(Coord)`, $(BR)
* `void iterate(string)(ubyte delegate(Ct cellState, Ct[] neighbours, Coord c))`,
* `void iterate(ubyte delegate(Ct cellState, Ct[] neighbours, Coord c))`, $(BR)
* `void nextGen(string)()`, `void nextGen()`, $(BR)
* Where `Coord` is an alias for a typetuple containing `int`'s, one `int` for each
* $(I dimension) (in a 3 dimensional $(B Lattice) `Coord` would be: `(int, int, int)`).
*
* Params:
*     T  = type to be tested
*     Ct = type of the cells the $(B Lattice) should contain
*     N  = number of dimensions
*
* Returns: true if T is a $(B Lattice), false if not
*/
template isLattice(T, Ct, uint N)
{
    alias Coord = Repeat!(N, int);

    static if(hasCellStateType!T && hasDimension!T && hasNeighbourhoodType!T)
    {
        enum isLattice =
            T.Dimension == N &&
            is(T.CellStateType : Ct) &&
            isNeighbourhood!(T.NeighbourhoodType, N) &&
            is(typeof(T.init.get!"_test"(Coord.init)) : Ct) &&
            is(typeof(T.init.get(Coord.init)) : Ct) &&
            is(typeof(T.init.set!"_test"(Coord.init, Ct.init)) : void) &&
            is(typeof(T.init.set(Coord.init, Ct.init)) : void) &&
            is(typeof(T.init.getNeighbours!"_test"(Coord.init)) : Ct[]) &&
            is(typeof(T.init.getNeighbours(Coord.init)) : Ct[]) &&
            is(typeof(T.init.iterate!"_test"((Ct cellState, Ct[] neighbours, Coord c)
                { return Ct.init; })) : void) &&
            is(typeof(T.init.iterate((Ct cellState, Ct[] neighbours, Coord c)
                { return Ct.init; })) : void) &&
            is(typeof(T.init.nextGen!"_test"()) : void) &&
            is(typeof(T.init.nextGen()) : void);   
    }
    else
    {
        enum isLattice = false;
    }
    
}

unittest
{
    static assert( isLattice!(Lattice!(int, 1), int, 1));
    static assert( isLattice!(Lattice!(int, 2), int, 2));
    static assert( isLattice!(Lattice!(int, 3), int, 3));

    static assert(!isLattice!(Lattice!(int, 3), uint, 2));
    static assert(!isLattice!(Lattice!(int, 1), uint, 1));
}



/// $(IS_ANY Lattice)
template isAnyLattice(T)
{
    static if(hasCellStateType!T && hasDimension!T)
        enum isAnyLattice = isLattice!(T, T.CellStateType, T.Dimension);
    else
        enum isAnyLattice = false;
}

unittest
{
    static assert( isAnyLattice!(Lattice!(char, 1)));
    static assert( isAnyLattice!(BoundedLattice!(float, 2)));
    static assert(!isAnyLattice!string);
}



/// Example of a $(B Lattice)
struct Lattice(Ct, uint N, neighbourhood=Neighbourhood!N)
if(isNeighbourhood!(neighbourhood, N))
{
    alias CellStateType = Ct;
    alias NeighbourhoodType = neighbourhood;
    enum uint Dimension = N;

    alias Coord = Repeat!(N, int);

    Ct get(string s)(Coord) { return Ct.init; }
    Ct get(Coord) { return Ct.init; }

    void set(string s)(Coord, Ct) {}
    void set(Coord, Ct) {}

    Ct[] getNeighbours(string s)(Coord) { return new Ct[0]; }
    Ct[] getNeighbours(Coord) { return new Ct[0]; }

    void iterate(string s)(Ct delegate(Ct, Ct[], Coord)) {}
    void iterate(Ct delegate(Ct, Ct[], Coord)) {}

    void nextGen(string s)() {}
    void nextGen() {}
}

///
unittest
{
    static assert(isLattice!(Lattice!(int, 2), int, 2));
    static assert(isAnyLattice!(Lattice!(char, 3)));
}



/**
* Tests if something is a $(B BoundedLattice). 
*
* returns `true` if `T` is a $(B BoundedLattice) of $(I dimension) `N`, Storing cells of type `Ct`.
* False if not.
*
* A $(B BoundedLattice) is a $(LATTICE) with a fixed size. It's function `getLatticeBounds`
* returns a list of `uint`'s representing the length of the $(I lattice's) $(I dimensions)
*
* A $(B BoundedLattice) is a $(B Lattice) with the additional function: `void getLatticeBounds()`.
*
* Params:
*     T  = type to be tested
*     Ct = type of the cells the $(B BoundedLattice) should contain
*     N  = number of dimensions
*
* Returns: true if T is a $(B BoundedLattice), false if not
*/
template isBoundedLattice(T, Ct, uint N)
{
    alias Coord = Repeat!(N, int);

    enum isBoundedLattice =
        isLattice!(T, Ct, N) &&
        is(typeof(T.init.getLatticeBounds()) : int[N]);
}

unittest
{
    static assert( isLattice!(BoundedLattice!(int, 1), int, 1));
    static assert( isLattice!(BoundedLattice!(int, 2), int, 2));
    static assert( isLattice!(BoundedLattice!(int, 3), int, 3));
    static assert( isBoundedLattice!(BoundedLattice!(int, 1), int, 1));
    static assert( isBoundedLattice!(BoundedLattice!(int, 2), int, 2));
    static assert( isBoundedLattice!(BoundedLattice!(int, 3), int, 3));

    static assert(!isBoundedLattice!(BoundedLattice!(int, 3), uint, 2));
    static assert(!isBoundedLattice!(BoundedLattice!(int, 1), uint, 1));
}



///$(IS_ANY BoundedLattice)
template isAnyBoundedLattice(T)
{
    static if(hasCellStateType!T && hasDimension!T)
        enum isAnyBoundedLattice = isBoundedLattice!(T, T.CellStateType, T.Dimension);
    else
        enum isAnyBoundedLattice = false;
}

unittest
{
    static assert(!isAnyBoundedLattice!(Lattice!(char, 1)));
    static assert( isAnyBoundedLattice!(BoundedLattice!(float, 2)));
    static assert(!isAnyBoundedLattice!string);
}



/// Example of a $(B BoundedLattice)
struct BoundedLattice(Ct, uint N)
{
    Lattice!(Ct, N) lattice;
    alias lattice this;

    int[N] getLatticeBounds() {
        // "return int[N]"" makes compiler think
        // "int[N]" is a call to "opIndex"
        int[N] a; return a.init;
    }
}

///
unittest
{
    static assert(isBoundedLattice!(BoundedLattice!(int, 3), int, 3));
    static assert(isAnyLattice!(BoundedLattice!(char, 7)));
}