Grid factory

import { constructors, entity } from '../core/library.js';

import { doCreate, isa_number, isa_obj, mergeOver, pushUnique, xt, xta, λnull, Ωempty } from '../helper/utilities.js';

import { releaseCell, requestCell } from '../untracked-factory/cell-fragment.js';

import { releaseCoordinate, requestCoordinate } from '../untracked-factory/coordinate.js';

import baseMix from '../mixin/base.js';
import entityMix from '../mixin/entity.js';

import { _isArray, _isFinite, _parse, BLACK, COLOR, ENTITY, FILL, SOURCE_IN, SOURCE_OVER, T_GRID, WHITE } from '../helper/shared-vars.js';

const _isInteger = Number.isSafeInteger || Number.isInteger,
    CELL_GRADIENT = 'cellGradient',
    GRAY = 'rgb(127 127 127 / 1)',
    GRID_GRADIENT = 'gridGradient',
    GRID_PICTURE = 'gridPicture',
    TILE_PICTURE = 'tilePicture',
    TOP = 'top',
    LEFT = 'left',
    CENTER = 'center',
    BOTTOM = 'bottom',
    RIGHT = 'right',
    HORIZONTAL_POSITIONS = ['left', 'center', 'right'],
    VERTICAL_POSITIONS = ['top', 'center', 'bottom'];

const Grid = function (items = Ωempty) {

    this.tileFill = [];
    this.tileSources = [];

    this.rowLines = null;
    this.columnLines = null;
    this.currentTileWidth = 0;
    this.currentTileHeight = 0;

    this.entityInit(items);

    if (!items.tileSources) {

        this.tileSources = [].concat([{

            type: COLOR,
            source: BLACK,
        },
        {

            type: COLOR,
            source: WHITE,
        }]);
    }

    if (!items.tileFill) {

        this.tileFill.length = this.columns * this.rows;
        this.tileFill.fill(0);
    }
    else if (_isArray(items.tileFill) && this.tileFill.length === items.tileFill.length) {

        this.tileFill = items.tileFill;
    }

    this.tilePaths = [];
    this.tileRealCoordinates = [];
    this.tileVirtualCoordinates = [];

    if (!items.dimensions) {

        if (!items.width) this.currentDimensions[0] = this.dimensions[0] = 20;
        if (!items.height) this.currentDimensions[1] = this.dimensions[1] = 20;
    }

    return this;
};

const P = Grid.prototype = doCreate();
P.type = T_GRID;
P.lib = ENTITY;
P.isArtefact = true;
P.isAsset = false;

baseMix(P);
entityMix(P);

const defaultAttributes = {

    columns: 2,
    rows: 2,

    columnGutterWidth: 1,
    rowGutterWidth: 1,

    tileSources: null,

    tileFill: null,

    gutterColor: GRAY,

    horizontalPivotPosition: LEFT,

    verticalPivotPosition: TOP,
};
P.defs = mergeOver(P.defs, defaultAttributes);

P.packetExclusions = pushUnique(P.packetExclusions, ['tileSources']);

P.finalizePacketOut = function (copy, items) {

    const cSources = copy.tileSources = [],
        tSources = this.tileSources;

    tSources.forEach(item => {

        cSources.push({
            type: item.type,
            source: (isa_obj(item.source)) ? item.source.name : item.source
        });
    });

    if (isa_obj(copy.gutterColor)) copy.gutterColor = copy.gutterColor.name;

    const stateCopy = _parse(this.state.saveAsPacket(items))[3];
    copy = mergeOver(copy, stateCopy);

    copy = this.handlePacketAnchor(copy, items);

    return copy;
};

const S = P.setters,
    D = P.deltaSetters;

S.columns = function (item) {

    if (isa_number(item)) {

        if (!_isInteger(item)) item = parseInt(item, 10);

        if (item !== this.columns) {

            let i, iz, j;

            const currentFill = this.tileFill,
                currentCols = this.columns,
                newFill = [];

            this.columns = item;

            for (i = 0, iz = this.rows; i < iz; i++) {

                for (j = 0; j < item; j++) {

                    if (j < currentCols) newFill.push(currentFill[(i * currentCols) + j]);
                    else newFill.push(0);
                }
            }
            this.tileFill = newFill;
        }
    }
    this.dirtyPathObject = true;
    this.dirtyFilterIdentifier = true;
};
D.columns = λnull;

