Mesh factory

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

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

import { currentCorePosition } from '../core/user-interaction.js';

import { makeState } from '../untracked-factory/state.js';

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

import { releaseArray, requestArray } from '../helper/array-pool.js';

import { currentGroup } from './canvas.js';

import baseMix from '../mixin/base.js';
import deltaMix from '../mixin/delta.js';
import hiddenElementsMix from '../mixin/hidden-dom-elements.js';
import anchorMix from '../mixin/anchor.js';
import buttonMix from '../mixin/button.js';

import { _atan2, _ceil, _isArray, _isFinite, _keys, _max, _min, _parse, _piHalf, _sqrt, ARG_SPLITTER, DESTINATION_OUT, ENTITY, FILL, NAME, STATE_KEYS, T_CELL, T_GROUP, T_NET, T_PICTURE, UNDEF, ZERO_STR } from '../helper/shared-vars.js';

const T_MESH = 'Mesh';

const Mesh = function (items = Ωempty) {

    this.makeName(items.name);
    this.register();

    this.modifyConstructorInputForAnchorButton(items);

    this.set(this.defs);

    this.state = makeState();

    if (!items.group) items.group = currentGroup;

    this.onEnter = λnull;
    this.onLeave = λnull;
    this.onDown = λnull;
    this.onUp = λnull;

    this.delta = {};

    this.currentHost = null;
    this.dirtyHost = true;
    this.badNet = true;
    this.dirtyParticles = true;
    this.particlePositions = null;
    this.sourceImageData = null;
    this.sourceDimension = 0;
    this.rows = null;
    this.columns = null;
    this.struts = null;
    this.boundingBox = null;
    this.pathObject = null;
    this.dirtyOutput = true;
    this.dirtyTargetImage = true;
    this.output = null;

    this.set(items);

    this.fromPathData = [];
    this.toPathData = [];

    this.watchFromPath = null;
    this.watchIndex = -1;
    this.engineInstructions = [];
    this.engineDeltaLengths = [];

    return this;
};

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

baseMix(P);
deltaMix(P);
hiddenElementsMix(P);
anchorMix(P);
buttonMix(P);

const defaultAttributes = {

    net: null,

    isHorizontalCopy: true,

    source: null,

    sourceIsVideoOrSprite: false,

    interferenceLoops: 2,
    interferenceFactor: 1.03,

    visibility: true,
    calculateOrder: 0,
    stampOrder: 0,
    delta: null,
    host: null,
    group: null,
    anchor: null,

    noCanvasEngineUpdates: false,

    noDeltaUpdates: false,

    onEnter: null,
    onLeave: null,
    onDown: null,
    onUp: null,

    noUserInteraction: false,

    method: FILL,

};
P.defs = mergeOver(P.defs, defaultAttributes);

P.packetExclusions = pushUnique(P.packetExclusions, ['pathObject', 'state']);
P.packetExclusionsByRegex = pushUnique(P.packetExclusionsByRegex, ['^(local|dirty|current)', 'Subscriber$']);
P.packetObjects = pushUnique(P.packetObjects, ['group', 'net', 'source']);
P.packetFunctions = pushUnique(P.packetFunctions, ['onEnter', 'onLeave', 'onDown', 'onUp']);

P.processPacketOut = function (key, value, incl) {

    let result = true;

    if(!incl.includes(key) && value === this.defs[key]) result = false;

    return result;
};

P.finalizePacketOut = function (copy, items) {

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

    copy = this.handlePacketAnchor(copy, items);

    return copy;
};

P.handlePacketAnchor = function (copy, items) {

    if (this.anchor) {

        const a = _parse(this.anchor.saveAsPacket(items))[3];
        copy.anchor = a;
    }
    return copy;
}

P.clone = λcloneError;

const G = P.getters,
    S = P.setters;

