Group factory

import { artefact, cell, constructors, entity, group } from '../core/library.js';
import { getPixelRatio } from "../core/user-interaction.js";

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

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

import { importDomImage } from '../asset-management/image-asset.js';

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

import baseMix from '../mixin/base.js';
import filterMix from '../mixin/filter.js';

import { _isArray, _floor, _values, ENTITY, IMG, REVERSE_BY_DELTA, SOURCE_IN, SOURCE_OVER, T_GROUP, UPDATE_BY_DELTA } from '../helper/shared-vars.js';

const ACCEPTED_OWNERS = ['Cell', 'Stack'],
    ADD_CLASSES = 'addClasses',
    GROUP = 'group',
    REMOVE_CLASSES = 'removeClasses',
    SET = 'set',
    SET_DELTA = 'setDelta';

const Group = function (items = Ωempty) {

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

    this.artefacts = [];
    this.artefactCalculateBuckets = [];
    this.artefactStampBuckets = [];

    this.set(this.defs);

    this.onEntityHover = λnull;
    this.onEntityNoHover = λnull;
    this.isHovering = null;

    this.currentHost = null;
    this.dirtyFilters = true;
    this.dirtyFiltersCache = true;
    this.filters = [];
    this.currentFilters = [];
    this.batchResort = true;
    this.stashOutput = false;
    this.stashOutputAsAsset = false;
    this.stashedImageData = null;
    this.stashedImage = null;
    this.dirtyImageSubscribers = true;

    this.set(items);

    return this;
};

const P = Group.prototype = doCreate();
P.type = T_GROUP;
P.lib = GROUP;
P.isArtefact = false;
P.isAsset = false;

baseMix(P);
filterMix(P);

const defaultAttributes = {

    artefacts: null,

    order: 0,

    visibility: true,

    checkForEntityHover: false,

    onEntityHover: null,

    onEntityNoHover: null,
};
P.defs = mergeOver(P.defs, defaultAttributes);

P.packetExclusions = pushUnique(P.packetExclusions, ['artefactCalculateBuckets', 'artefactStampBuckets', 'batchResort']);
P.packetFunctions = pushUnique(P.packetFunctions, ['onEntityHover', 'onEntityNoHover']);

P.postCloneAction = function(clone, items) {

    let host;

    if (items && items.host) {

        if (items.host.substring) host = artefact[items.host];
        else if (items.host.type && ACCEPTED_OWNERS.includes(items.host.type)) host = items.host;
    }
    else {

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

            if (this.host.substring) host = artefact[this.host];
            else if (this.host.type && ACCEPTED_OWNERS.includes(this.host.type)) host = this.host;
        }
    }

    if (host) {

        host.addGroups(clone.name);
        if (!clone.host) clone.host = host.name;
    }

    return clone;
};

P.kill = function (killArtefacts = false, killDomElement = false) {

    if (killArtefacts) this.artefactCalculateBuckets.forEach(item => item.kill(killDomElement));

    const myname = this.name;

    _values(artefact).forEach(art => {

        if (_isArray(art.groups) && art.groups.includes(myname)) {

            removeItem(art.groups, myname);
            art.batchResort = true;
        }
    });

    _values(cell).forEach(obj => {

        if (_isArray(obj.groups) && obj.groups.includes(myname)) {

            removeItem(obj.groups, myname);
            obj.batchResort = true;
        }
    });

    return this.deregister();
}

P.killArtefacts = function (killDomElement = false) {

    this.artefactCalculateBuckets.forEach(item => item.kill(killDomElement));

    return this;
}

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

G.artefacts = function () {

    return [].concat(this.artefacts);
};

S.artefacts = function (item) {

    if (!this.artefacts) this.artefacts = [];
    this.artefacts.length = 0;

    this.addArtefacts(item);
};

S.host = function (item) {

    const host = this.getHost(item);

    if (host && host.addGroups) {

        this.host = item;
        host.addGroups(this.name);

        this.dirtyHost = true;
    }
};

S.order = function (item) {

    const host = this.getHost(this.host);

    this.order = item;

    if (host) {

        host.set({
            batchResort: true
        });
    }
};