S.rows = function (item) {

    if (isa_number(item)) {

        if (!_isInteger(item)) item = parseInt(item, 10);

        if (item !== this.rows) {

            const currentRows = this.rows;

            this.rows = item;

            this.tileFill.length = this.columns * item;

            if (currentRows < item) this.tileFill.fill(0, currentRows * this.columns);
        }
    }
    this.dirtyPathObject = true;
    this.dirtyFilterIdentifier = true;
};
D.rows = λnull;

S.horizontalPivotPosition = function (item) {

    if (item.substring) {

        item = item.toLowerCase();

        if (HORIZONTAL_POSITIONS.includes(item)) this.horizontalPivotPosition = item;
    }
};

S.verticalPivotPosition = function (item) {

    if (item.substring) {

        item = item.toLowerCase();

        if (VERTICAL_POSITIONS.includes(item)) this.verticalPivotPosition = item;
    }
};

P.setAllTilesTo = function (val) {

    if (isa_number(val)) {

        if (!_isInteger(val)) val = parseInt(val, 10);

        this.tileFill.fill(val);
        this.dirtyFilterIdentifier = true;
    }
    return this;
};

P.setTileFill = function (item) {

    const { columns, rows } = this;

    if (_isArray(item) && item.length === columns * rows) {

        this.tileFill = item;
        this.dirtyFilterIdentifier = true;
    }
    return this;
};

P.setTilesTo = function (tiles, val) {

    const tileFill = this.tileFill;

    if (xt(tiles) && isa_number(val)) {

        if (!_isInteger(val)) val = parseInt(val, 10);

        if (isa_number(tiles)) tileFill[tiles] = val;
        else if (_isArray(tiles)) {

            tiles.forEach(tile => {

                if (isa_number(tile)) tileFill[tile] = val;
            });
        }
        this.dirtyFilterIdentifier = true;
    }
    return this;
};

P.setTileSourceTo = function (index, obj) {

    if (isa_number(index) && isa_obj(obj)) {

        if (obj.type && obj.source) this.tileSources[index] = obj;
    }
    return this;
};

P.removeTileSource = function (index) {

    if (_isFinite(index)) {

        this.tileSources[index] = null;

        this.tileFill = this.tileFill.map(item => item === index ? 0 : item);
    }
    return this;
};

P.getTileSource = function (row, col) {

    if (isa_number(row)) {

        if (!isa_number(col)) return this.tileFill[row];
        else return this.tileFill[(row * this.columns) + col];
    }
};

P.getTilesUsingSource = function (key) {

    const res = [];

    if (isa_number(key)) this.tileFill.forEach((val, index) => val === key && res.push(index));

    return res;
};

P.tileIndexFromPosition = function (row, col) {

    if (_isFinite(row) && _isFinite(col) && row >= 0 && col >= 0) {

        const rows = this.rows,
            cols = this.columns;

        row = (row | 0);
        col = (col | 0);

        if (row < rows && col < cols) return (row * cols) + col;
    }

    return -1;
};

P.positionIndices = function (index) {

    if (_isFinite(index) && index >= 0) {

        const rows = this.rows,
            cols = this.columns;

        index = (index | 0);

        if (cols > 0 && index < rows * cols) return [~~(index / cols), index % cols];
    }

    return [];
};

P.rowIndex = function (index) {

    if (_isFinite(index) && index >= 0) {

        const rows = this.rows,
            cols = this.columns;

        index = (index | 0);

        if (cols > 0 && index < rows * cols) return ~~(index / cols);
    }

    return -1;
};

P.columnIndex = function (index) {

    if (_isFinite(index) && index >= 0) {

        const rows = this.rows,
            cols = this.columns;

        index = (index | 0);

        if (cols > 0 && index < rows * cols) return index % cols;
    }

    return -1;
};

P.fillRow = function (items = Ωempty) {

    let { row, index } = items;

    if (_isFinite(row) && _isFinite(index) && row >= 0 && index >= 0) {

        const cols = this.columns,
            rows = this.rows;

        row = (row | 0);
        index = (index | 0);

        if (cols > 0 && rows > 0 && row < rows) {

            const start = row * cols,
                fill = this.tileFill;

            for (let c = 0; c < cols; c++) {

                fill[start + c] = index;
            }

            this.dirtyFilterIdentifier = true;
        }
    }
    return this;
};