P.get = function (item) {

    const getter = this.getters[item];

    if (getter) return getter.call(this);

    else {

        const state = this.state;

        let def = this.defs[item],
            val;

        if (typeof def !== UNDEF) {

            val = this[item];
            return (typeof val !== UNDEF) ? val : def;
        }

        def = state.defs[item];

        if (typeof def !== UNDEF) {

            val = state[item];
            return (typeof val !== UNDEF) ? val : def;
        }
        return null;
    }
};

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

    const keys = _keys(items),
        keysLen = keys.length;

    if (keysLen) {

        const setters = this.setters,
            defs = this.defs,
            state = this.state;

        const stateSetters = (state) ? state.setters : Ωempty;
        const stateDefs = (state) ? state.defs : Ωempty;

        let fn, i, key, value;

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

            key = keys[i];
            value = items[key];

            if (key && key !== NAME && value != null) {

                if (!STATE_KEYS.includes(key)) {

                    fn = setters[key];

                    if (fn) fn.call(this, value);
                    else if (typeof defs[key] !== UNDEF) {

                        this[key] = value;
                        this.dirtyFilterIdentifier = true;
                    }
                }
                else {

                    fn = stateSetters[key];

                    if (fn) fn.call(state, value);
                    else if (typeof stateDefs[key] !== UNDEF) state[key] = value;
                }
            }
        }
    }
    return this;
};

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

    const keys = _keys(items),
        keysLen = keys.length;

    if (keysLen) {

        const setters = this.deltaSetters,
            defs = this.defs,
            state = this.state;

        const stateSetters = (state) ? state.deltaSetters : Ωempty;
        const stateDefs = (state) ? state.defs : Ωempty;

        let fn, i, key, value;

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

            key = keys[i];
            value = items[key];

            if (key && key != NAME && value != null) {

                if (!STATE_KEYS.includes(key)) {

                    fn = setters[key];

                    if (fn) fn.call(this, value);
                    else if (typeof defs[key] != UNDEF) {

                        this[key] = addStrings(this[key], value);
                        this.dirtyFilterIdentifier = true;
                    }
                }
                else {

                    fn = stateSetters[key];

                    if (fn) fn.call(state, value);
                    else if (typeof stateDefs[key] != UNDEF) state[key] = addStrings(state[key], value);
                }
            }
        }
    }
    return this;
};

S.host = function (item) {

    if (item) {

        const host = artefact[item];

        if (host && host.here) this.host = host.name;
        else this.host = item;
    }
    else this.host = ZERO_STR;
    this.dirtyFilterIdentifier = true;
};

G.group = function () {

    return (this.group) ? this.group.name : ZERO_STR;
};
S.group = function (item) {

    let g;

    if (item) {

        if (this.group && this.group.type === T_GROUP) this.group.removeArtefacts(this.name);

        if (item.substring) {

            g = group[item];

            if (g) this.group = g;
            else this.group = item;
        }
        else this.group = item;
    }

    if (this.group && this.group.type === T_GROUP) this.group.addArtefacts(this.name);
};

P.getHere = function () {

    return currentCorePosition;
};

S.net = function (item) {

    if (item) {

        item = (item.substring) ? artefact[item] : item;

        if (item && item.type === T_NET) {

            this.net = item;
            this.dirtyStart = true;
        }
        this.dirtyFilterIdentifier = true;
    }
};

S.source = function (item) {

    item = (item.substring) ? artefact[item] : item;

    if (item && item.type === T_PICTURE) {

        const src = this.source;

        if (src && src.type === T_PICTURE) src.imageUnsubscribe(this.name);

        this.source = item;
        item.imageSubscribe(this.name);
        this.dirtyInput = true;
        this.dirtyFilterIdentifier = true;
    }
};

S.isHorizontalCopy = function (item) {

    this.isHorizontalCopy = (item) ? true : false;
    this.dirtyPathData = true;
    this.dirtyFilterIdentifier = true;
};

P.getHost = function () {

    if (this.currentHost) return this.currentHost;
    else if (this.host) {

        const host = artefact[this.host];

        if (host) {

            this.currentHost = host;
            this.dirtyHost = true;
            return this.currentHost;
        }
    }
    return currentCorePosition;
};

P.midInitActions = λnull;