S.noFilters = function (item) {

    this.noFilters = item;
    this.dirtyFilterIdentifier = true;
};

P.getArtefactNames = function () {

    return [...this.artefacts];
};

P.getHost = function (item) {

    if (item) {

        if (item.type && ACCEPTED_OWNERS.includes(item.type)) return item;
        if (item.substring) return artefact[item] || cell[item];
    }

    const host = this.currentHost;

    if (host && host.substring) return artefact[host] || cell[host];

    return host;
};

P.forceStamp = function () {

    const v = this.visibility;
    this.visibility = true;
    this.stamp()
    this.visibility = v;
};

P.stamp = function () {

    if (this.dirtyHost || !this.currentHost) {

        this.dirtyHost = false;

        const currentHost = this.getHost(this.host);

        if (currentHost) this.currentHost = currentHost;
        else this.dirtyHost = true;
    }

    if (this.visibility) {

        const { currentHost, stashOutput, noFilters, filters } = this;

        if (currentHost) {

            this.sortArtefacts();

            let filterCell = null;

            if (stashOutput || (!noFilters && filters && filters.length)) {

                filterCell = requestCell(currentHost.element.width, currentHost.element.height);
            }

            else if (currentHost.engine) currentHost.engine.save();

            this.prepareStamp(filterCell);

            this.stampAction(filterCell);

            if (filterCell) releaseCell(filterCell);
            else {

                if (currentHost.engine) {

                    currentHost.engine.restore();
                    currentHost.setEngineFromState(currentHost.engine);
                }
            }
        }
    }
};

P.sortArtefacts = function () {

    if (this.batchResort) {

        this.batchResort = false;

        const calcBuckets = requestArray(),
            stampBuckets = requestArray();

        const { artefacts, artefactCalculateBuckets, artefactStampBuckets } = this;

        let obj, order, i, iz, name, arr;

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

            name = artefacts[i];
            obj = artefact[name];

            if (obj) {

                order = _floor(obj.calculateOrder);
                if (!calcBuckets[order]) calcBuckets[order] = requestArray();
                calcBuckets[order].push(obj);

                order = _floor(obj.stampOrder);
                if (!stampBuckets[order]) stampBuckets[order] = requestArray();
                stampBuckets[order].push(obj);
            }
        }

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

            arr = calcBuckets[i];

            if (arr) {

                artefactCalculateBuckets.push(...arr);
                releaseArray(arr);
            }
        }
        releaseArray(calcBuckets);

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

            arr = stampBuckets[i];

            if (arr) {

                artefactStampBuckets.push(...arr);
                releaseArray(arr);
            }
        }
        releaseArray(stampBuckets);
    }
};

P.prepareStamp = function (myCell) {

    let host = this.currentHost;

    if (myCell) host = myCell;

    this.artefactCalculateBuckets.forEach(art => {

        if (art.lib === ENTITY) {

            if (!art.currentHost || art.currentHost.name !== host.name) {

                art.currentHost = host;
                if (!myCell) art.dirtyHost = true;
            }
        }

        if (!art.noDeltaUpdates) art.updateByDelta();

        art.prepareStamp();
    });
};

P.stampAction = function (myCell) {

    const { dirtyFilters, currentFilters, artefactStampBuckets, noFilters, filters, stashOutput, currentHost } = this;

    if (dirtyFilters || !currentFilters) this.cleanFilters();

    artefactStampBuckets.forEach(art => {

        if (art && art.stamp) art.stamp();
    });

    if (myCell) {

        if (!noFilters && filters && filters.length) {

            const img = this.applyFilters(myCell);
            if (stashOutput) this.stashAction(img);
        }
        else if (stashOutput) {

            const tempElement = myCell.element,
                tempEngine = myCell.engine,
                realEngine = (currentHost && currentHost.engine) ? currentHost.engine : false;

            if (realEngine) {

                realEngine.save();

                realEngine.globalCompositeOperation = SOURCE_OVER;
                realEngine.globalAlpha = 1;
                realEngine.resetTransform();

                realEngine.drawImage(tempElement, 0, 0);

                realEngine.restore();

                const tempImg = tempEngine.getImageData(0, 0, tempElement.width, tempElement.height);


                this.stashAction(tempImg);
            }
        }
    }
};