P.fillColumn = function (items = Ωempty) {

    let { column, index } = items;

    if (_isFinite(column) && _isFinite(index) && column >= 0 && index >= 0) {

        const cols = this.columns,
            rows = this.rows;

        column = (column | 0);
        index = (index | 0);

        if (cols > 0 && rows > 0 && column < cols) {

            const fill = this.tileFill;

            for (let r = 0; r < rows; r++) {

                fill[(r * cols) + column] = index;
            }

            this.dirtyFilterIdentifier = true;
        }
    }
    return this;
};

P.fillRect = function (items = Ωempty) {

    let { rowStart, columnStart, rowEnd, columnEnd, index } = items;

    if (_isFinite(rowStart) && _isFinite(rowEnd) && _isFinite(columnStart) && _isFinite(columnEnd) && _isFinite(index)) {

        rowStart = (rowStart | 0);
        rowEnd = (rowEnd | 0);
        columnStart = (columnStart | 0);
        columnEnd = (columnEnd | 0);
        index = (index | 0);

        if (rowStart > rowEnd) [rowStart, rowEnd] = [rowEnd, rowStart];
        if (columnStart > columnEnd) [columnStart, columnEnd] = [columnEnd, columnStart];

        const cols = this.columns,
            rows = this.rows;

        if (
            rowStart >= 0 && rowStart < rows &&
            rowEnd >= 0 && rowEnd < rows &&
            columnStart >= 0 && columnStart < cols &&
            columnEnd >= 0 && columnEnd < cols &&
            index >= 0
        ) {

            const fill = this.tileFill;

            let r, c, base;

            for (r = rowStart; r <= rowEnd; r++) {

                base = r * cols;

                for (c = columnStart; c <= columnEnd; c++) {

                    fill[base + c] = index;
                }
            }

            this.dirtyFilterIdentifier = true;
        }
    }
    return this;
};

P.cleanPathObject = function () {

    this.dirtyPathObject = false;

    if (!this.noPathUpdates || !this.pathObject) {

        const p = this.pathObject = new Path2D(),
            rowLines = new Path2D(),
            colLines = new Path2D();

        const handle = this.currentStampHandlePosition,
            scale = this.currentScale,
            dims = this.currentDimensions;

        const x = -handle[0] * scale,
            y = -handle[1] * scale,
            w = dims[0] * scale,
            h = dims[1] * scale;

        p.rect(x, y, w, h);

        const cols = this.columns,
            rows = this.rows,
            colWidth = w / cols,
            rowHeight = h / rows,
            paths = this.tilePaths,
            real = this.tileRealCoordinates,
            virtual = this.tileVirtualCoordinates;

        let i, j, cx, cy;

        rowLines.moveTo(x, y);
        rowLines.lineTo(x + w, y);

        for (i = 1; i <= rows; i++) {

            const ry = y + (i * rowHeight);

            rowLines.moveTo(x, ry);
            rowLines.lineTo(x + w, ry);
        }
        this.rowLines = rowLines;

        colLines.moveTo(x, y);
        colLines.lineTo(x, y + h);

        for (j = 1; j <= cols; j++) {

            cx = x + (j * colWidth);

            colLines.moveTo(cx, y);
            colLines.lineTo(cx, y + h);
        }
        this.columnLines = colLines;

        paths.length = 0;
        real.length = 0;
        virtual.length = 0;

        for (i = 0; i < rows; i++) {

            for (j = 0; j < cols; j++) {

                const path = new Path2D();

                cx = j * colWidth;
                cy = i * rowHeight;

                path.rect(x + cx, y + cy, colWidth, rowHeight);
                paths.push(path);

                virtual.push([cx, cy]);
                real.push([x + cx, y + cy]);
            }
        }

        this.currentTileWidth = colWidth;
        this.currentTileHeight = rowHeight;
    }
};

P.getTilePivotCoordsAt = function (index) {

    if (_isFinite(index) && index >= 0) {

        const tiles = this.tileRealCoordinates;

        if (index < tiles.length) {

            const start = this.currentStampPosition,
                offset = [...tiles[index]],
                angle = this.currentRotation,
                horizontalPivotPosition = this.horizontalPivotPosition,
                verticalPivotPosition = this.verticalPivotPosition,
                width = this.currentTileWidth,
                height = this.currentTileHeight;

            if (horizontalPivotPosition === RIGHT) offset[0] += width;
            else if (horizontalPivotPosition === CENTER) offset[0] += width / 2;

            if (verticalPivotPosition === BOTTOM) offset[1] += height;
            else if (verticalPivotPosition === CENTER) offset[1] += height / 2;

            if (this.flipReverse) offset[0] = -offset[0];
            if (this.flipUpend) offset[1] = -offset[1];

            const coord = requestCoordinate();
            coord.setFromArray(offset).rotate(angle).add(start);

            const res = [...coord];

            releaseCoordinate(coord);

            return res;
        }
    }

    return [...this.currentStampPosition];
};