P.prepareStamp = function() {

    this.badNet = true;
    this.dirtyParticles = false;

    if (!this.particlePositions) this.particlePositions = [];

    const {net, particlePositions} = this;

    if (net && net.particleStore && net.particleStore.length > 3) {

        const {rows, columns, particleStore} = net;

        if (rows && columns) {

            this.badNet = false;
            this.rows = rows;
            this.columns = columns;

            const checkPositions = [];

            particleStore.forEach(p => {

                const pos = p.position;
                const {x, y} = pos;

                checkPositions.push([x, y]);
            });
            const checkPositionsString = checkPositions.join(ARG_SPLITTER),
                particlePositionsString = particlePositions.join(ARG_SPLITTER);

            if (particlePositionsString !== checkPositionsString) {

                this.particlePositions = checkPositions;
                this.dirtyInput = true;
            }

            if (this.sourceIsVideoOrSprite) this.dirtyInput = true;
        }
    }

    this.prepareStampTabsHelper();
};

P.setSourceDimension = function () {

    if (!this.badNet) {

        const {columns, rows, particlePositions} = this;

        const results = requestArray(),
            lengths = requestArray(),
            xPos = requestArray(),
            yPos = requestArray(),
            top = requestArray(),
            left = requestArray(),
            right = requestArray(),
            coords = requestArray(),
            bottom = requestArray();

        let x, xz, y, res, pos, coord, x0, x1, y0, y1, dx, dy, len, l, i, iz, j, jz;

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

            res = 0;
            len = lengths[y] = requestArray();
            coord = coords[y] = [];

            for (x = 0, xz = columns - 1; x < xz; x++) {

                pos = (y * columns) + x;

                [x0, y0] = particlePositions[pos];
                [x1, y1] = particlePositions[pos + 1];

                coord.push([x0, y0, x1, y1]);

                if (x === 0) {

                    left.push([x0, y0]);
                }
                else if (x === xz - 1) {

                    right.push([x1, y1]);
                }
                else if (y === 0) {

                    top.push([x0, y0]);

                    if (x === xz - 2) top.push([x1, y1]);
                }
                else if (y === rows - 1) {

                    bottom.push([x0, y0]);

                    if (x === xz - 2) bottom.push([x1, y1]);
                }

                xPos.push(x0, x1);
                yPos.push(y0, y1);

                dx = x1 - x0;
                dy = y1 - y0;

                l = _sqrt((dx * dx) + (dy * dy));
                res += l;
                len.push(l);
            }
            results.push(res);
        }
        this.sourceDimension = _max(...results);

        const host = this.currentHost || this.getHost();
        if (host) {

            const max = _max(...host.currentDimensions);
            if (this.sourceDimension > max) this.sourceDimension = max;
        }

        for (i = 0, iz = lengths.length; i < iz; i++) {

            l = results[i];
            len = lengths[i];
            coord = coords[i];

            for (j = 0, jz = len.length; j < jz; j++) {

                if (l) len[j] = len[j] / l;

                coord[j].push(len[j]);
            }
        }

        if (!this.struts) this.struts = [];
        this.struts.length = 0;
        this.struts.push(...coords);

        const xMin = _min(...xPos),
            yMin = _min(...yPos),
            xMax = _max(...xPos),
            yMax = _max(...yPos);

        this.boundingBox = [xMin, yMin, xMax - xMin, yMax - yMin];

        left.reverse();
        bottom.reverse();

        let p = `M${top[0][0]},${top[0][1]}L`;

        for (i = 1, iz = top.length; i < iz; i++) {

            [x, y] = top[i];
            p += `${x},${y} `;
        }
        for (i = 0, iz = right.length; i < iz; i++) {

            [x, y] = right[i];
            p += `${x},${y} `;
        }
        for (i = 0, iz = bottom.length; i < iz; i++) {

            [x, y] = bottom[i];
            p += `${x},${y} `;
        }
        for (i = 0, iz = left.length; i < iz; i++) {

            [x, y] = left[i];
            p += `${x},${y} `;
        }
        p += 'z';

        this.pathObject = new Path2D(p);

        releaseArray(...lengths, lengths);
        releaseArray(results, xPos, yPos, top, left, right, bottom, coords);
    }
};

P.simpleStamp = function (host, changes) {

    if (host && host.type === T_CELL) {

        this.currentHost = host;

        if (changes) {

            this.set(changes);
            this.prepareStamp();
        }

        this.regularStamp();
    }
};