P.applyFilters = function (myCell) {

    const currentHost = this.currentHost;
    const dpr = getPixelRatio();


    if (!currentHost || !myCell) return false;

    const currentElement = currentHost.element,
        currentEngine = currentHost.engine;

    const filterCellElement = myCell.element,
        filterCellEngine = myCell.engine;

    if (this.isStencil) {

        filterCellEngine.save();
        filterCellEngine.globalCompositeOperation = SOURCE_IN;
        filterCellEngine.globalAlpha = 1;
        filterCellEngine.resetTransform();
        filterCellEngine.drawImage(currentElement, 0, 0);
        filterCellEngine.restore();

        this.dirtyFilterIdentifier = true;
    }

    filterCellEngine.resetTransform();

    const myimage = filterCellEngine.getImageData(0, 0, filterCellElement.width, filterCellElement.height);

    this.preprocessFilters(this.currentFilters, filterCellElement.width, filterCellElement.height);

    const img = filterEngine.action({
        identifier: this.filterIdentifier,
        image: myimage,
        filters: this.currentFilters,
    })

    if (img) {

        filterCellEngine.globalCompositeOperation = SOURCE_OVER;
        filterCellEngine.globalAlpha = 1;
        filterCellEngine.setTransform(dpr, 0, 0, dpr, 0, 0);
        filterCellEngine.putImageData(img, 0, 0);
    }

    currentEngine.save();

    currentEngine.resetTransform();
    currentEngine.drawImage(filterCellElement, 0, 0);
    currentEngine.restore();

    return img;
};

P.stashAction = function (img) {

    if (!img) return false;

    if (this.stashOutput) {

        this.stashOutput = false;

        const [x, y, width, height] = this.getCellCoverage(img);

        const myCell = requestCell(),
            myEngine = myCell.engine,
            myElement = myCell.element;

        myElement.width = width;
        myElement.height = height;

        myEngine.putImageData(img, -x, -y);

        this.stashedImageData = myEngine.getImageData(0, 0, width, height);

        if (this.stashOutputAsAsset) {

            const stashId = this.stashOutputAsAsset.substring ? this.stashOutputAsAsset : `${this.name}-groupimage`;

            this.stashOutputAsAsset = false;

            if (!this.stashedImage) {

                const host = this.currentHost;
                const control = (host) ? host.getController() : null;

                if (control) {

                    const that = this;

                    const newimg = document.createElement(IMG);
                    newimg.id = stashId;
                    newimg.alt = `A cached image of the ${this.name} Group of entitys`;

                    newimg.onload = function () {

                        control.canvasHold.appendChild(newimg);
                        that.stashedImage = newimg;
                        importDomImage(`#${stashId}`);
                    };

                    newimg.src = myElement.toDataURL();
                }
            }
            else this.stashedImage.src = myElement.toDataURL();
        }
        releaseCell(myCell);
    }
};

P.getCellCoverage = function (img) {

    const { width, height, data } = img;

    let maxX = 0,
        maxY = 0,
        minX = width,
        minY = height,
        counter = 3,
        x, y, i, iz;

    for (i = 0, iz = width * height; i < iz; i++) {

        if (data[counter]) {

            y = _floor(i / width);
            x = i - (y * width);

            if (minX > x) minX = x;
            if (maxX < x) maxX = x;
            if (minY > y) minY = y;
            if (maxY < y) maxY = y;
        }
        counter += 4;
    }
    if (minX < maxX && minY < maxY) return [minX, minY, maxX - minX, maxY - minY];
    else return [0, 0, width, height];
};

P.addArtefacts = function (...args) {

    if (args && _isArray(args[0])) args = args[0];

    args.forEach(item => {

        if (item) {

            if (item.substring) pushUnique(this.artefacts, item);
            else if (item.name) pushUnique(this.artefacts, item.name);
        }
    }, this);

    this.batchResort = true;
    return this;
};

P.getArtefact = function (name) {

    if (this.artefacts.includes(name)) return artefact[name] || false;
    return false;
};