P.performFill = function (engine) {

    const currentScale = this.currentScale || 0;

    if (currentScale > 0) {

        engine.save();

        const composer = requestCell(),
            compEngine = composer.engine,
            compCanvas = composer.element;

        const tileSources = this.tileSources,
            tileFill = this.tileFill,
            tilePaths = this.tilePaths,
            tileRealCoords = this.tileRealCoordinates,
            tileVirtualCoords = this.tileVirtualCoordinates,
            winding = this.winding,
            tileWidth = this.currentTileWidth,
            tileHeight = this.currentTileHeight;

        const dims = this.currentDimensions;

        let currentPicture;

        tileSources.forEach((obj, index) => {

            if (obj && obj.type) {

                switch (obj.type) {

                    case COLOR :

                        engine.fillStyle = obj.source;
                        break;

                    case CELL_GRADIENT :

                        this.lockFillStyleToEntity = false;
                        engine.fillStyle = obj.source.getData(this, this.currentHost);
                        break;

                    case GRID_GRADIENT :

                        this.lockFillStyleToEntity = true;
                        engine.fillStyle = obj.source.getData(this, this.currentHost);
                        break;
                }
            }

            const validTiles = tileFill.map(item => item === index ? true : false);

            if (validTiles.length) {

                switch (obj.type) {

                    case GRID_PICTURE :

                        currentPicture = (obj.source.substring) ? entity[obj.source] : obj.source;

                        if (currentPicture.simpleStamp) {

                            compCanvas.width = dims[0] * currentScale;
                            compCanvas.height = dims[1] * currentScale;
                            compEngine.globalCompositeOperation = SOURCE_OVER;
                            compEngine.fillStyle = BLACK;

                            validTiles.forEach((tile, pos) => {

                                if (tile) compEngine.fillRect(tileVirtualCoords[pos][0], tileVirtualCoords[pos][1], tileWidth, tileHeight);
                            });

                            compEngine.globalCompositeOperation = SOURCE_IN;

                            currentPicture.simpleStamp(composer, {
                                startX: 0,
                                startY: 0,
                                width: dims[0] * currentScale,
                                height: dims[1] * currentScale,
                                method: FILL,
                            });

                            engine.drawImage(compCanvas, ~~tileRealCoords[0][0], ~~tileRealCoords[0][1]);
                        }
                        break;

                    case TILE_PICTURE :

                        currentPicture = (obj.source.substring) ? entity[obj.source] : obj.source;

                        if (currentPicture.simpleStamp) {

                            compCanvas.width = tileWidth;
                            compCanvas.height = tileHeight;
                            compEngine.globalCompositeOperation = SOURCE_OVER;

                            currentPicture.simpleStamp(composer, {
                                startX: 0,
                                startY: 0,
                                width: tileWidth,
                                height: tileHeight,
                                method: FILL,
                            });

                            validTiles.forEach((tile, pos) => tile && engine.drawImage(compCanvas, ~~tileRealCoords[pos][0], ~~tileRealCoords[pos][1]));
                        }
                        break;

                    default :

                        validTiles.forEach((tile, pos) => tile && engine.fill(tilePaths[pos], winding));
                }
            }
        });

        const gColor = this.gutterColor,
            gRow = this.rowGutterWidth,
            gCol = this.columnGutterWidth;

        let gObject;

        if(xt(gColor)) {

            if (gColor.substring) {

                gObject = {
                    type: COLOR,
                    source: this.gutterColor
                };
            }
            else if (isa_obj(gColor)) gObject = gColor;
            else if (isa_number(gColor) && isa_obj(tileSources[gColor])) gObject = tileSources[gColor];

            switch (gObject.type) {

                case CELL_GRADIENT :

                    this.lockFillStyleToEntity = false;
                    engine.strokeStyle = gObject.source.getData(this, this.currentHost);
                    break;

                case GRID_GRADIENT :

                    this.lockFillStyleToEntity = true;
                    engine.strokeStyle = gObject.source.getData(this, this.currentHost);
                    break;

                case COLOR :

                    engine.strokeStyle = gObject.source;
                    break;
            }

            switch (gObject.type) {

                case GRID_PICTURE :
                case TILE_PICTURE :

                    if(gRow || gCol) {

                        currentPicture = (gObject.source.substring) ? entity[gObject.source] : gObject.source;

                        if (currentPicture.simpleStamp) {

                            const handle = this.currentStampHandlePosition,
                                x = handle[0] * currentScale,
                                y = handle[1] * currentScale;

                            compCanvas.width = dims[0] * currentScale;
                            compCanvas.height = dims[1] * currentScale;
                            compEngine.globalCompositeOperation = SOURCE_OVER;
                            compEngine.strokeStyle = BLACK;
                            compEngine.translate(x, y);

                            if (gRow) {

                                compEngine.lineWidth = gRow;
                                compEngine.stroke(this.rowLines);
                            }

                            if (gCol) {

                                compEngine.lineWidth = gCol;
                                compEngine.stroke(this.columnLines);
                            }

                            compEngine.globalCompositeOperation = SOURCE_IN;

                            currentPicture.simpleStamp(composer, {
                                startX: 0,
                                startY: 0,
                                width: dims[0] * currentScale,
                                height: dims[1] * currentScale,
                                method: FILL,
                            });

                            engine.drawImage(compCanvas, ~~tileRealCoords[0][0], ~~tileRealCoords[0][1]);
                            compEngine.translate(0, 0);
                        }
                    }
                    break;

                default :

                    if (gRow) {

                        engine.lineWidth = gRow;
                        engine.stroke(this.rowLines);
                    }

                    if (gCol) {

                        engine.lineWidth = gCol;
                        engine.stroke(this.columnLines);
                    }
            }
        }

        releaseCell(composer);

        engine.restore();
    }
};