P.stamp = function (force = false, host, changes) {

    if (force) {

        if (host && host.type === T_CELL) this.currentHost = host;

        if (changes) {

            this.set(changes);
            this.prepareStamp();
        }
        this.regularStamp();
    }

    else if (this.visibility) {

        if (this.dirtyInput) {

            this.sourceImageData = this.cleanInput();

            if (this.sourceImageData) this.output = this.cleanOutput();
            else this.dirtyInput = true;
        }

        if (this.output) this.regularStamp();
    }
};

P.cleanInput = function () {

    this.dirtyInput = false;

    this.setSourceDimension();

    const sourceDimension = this.sourceDimension;

    if (!sourceDimension) {

        this.dirtyInput = true;
        return false;
    }

    const mycell = requestCell(),
        engine = mycell.engine,
        canvas = mycell.element;

    canvas.width = sourceDimension;
    canvas.height = sourceDimension;
    engine.resetTransform();

    this.source.stamp(true, mycell, {
        startX: 0,
        startY: 0,
        handleX: 0,
        handleY: 0,
        offsetX: 0,
        offsetY: 0,
        roll: 0,
        scale: 1,

        width: sourceDimension,
        height: sourceDimension,

        method: FILL,
    })
    const sourceImageData = engine.getImageData(0, 0, sourceDimension, sourceDimension);

    releaseCell(mycell);
    return sourceImageData;
};

P.cleanOutput = function () {

    this.dirtyOutput = false;

    const {sourceImageData, columns, rows, struts, boundingBox} = this;

    const sourceDimension = _ceil(this.sourceDimension);

    if (sourceImageData && rows - 1 > 0) {

/* eslint-disable-next-line */
        let [startX, startY, outputWidth, outputHeight] = boundingBox;

        outputWidth = ~~(startX + outputWidth);
        outputHeight = ~~(startY + outputHeight);

        const inputCell = requestCell(),
            inputEngine = inputCell.engine,
            inputCanvas = inputCell.element;

        inputCanvas.width = sourceDimension;
        inputCanvas.height = sourceDimension;
        inputEngine.resetTransform();
        inputEngine.putImageData(sourceImageData, 0, 0);

        const outputCell = requestCell(),
            outputEngine = outputCell.engine,
            outputCanvas = outputCell.element;

        outputCanvas.width = outputWidth;
        outputCanvas.height = outputHeight;
        outputEngine.globalAlpha = this.state.globalAlpha;
        outputEngine.resetTransform();

        const inputStrutHeight = parseFloat((sourceDimension / (rows - 1)).toFixed(4)),
            inputStrutWidth = parseFloat((sourceDimension / (columns - 1)).toFixed(4));

        let topStruts, baseStruts,
            maxLen, iStep, xtStep, ytStep, xbStep, ybStep, tx, ty, bx, by, sx, sy,
            xLen, yLen, stripLength, stripAngle,
            c, cz, r, rz, i;

        for (r = 0, rz = rows - 1; r < rz; r++) {

            topStruts = struts[r];
            baseStruts = struts[r + 1];

            for (c = 0, cz = columns - 1; c < cz; c++) {

/* eslint-disable-next-line */
                let [ltx, lty, rtx, rty, tLen] = topStruts[c];
/* eslint-disable-next-line */
                let [lbx, lby, rbx, rby, bLen] = baseStruts[c];

                tLen *= sourceDimension;
                bLen *= sourceDimension;

                maxLen = _max(tLen, bLen, inputStrutWidth);

                iStep = inputStrutWidth / maxLen;

                xtStep = (rtx - ltx) / maxLen;
                ytStep = (rty - lty) / maxLen;
                xbStep = (rbx - lbx) / maxLen;
                ybStep = (rby - lby) / maxLen;

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

                    tx = ltx + (xtStep * i);
                    ty = lty + (ytStep * i);
                    bx = lbx + (xbStep * i);
                    by = lby + (ybStep * i);
                    sy = r * inputStrutHeight;
                    sx = (c * inputStrutWidth) + (iStep * i);

                    xLen = tx - bx;
                    yLen = ty - by;
                    stripLength = _sqrt((xLen * xLen) + (yLen * yLen));
                    stripAngle = _atan2(yLen, xLen) + _piHalf;

                    outputEngine.setTransform(1, 0, 0, 1, tx, ty);
                    outputEngine.rotate(stripAngle);

                    const testHeight = (sy + inputStrutHeight > sourceDimension) ? sourceDimension - sy : inputStrutHeight;

                    outputEngine.drawImage(inputCanvas, ~~sx, ~~sy, 1, ~~testHeight, 0, 0, 1, ~~stripLength);
                }
            }
        }

        const iFactor = this.interferenceFactor,
            iLoops = this.interferenceLoops,

            iWidth = ~~(outputWidth * iFactor) + 1,
            iHeight = ~~(outputHeight * iFactor) + 1;

        inputCanvas.width = iWidth;
        inputCanvas.height = iHeight;

        outputEngine.resetTransform();
        inputEngine.resetTransform();

        for (let j = 0; j < iLoops; j++) {

            inputEngine.drawImage(outputCanvas, 0, 0, outputWidth, outputHeight, 0, 0, iWidth, iHeight);
            outputEngine.drawImage(inputCanvas, 0, 0, iWidth, iHeight, 0, 0, outputWidth, outputHeight);
        }

        const outputData = outputEngine.getImageData(0, 0, outputWidth, outputHeight);

        releaseCell(inputCell, outputCell);

        this.dirtyTargetImage = true;

        return outputData;
    }
    return false;
};