P.removeArtefacts = function (...args) {

    args.forEach(item => {

        if (item) {

            if (item.substring) removeItem(this.artefacts, item);
            else if (item.name) removeItem(this.artefacts, item.name);
        }
    }, this);

    this.batchResort = true;
    return this;
};

P.moveArtefactsIntoGroup = function (...args) {

    let temp, art;

    args.forEach(item => {

        if (item) {

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

            if (art && art.isArtefact) {

                if (art.group) temp = art.group;
                else if (art.host) temp = group[art.host];
                else temp = false;
            }

            if (temp) {

                temp.removeArtefacts(item);
                temp.batchResort = true;
            }
            pushUnique(this.artefacts, item);
        }
    }, this);

    this.batchResort = true;
    return this;
};

P.clearArtefacts = function () {

    this.artefacts.length = 0;
    this.artefactCalculateBuckets.length = 0;
    this.artefactStampBuckets.length = 0;
    this.batchResort = true;
    return this;
};

P.updateArtefacts = function (items) {

    this.cascadeAction(items, SET_DELTA);
    return this;
};

P.setArtefacts = function (items) {

    this.cascadeAction(items, SET);
    return this;
};

P.updateByDelta = function () {

    this.cascadeAction(false, UPDATE_BY_DELTA);
    return this;
};

P.reverseByDelta = function () {

    this.cascadeAction(false, REVERSE_BY_DELTA);
    return this;
};

P.addArtefactClasses = function (items) {

    this.cascadeAction(items, ADD_CLASSES);
    return this;
};

P.removeArtefactClasses = function (items) {

    this.cascadeAction(items, REMOVE_CLASSES);
    return this;
};

P.cascadeAction = function (items, action) {

    let art;

    this.artefacts.forEach(name => {

        art = artefact[name];

        if(art && art[action]) art[action](items);
    });
    return this;
};

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

    this.artefactCalculateBuckets.forEach(art => art.setDeltaValues(items));

    return this;
};

P.addFiltersToEntitys = function (...args) {

    let ent;

    this.artefacts.forEach(name => {

        ent = entity[name];

        if (ent && ent.addFilters) ent.addFilters(args);
    });
    return this;
};

P.removeFiltersFromEntitys = function (...args) {

    let ent;

    this.artefacts.forEach(name => {

        ent = entity[name];

        if (ent && ent.removeFilters) ent.removeFilters(args);
    });
    return this;
};

P.clearFiltersFromEntitys = function () {

    let ent;

    this.artefacts.forEach(name => {

        ent = entity[name];

        if (ent && ent.clearFilters) ent.clearFilters();
    });
    return this;
};

P.recalculateFonts = function () {

    let ent;

    this.artefacts.forEach(name => {

        ent = entity[name];

        if (ent && ent.recalculateFont) ent.recalculateFont();
    });
    return this;
};

P.getArtefactAt = function (items) {

    this.sortArtefacts();

    const artBuckets = this.artefactStampBuckets;

    let art, result;

    for (let i = artBuckets.length - 1; i >= 0; i--) {

        art = artBuckets[i];

        if (art) {

            result = art.checkHit(items);

            if (result) return result;
        }
    }
    return false;
};

P.getAllArtefactsAt = function (items) {

    this.sortArtefacts();

    const artBuckets = this.artefactStampBuckets,
        resultNames = requestArray(),
        results = [];

    let art, result, hit;

    for (let i = artBuckets.length - 1; i >= 0; i--) {

        art = artBuckets[i];

        if (art) {

            result = art.checkHit(items);

            if (result && result.artefact) {

                hit = result.artefact;

                if (!resultNames.includes(hit.name)) {

                    resultNames.push(hit.name);
                    results.push(result);
                }
            }
        }
    }
    releaseArray(resultNames);

    if (this.checkForEntityHover) {

        const foundArtefacts = (results.length) ? true : false,
            isHovering = this.isHovering;

        if (isHovering !== foundArtefacts) {

            this.isHovering = foundArtefacts;

            if (foundArtefacts) this.onEntityHover();
            else this.onEntityNoHover();
        }
    }
    return results;
};

export const makeGroup = function (items) {

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

constructors.Group = Group;