Loom factory

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

import { addStrings, doCreate, mergeDiscard, mergeOver, pushUnique, removeItem, 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 { 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, _cos, _floor, _hypot, _isArray, _isFinite, _keys, _max, _min, _parse, _piHalf, _sin, BLACK, DESTINATION_OUT, ENTITY, FILL, GOOD_HOST, NAME, SOURCE_OVER, STATE_KEYS, T_GROUP, T_PICTURE, UNDEF, ZERO_STR } from '../helper/shared-vars.js';

const T_LOOM = 'Loom';

const Loom = function (items = Ωempty) {

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

    this.state = makeState(Ωempty);

    this.modifyConstructorInputForAnchorButton(items);

    this.set(this.defs);

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

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

    this.delta = {};

    this.boundingBox = [];
    this.currentHost = null;
    this.currentPathData = null;
    this.dirtyDimensions = true;
    this.dirtyHost = true;
    this.dirtyInput = true;
    this.dirtyOutput = true;
    this.dirtyTargetImage = true;
    this.fromPathSteps = 1;
    this.output = null;
    this.pathTests = null;
    this.sourceDimension = 0;
    this.sourceImageData = null;
    this.toPathSteps = 1;
    this.watchFromPath = true;

    this.set(items);

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

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

    return this;
};

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

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

const defaultAttributes = {

    fromPath: null,
    toPath: null,

    fromPathStart: 0,
    fromPathEnd: 1,

    toPathStart: 0,
    toPathEnd: 1,

    synchronizePathCursors: true,

    loopPathCursors: true,
    constantSpeedAlongPath: true,

    isHorizontalCopy: true,

    showBoundingBox: false,
    boundingBoxColor: BLACK,

    source: null,

    sourceIsVideoOrSprite: false,

    interferenceLoops: 2,
    interferenceFactor: 1.03,

    sourceExpansionFactor: 1,

    visibility: true,
    calculateOrder: 0,
    stampOrder: 0,
    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', 'fromPath', 'toPath', 'source']);
P.packetFunctions = pushUnique(P.packetFunctions, ['onEnter', 'onLeave', 'onDown', 'onUp']);

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

    let result = true;

    if(!incs.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,
    D = P.deltaSetters;

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 (def != null) {

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

        def = state.defs[item];

        if (def != null) {

            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;
                }
                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);
                }
                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;
};

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.delta = function (items) {

    if (items) this.delta = mergeDiscard(this.delta, items);
};

S.fromPath = function (item) {

    if (item) {

        const oldPath = this.fromPath,
            newPath = (item.substring) ? artefact[item] : item,
            name = this.name;

        if (newPath && newPath.name && newPath.useAsPath) {

            if (oldPath && oldPath.name !== newPath.name) removeItem(oldPath.pathed, name);

            pushUnique(newPath.pathed, name);

            this.fromPath = newPath;

            this.dirtyStart = true;
        }
    }
};

S.toPath = function (item) {

    if (item) {

        const oldPath = this.toPath,
            newPath = (item.substring) ? artefact[item] : item,
            name = this.name;

        if (newPath && newPath.name && newPath.useAsPath) {

            if (oldPath && oldPath.name !== newPath.name) removeItem(oldPath.pathed, name);

            pushUnique(newPath.pathed, name);

            this.toPath = newPath;

            this.dirtyStart = 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;
    }
};

S.isHorizontalCopy = function (item) {

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

S.synchronizePathCursors = function (item) {

    this.synchronizePathCursors = (item) ? true : false;

    if (item) {

        this.toPathStart = this.fromPathStart;
        this.toPathEnd = this.fromPathEnd;
    }

    this.dirtyPathData = true;
};

S.loopPathCursors = function (item) {

    this.loopPathCursors = (item) ? true : false;

    if (item) {

        let c = this.fromPathStart;
        if (c < 0 || c > 1) this.fromPathStart = c - _floor(c);

        c = this.fromPathEnd
        if (c < 0 || c > 1) this.fromPathEnd = c - _floor(c);

        c = this.toPathStart
        if (c < 0 || c > 1) this.toPathStart = c - _floor(c);

        c = this.toPathEnd
        if (c < 0 || c > 1) this.toPathEnd = c - _floor(c);
    }

    this.dirtyOutput = true;
};

S.fromPathStart = function (item) {

    if (this.loopPathCursors && (item < 0 || item > 1)) item = item - _floor(item);
    this.fromPathStart = item;
    if (this.synchronizePathCursors) this.toPathStart = item;
    this.dirtyPathData = true;
};
D.fromPathStart = function (item) {

    let val = this.fromPathStart += item;

    if (this.loopPathCursors && (val < 0 || val > 1)) val = val - _floor(val);
    this.fromPathStart = val;
    if (this.synchronizePathCursors) this.toPathStart = val;
    this.dirtyPathData = true;
};

S.fromPathEnd = function (item) {

    if (this.loopPathCursors && (item < 0 || item > 1)) item = item - _floor(item);
    this.fromPathEnd = item;
    if (this.synchronizePathCursors) this.toPathEnd = item;
    this.dirtyPathData = true;
};
D.fromPathEnd = function (item) {

    let val = this.fromPathEnd += item;

    if (this.loopPathCursors && (val < 0 || val > 1)) val = val - _floor(val);
    this.fromPathEnd = val;
    if (this.synchronizePathCursors) this.toPathEnd = val;
    this.dirtyPathData = true;
};

S.toPathStart = function (item) {

    if (this.loopPathCursors && (item < 0 || item > 1)) item = item - _floor(item);
    this.toPathStart = item;
    if (this.synchronizePathCursors) this.fromPathStart = item;
    this.dirtyPathData = true;
};
D.toPathStart = function (item) {

    let val = this.toPathStart += item;

    if (this.loopPathCursors && (val < 0 || val > 1)) val = val - _floor(val);
    this.toPathStart = val;
    if (this.synchronizePathCursors) this.fromPathStart = val;
    this.dirtyPathData = true;
};

S.toPathEnd = function (item) {

    if (this.loopPathCursors && (item < 0 || item > 1)) item = item - _floor(item);
    this.toPathEnd = item;
    if (this.synchronizePathCursors) this.fromPathEnd = item;
    this.dirtyPathData = true;
};
D.toPathEnd = function (item) {

    let val = this.toPathEnd += item;

    if (this.loopPathCursors && (val < 0 || val > 1)) val = val - _floor(val);
    this.toPathEnd = val;
    if (this.synchronizePathCursors) this.fromPathEnd = val;
    this.dirtyPathData = 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.update = function () {

    this.dirtyInput = true;
    this.dirtyOutput = true;
};

P.prepareStamp = function () {

    const fPath = this.fromPath,
        tPath = this.toPath;

    const [startX, startY] = this.getBoundingBox();

    if (!this.dirtyPathData && fPath && tPath) {

        const { x: fSx, y: fSy } = fPath.getPathPositionData(0);
        const { x: fEx, y: fEy } = fPath.getPathPositionData(1);
        const { x: tSx, y: tSy } = tPath.getPathPositionData(0);
        const { x: tEx, y: tEy } = tPath.getPathPositionData(1);

        const localPathTests = [fSx, fSy, fEx, fEy, tSx, tSy, tEx, tEy];

        if (!this.pathTests || this.pathTests.some((v, i) => v !== localPathTests[i])) {

            this.pathTests = localPathTests;
            this.dirtyPathData = true;
        }
    }

    if (this.dirtyPathData || !this.fromPathData.length) {

        this.dirtyPathData = false;

        this.watchIndex = -1;
        this.engineInstructions.length = 0;
        this.engineDeltaLengths.length = 0;

        const fromPathData = this.fromPathData,
            toPathData   = this.toPathData;

        fromPathData.length = 0;
        toPathData.length   = 0;

        if (fPath && tPath) {

            const fPathLength = _ceil(fPath.length);
            const tPathLength = _ceil(tPath.length);

            const pathSteps = this.setSourceDimension(_max(fPathLength, tPathLength) * this.sourceExpansionFactor);

            const steps = (pathSteps > 1) ? pathSteps : 2,
                step  = 1 / (steps - 1);

            const pathSpeed = this.constantSpeedAlongPath;

            for (let i = 0; i < steps; i++) {

                const cursor = (i === steps - 1) ? 1 : i * step;

                let p = fPath.getPathPositionData(cursor, pathSpeed);
                fromPathData.push([p.x - startX, p.y - startY]);

                p = tPath.getPathPositionData(cursor, pathSpeed);
                toPathData.push([p.x - startX, p.y - startY]);
            }

            const fStart = this.fromPathStart, fEnd = this.fromPathEnd,
                tStart = this.toPathStart,   tEnd = this.toPathEnd

            let fPartial = (fEnd >= fStart) ? (fEnd - fStart) : (1 - fStart + fEnd),
                tPartial = (tEnd >= tStart) ? (tEnd - tStart) : (1 - tStart + tEnd);

            if (fPartial < 0.005) fPartial = 0.005;
            if (tPartial < 0.005) tPartial = 0.005;

            this.fromPathSteps = fPartial;
            this.toPathSteps   = tPartial;

            this.watchFromPath = (fPartial <= tPartial);

            this.dirtyOutput = true;
        }
        else this.dirtyPathData = true;
    }

    this.prepareStampTabsHelper();
};

P.setSourceDimension = function (val) {

    if (val) {

        if (this.sourceDimension !== val) {

            this.sourceDimension = val;
            this.dirtyInput = true;
        }
    }

    else {

        const fPath = this.fromPath,
            tPath = this.toPath;

        if(fPath && tPath) {

            const fPathLength = _ceil(fPath.length),
                tPathLength = _ceil(tPath.length);

            const steps = _max(fPathLength, tPathLength);

            if (this.sourceDimension !== steps) this.sourceDimension = steps;
        }
        else this.sourceDimension = 0;
    }
    return this.sourceDimension;
};

P.simpleStamp = function (host, changes) {

    if (host && GOOD_HOST.includes(host.type)) {

        this.currentHost = host;

        if (changes) {

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

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

    if (force) {

        if (host && GOOD_HOST.includes(host.type)) this.currentHost = host;

        if (changes) {

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

    else if (this.visibility) {

        if (this.sourceIsVideoOrSprite || this.dirtyInput) this.cleanInput();

        if (this.dirtyOutput) this.output = this.cleanOutput();

        this.regularStamp();
    }
};

P.cleanInput = function () {

    this.dirtyInput = false;

    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,
    });

    this.sourceImageData = engine.getImageData(0, 0, sourceDimension, sourceDimension);

    releaseCell(mycell);
};

P.cleanOutput = function () {

    this.dirtyOutput = false;

    const sourceDimension = this.sourceDimension,
        sourceData = this.sourceImageData;

    if (sourceDimension && sourceData) {

        const fromPathData = this.fromPathData,
            toPathData = this.toPathData,

            dataLen = fromPathData.length,

            fPathStart = this.fromPathStart,
            fStep = this.fromPathSteps || 1,

            tPathStart = this.toPathStart,
            tStep = this.toPathSteps || 1,

            magicVerticalPi = _piHalf - 1.5708,

            isHorizontalCopy = this.isHorizontalCopy,
            loop = this.loopPathCursors,

            watchFromPath = this.watchFromPath,
            engineInstructions = this.engineInstructions,
            engineDeltaLengths = this.engineDeltaLengths;

        let fCursor = fPathStart * dataLen,
            tCursor = tPathStart * dataLen,
            watchIndex = this.watchIndex,
            fx, fy, tx, ty, dx, dy, dLength, dAngle, cos, sin, i, j,
            instruction;

        let [, , outputWidth, outputHeight] = this.getBoundingBox();

        if (outputWidth && outputHeight) {

            outputWidth = ~~outputWidth;
            outputHeight = ~~outputHeight;

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

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

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

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

            if(!engineInstructions.length) {

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

                    if (watchIndex < 0) {

                        if (watchFromPath && fCursor < 1) watchIndex = i;
                        else if (!watchFromPath && tCursor < 1) watchIndex = i;
                    }

                    if (fCursor < dataLen && tCursor < dataLen && fCursor >= 0 && tCursor >= 0) {

                        [fx, fy] = fromPathData[_floor(fCursor)];
                        [tx, ty] = toPathData[_floor(tCursor)];

                        dx = tx - fx;
                        dy = ty - fy;

                        dLength = _hypot(dx, dy);

                        if (isHorizontalCopy) {

                            dAngle = -_atan2(dx, dy) + _piHalf;
                            cos = _cos(dAngle);
                            sin = _sin(dAngle);

                            engineInstructions.push([cos, sin, -sin, cos, fx, fy]);
                            engineDeltaLengths.push(dLength);
                        }
                        else {

                            dAngle = -_atan2(dx, dy) + magicVerticalPi;
                            cos = _cos(dAngle);
                            sin = _sin(dAngle);

                            engineInstructions.push([cos, sin, -sin, cos, fx, fy, dLength]);
                            engineDeltaLengths.push(dLength);
                        }
                    }
                    else {

                        engineInstructions.push(false);
                        engineDeltaLengths.push(false);
                    }

                    fCursor += fStep;
                    tCursor += tStep;

                    if (loop) {

                        if (fCursor >= dataLen) fCursor -= dataLen;
                        if (tCursor >= dataLen) tCursor -= dataLen;
                    }
                }
                if (watchIndex < 0) watchIndex = 0;
                this.watchIndex = watchIndex;
            }

            if (isHorizontalCopy) {

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

                    instruction = engineInstructions[watchIndex];

                    if (instruction) {

                        outputEngine.setTransform(...instruction);
                        outputEngine.drawImage(inputCanvas, 0, ~~watchIndex, ~~sourceDimension, 1, 0, 0, ~~engineDeltaLengths[watchIndex], 1);
                    }
                    watchIndex++;

                    if (watchIndex >= sourceDimension) watchIndex = 0;
                }
            }
            else {

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

                    instruction = engineInstructions[watchIndex];

                    if (instruction) {

                        outputEngine.setTransform(...instruction);
                        outputEngine.drawImage(inputCanvas, ~~watchIndex, 0, 1, ~~sourceDimension, 0, 0, 1, ~~engineDeltaLengths[watchIndex]);
                    }
                    watchIndex++;

                    if (watchIndex >= sourceDimension) watchIndex = 0;
                }
            }

            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 (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;
        }
        else this.dirtyOutput = true;
    }
    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.getBoundingBox = function () {

    const fPath = this.fromPath,
        tPath = this.toPath;

    if(fPath && tPath) {

        if (this.dirtyStart) {

            this.boundingBox.length = 0;

            if (fPath.getBoundingBox && tPath.getBoundingBox) {

                this.dirtyStart = false;

/* eslint-disable-next-line */
                let [lsx, lsy, sw, sh, sx, sy] = fPath.getBoundingBox();
/* eslint-disable-next-line */
                let [lex, ley, ew, eh, ex, ey] = tPath.getBoundingBox();

                if (!_isFinite(lsx) || !_isFinite(lsy) || !_isFinite(sw) || !_isFinite(sh) || !_isFinite(sx) || !_isFinite(sy) || !_isFinite(lex) || !_isFinite(ley) || !_isFinite(ew) || !_isFinite(eh) || !_isFinite(ex) || !_isFinite(ey)) this.dirtyStart = true;

                if (lsx === lex && lsy === ley && sw === ew && sh === eh && sx === ex && sy === ey) this.dirtyStart = true;

                lsx += sx;
                lsy += sy;
                lex += ex;
                ley += ey;

                const minX = _min(lsx, lex),
                    maxX = _max(lsx + sw, lex + ew),
                    minY = _min(lsy, ley),
                    maxY = _max(lsy + sh, ley + eh);

                this.boundingBox.push(minX, minY, maxX - minX, maxY - minY);

                this.dirtyPathData = true;
            }
            else this.boundingBox.push(0, 0, 0, 0);
        }
    }
    else if (!this.boundingBox.length) this.boundingBox.push(0, 0, 0, 0);

    return this.boundingBox;
};

P.fill = function (engine) {


    this.doFill(engine);

    if (this.showBoundingBox) this.drawBoundingBox(engine);

};

P.draw = function (engine) {

    this.doStroke(engine);

    if (this.showBoundingBox) this.drawBoundingBox(engine);
};

P.drawAndFill = function (engine) {

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

    if (this.showBoundingBox) this.drawBoundingBox(engine);
};

P.fillAndDraw = function (engine) {

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

    if (this.showBoundingBox) this.drawBoundingBox(engine);
};

P.drawThenFill = function (engine) {

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

    if (this.showBoundingBox) this.drawBoundingBox(engine);
};

P.fillThenDraw = function (engine) {

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

    if (this.showBoundingBox) this.drawBoundingBox(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;

        let [x, y, w, h] = this.getBoundingBox();

        x = ~~x;
        y = ~~y;
        w = ~~w;
        h = ~~h;

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

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

        releaseCell(tempCell);
        if (this.showBoundingBox) this.drawBoundingBox(engine);
    }
};

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

P.doStroke = function (engine) {

    const fPath = this.fromPath,
        tPath = this.toPath;

    if(fPath && fPath.getBoundingBox && tPath && tPath.getBoundingBox) {

        const host = this.currentHost;

        if (host) {

            const fStart = fPath.currentStampPosition,
                fEnd = fPath.getPathPositionData(1),
                tStart = tPath.currentStampPosition,
                tEnd = tPath.getPathPositionData(1);

            host.rotateDestination(engine, fStart[0], fStart[1], fPath);
            engine.stroke(fPath.pathObject);

            host.rotateDestination(engine, tStart[0], tStart[1], tPath);
            engine.stroke(tPath.pathObject);

            engine.resetTransform();
            engine.beginPath()
            engine.moveTo(fEnd.x, fEnd.y);
            engine.lineTo(tEnd.x, tEnd.y);
            engine.moveTo(...tStart);
            engine.lineTo(...fStart);
            engine.closePath();
            engine.stroke();
        }
    }
};

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;

        let [x, y, w, h] = this.getBoundingBox();

        x = ~~x;
        y = ~~y;
        w = ~~w;
        h = ~~h;

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

        tempEngine.putImageData(output, 0, 0);
        engine.resetTransform();
        engine.drawImage(tempCanvas, 0, 0, w, h, x, y, w, h);

        releaseCell(tempCell);
    }
};

P.drawBoundingBox = function (engine) {

    if (this.dirtyStart) this.getBoundingBox();

    engine.save();

    const t = engine.getTransform();
    engine.resetTransform();

    engine.strokeStyle = this.boundingBoxColor;
    engine.lineWidth = 1;
    engine.globalCompositeOperation = SOURCE_OVER;
    engine.globalAlpha = 1;
    engine.shadowOffsetX = 0;
    engine.shadowOffsetY = 0;
    engine.shadowBlur = 0;

    engine.strokeRect(...this.boundingBox);

    engine.restore();
    engine.setTransform(t);
};

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

    if (this.noUserInteraction) return false;

    const tests = (!_isArray(items)) ?  [items] : items,
        targetData = (this.output && this.output.data) ? this.output.data : false;

    let tx, ty, cx, cy, index;

    if (targetData) {

        const [x, y, w, h] = this.getBoundingBox();

        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;

            cx = tx - x;
            cy = ty - y;

            if (cx < 0 || cx > w || cy < 0 || cy > h) return false;

            index = (((cy * w) + cx) * 4) + 3;

            if (targetData) return (targetData[index] > 0) ? true : false;
            else return false;

        }, this)) {

            return {
                x: tx,
                y: ty,
                artefact: this
            };
        }
    }
    return false;
};

export const makeLoom = function (items) {

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

constructors.Loom = Loom;