P.regularStamp = function () {

    const dest = this.currentHost;

    if (dest) {

        const engine = dest.engine;

        if (!this.noCanvasEngineUpdates) dest.setEngine(this);

        this[this.method](engine);
    }
};

P.fill = function (engine) {

    this.doFill(engine);
};

P.draw = function (engine) {

    this.doStroke(engine);
};

P.drawAndFill = function (engine) {

    this.doStroke(engine);
    this.currentHost.clearShadow();
    this.doFill(engine);
};

P.fillAndDraw = function (engine) {

    this.doFill(engine);
    this.currentHost.clearShadow();
    this.doStroke(engine);
};

P.drawThenFill = function (engine) {

    this.doStroke(engine);
    this.doFill(engine);
};

P.fillThenDraw = function (engine) {

    this.doFill(engine);
    this.doStroke(engine);
};

P.clear = function (engine) {

    const output = this.output,
        canvas = (this.currentHost) ? this.currentHost.element : false,
        gco = engine.globalCompositeOperation;

    if (output && canvas) {

        const tempCell = requestCell(),
            tempEngine = tempCell.engine,
            tempCanvas = tempCell.element;

        const w = canvas.width,
            h = canvas.height;

        tempCanvas.width = w;
        tempCanvas.height = h;

        tempEngine.putImageData(output, 0, 0);
        engine.resetTransform();
        engine.globalCompositeOperation = DESTINATION_OUT;
        engine.drawImage(tempCanvas, 0, 0);
        engine.globalCompositeOperation = gco;

        releaseCell(tempCell);
    }
};

P.none = λnull;
P.clip = λnull;

P.doStroke = function (engine) {

    engine.resetTransform();
    engine.stroke(this.pathObject);
};

P.doFill = function (engine) {

    const output = this.output,
        canvas = (this.currentHost) ? this.currentHost.element : false;

    if (output && canvas) {

        const tempCell = requestCell(),
            tempEngine = tempCell.engine,
            tempCanvas = tempCell.element;

        const w = canvas.width,
            h = canvas.height;

        tempCanvas.width = w;
        tempCanvas.height = h;

        tempEngine.putImageData(output, 0, 0);
        engine.resetTransform();
        engine.drawImage(tempCanvas, 0, 0);

        releaseCell(tempCell);
    }
};

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

    if (this.noUserInteraction) return false;

    if (!this.pathObject) return false;

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

    let tx, ty;

    const mycell = requestCell();

    if (tests.some(test => {

        if (_isArray(test)) {

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

            tx = test.x;
            ty = test.y;
        }
        else return false;

        if (!_isFinite(tx) || !_isFinite(ty)) return false;

        return mycell.engine.isPointInPath(this.pathObject, tx, ty, this.winding);

    }, this)) {

        const r = {
            x: tx,
            y: ty,
            artefact: this
        };

        releaseCell(mycell);
        return r;
    }

    releaseCell(mycell);
    return false;
};

export const makeMesh = function (items) {

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

constructors.Mesh = Mesh;