P.fill = function (engine) {

    this.performFill(engine);
};

P.drawAndFill = function (engine) {

    const p = this.pathObject;

    engine.stroke(p);
    this.currentHost.clearShadow();
    this.performFill(engine);
};

P.fillAndDraw = function (engine) {

    const p = this.pathObject;

    engine.stroke(p);
    this.currentHost.clearShadow();
    this.performFill(engine);
    engine.stroke(p);
};

P.drawThenFill = function (engine) {

    const p = this.pathObject;

    engine.stroke(p);
    this.performFill(engine);
};

P.fillThenDraw = function (engine) {

    const p = this.pathObject;

    this.performFill(engine);
    engine.stroke(p);
};

P.checkHit = function (items = []) {

    if (this.noUserInteraction) return false;

    if (!this.pathObject || this.dirtyPathObject) {

        this.cleanPathObject();
    }

    const tests = (!_isArray(items)) ?  [items] : items;

    const mycell = requestCell(),
        engine = mycell.engine,
        stamp = this.currentStampPosition,
        x = stamp[0],
        y = stamp[1],
        tiles = new Set(),
        tilePaths = this.tilePaths;

    let isGood, tx, ty;

    const getCoords = (coords) => {

        let x, y;

        if (_isArray(coords)) {

            x = coords[0];
            y = coords[1];
        }
        else if (xta(coords, coords.x, coords.y)) {

            x = coords.x;
            y = coords.y;
        }
        else return [false];

        if (!_isFinite(x) || !_isFinite(y)) return [false];

        return [true, x, y];
    }

    mycell.rotateDestination(engine, x, y, this);

    if (tests.some(test => {

        [isGood, tx, ty] = getCoords(test);

        if (!isGood) return false;
        else return engine.isPointInPath(this.pathObject, tx, ty, this.winding);

    }, this)) {

        tests.forEach(test => {

            [isGood, tx, ty] = getCoords(test);

            if (isGood) {

                tilePaths.some((path, index) => {

                    if (engine.isPointInPath(path, tx, ty, this.winding)) {

                        tiles.add(index);
                        return true;
                    }
                    return false;
                })
            }
        });

        releaseCell(mycell);

        return {
            x: tx,
            y: ty,
            tiles: [...tiles],
            artefact: this
        };
    }

    releaseCell(mycell);
    return false;
};

export const makeGrid = function (items) {

    if (!items) return false;
    return new Grid(items);
};

constructors.Grid = Grid;