Picture factory

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

import { addStrings, doCreate, isa_obj, mergeOver, pushUnique, removeItem, xta, Ωempty } from '../helper/utilities.js';

import { gettableVideoAssetAtributes, settableVideoAssetAtributes } from '../asset-management/video-asset.js';

import { gettableImageAssetAtributes, settableImageAssetAtributes } from '../asset-management/image-asset.js';

import { makeCoordinate } from '../untracked-factory/coordinate.js';

import baseMix from '../mixin/base.js';
import entityMix from '../mixin/entity.js';
import assetConsumerMix from '../mixin/asset-consumer.js';

import { $IMAGE, $VIDEO, _keys, ENTITY, MOUSE, NAME, PARTICLE, STATE_KEYS, T_PICTURE, T_SPRITE, UNDEF } from '../helper/shared-vars.js';

const COPY_DIMENSIONS = 'copyDimensions',
    COPY_START = 'copyStart';

const Picture = function (items = Ωempty) {

    this.copyStart = makeCoordinate();
    this.currentCopyStart = makeCoordinate();

    this.copyDimensions = makeCoordinate();
    this.currentCopyDimensions = makeCoordinate();

    this.copyArray = [];
    this.pasteArray = [];
    this.dirtyPaste = true;

    this.source = null;
    this.sourceNaturalWidth = 0;
    this.sourceNaturalHeight = 0;
    this.sourceNaturalDimensions = [];
    this.sourceLoaded = false;

    this.entityInit(items);

    if (!items.copyStart) {

        if (!items.copyStartX) this.copyStart[0] = 0;
        if (!items.copyStartY) this.copyStart[1] = 0;
    }

    if (!items.copyDimensions) {

        if (!items.copyWidth) this.copyDimensions[0] = 1;
        if (!items.copyHeight) this.copyDimensions[1] = 1;
    }

    this.imageSubscribers = [];

    this.dirtyCopyStart = true;
    this.dirtyCopyDimensions = true;
    this.dirtyImage = true;

    return this;
};

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

baseMix(P);
entityMix(P);
assetConsumerMix(P);

const defaultAttributes = {

    copyStart: null,

    copyDimensions: null,

    checkHitIgnoreTransparency: false,

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

P.packetCoordinates = pushUnique(P.packetCoordinates, ['copyStart', 'copyDimensions']);
P.packetObjects = pushUnique(P.packetObjects, ['asset']);

P.factoryKill = function () {

    const { asset, removeAssetOnKill } = this;

    if (isa_obj(asset)) {

        asset.unsubscribe(this);

        if (removeAssetOnKill) asset.kill(true);
    }
};

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

G.copyStart = function () {

    return [].concat(this.currentCopyStart);
};
G.copyStartX = function () {

    return this.currentCopyStart[0];
};
G.copyStartY = function () {

    return this.currentCopyStart[1];
};
S.copyStartX = function (coord) {

    if (coord != null) {

        this.copyStart[0] = coord;
        this.dirtyCopyStart = true;
        this.dirtyImageSubscribers = true;
        this.dirtyFilterIdentifier = true;
    }
};
S.copyStartY = function (coord) {

    if (coord != null) {

        this.copyStart[1] = coord;
        this.dirtyCopyStart = true;
        this.dirtyImageSubscribers = true;
        this.dirtyFilterIdentifier = true;
    }
};
S.copyStart = function (x, y) {

    this.setCoordinateHelper(COPY_START, x, y);
    this.dirtyCopyStart = true;
    this.dirtyImageSubscribers = true;
    this.dirtyFilterIdentifier = true;
};
D.copyStartX = function (coord) {

    const c = this.copyStart;
    c[0] = addStrings(c[0], coord);
    this.dirtyCopyStart = true;
    this.dirtyImageSubscribers = true;
    this.dirtyFilterIdentifier = true;
};
D.copyStartY = function (coord) {

    const c = this.copyStart;
    c[1] = addStrings(c[1], coord);
    this.dirtyCopyStart = true;
    this.dirtyFilterIdentifier = true;
};
D.copyStart = function (x, y) {

    this.setDeltaCoordinateHelper(COPY_START, x, y);
    this.dirtyCopyStart = true;
    this.dirtyImageSubscribers = true;
    this.dirtyFilterIdentifier = true;
};

G.copyWidth = function () {

    return this.currentCopyDimensions[0];
};
G.copyHeight = function () {

    return this.currentCopyDimensions[1];
};
G.copyDimensions = function () {

    return [].concat(this.currentCopyDimensions);
};
S.copyWidth = function (val) {

    if (val != null) {

        this.copyDimensions[0] = val;
        this.dirtyCopyDimensions = true;
        this.dirtyImageSubscribers = true;
        this.dirtyFilterIdentifier = true;
    }
};
S.copyHeight = function (val) {

    if (val != null) {

        this.copyDimensions[1] = val;
        this.dirtyCopyDimensions = true;
        this.dirtyImageSubscribers = true;
        this.dirtyFilterIdentifier = true;
    }
};
S.copyDimensions = function (w, h) {

    this.setCoordinateHelper(COPY_DIMENSIONS, w, h);
    this.dirtyCopyDimensions = true;
    this.dirtyImageSubscribers = true;
    this.dirtyFilterIdentifier = true;
};
D.copyWidth = function (val) {

    const c = this.copyDimensions;
    c[0] = addStrings(c[0], val);
    this.dirtyCopyDimensions = true;
    this.dirtyImageSubscribers = true;
    this.dirtyFilterIdentifier = true;
};
D.copyHeight = function (val) {

    const c = this.copyDimensions;
    c[1] = addStrings(c[1], val);
    this.dirtyCopyDimensions = true;
    this.dirtyImageSubscribers = true;
    this.dirtyFilterIdentifier = true;
};
D.copyDimensions = function (w, h) {

    this.setDeltaCoordinateHelper(COPY_DIMENSIONS, w, h);
    this.dirtyCopyDimensions = true;
    this.dirtyImageSubscribers = true;
    this.dirtyFilterIdentifier = true;
};

P.get = function (item) {

    const source = this.source;

    if ((item.indexOf($VIDEO) === 0 || item.indexOf($IMAGE) === 0) && source) {

        if (gettableVideoAssetAtributes.includes(item)) return source[item.substring(6)];
        else if (gettableImageAssetAtributes.includes(item)) return source[item.substring(6)];
    }

    else {

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

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

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

    if (keysLen) {

        const setters = this.setters,
            defs = this.defs,
            source = this.source,
            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.indexOf($VIDEO) === 0 || key.indexOf($IMAGE) === 0) && source) {

                if (settableVideoAssetAtributes.includes(key)) source[key.substring(6)] = value
                else if (settableImageAssetAtributes.includes(key)) source[key.substring(6)] = value
            }

            else 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.updateImageSubscribers = function () {

    this.dirtyImageSubscribers = false;

    if (this.imageSubscribers.length) {

        this.imageSubscribers.forEach(name => {

            const instance = artefact[name];

            if (instance) instance.dirtyInput = true;
        });
    }
};

P.imageSubscribe = function (name) {

    if (name && name.substring) pushUnique(this.imageSubscribers, name);
};

P.imageUnsubscribe = function (name) {

    if (name && name.substring) removeItem(this.imageSubscribers, name);
};

P.cleanImage = function () {

    const natWidth = this.sourceNaturalWidth,
        natHeight = this.sourceNaturalHeight;

    if (xta(natWidth, natHeight) && natWidth > 0 && natHeight > 0) {

        this.dirtyImage = false;

        const start = this.currentCopyStart,
            x = start[0],
            y = start[1];

        const dims = this.currentCopyDimensions,
            w = dims[0],
            h = dims[1];

        if (x + w > natWidth) start[0] = natWidth - w;
        if (y + h > natHeight) start[1] = natHeight - h;

        const copyArray = this.copyArray;

        copyArray.length = 0;
        copyArray.push(~~start[0], ~~start[1], ~~w, ~~h);
    }
};

P.cleanCopyStart = function () {

    const width = this.sourceNaturalWidth,
        height = this.sourceNaturalHeight;

    if (xta(width, height) && width > 0 && height > 0) {

        this.dirtyCopyStart = false;

        this.cleanPosition(this.currentCopyStart, this.copyStart, [width, height]);

        const current = this.currentCopyStart,
            x = current[0],
            y = current[1];

        if (x < 0 || x > width) {

            if (x < 0) current[0] = 0;
            else current[0] = width - 1;
        }

        if (y < 0 || y > height) {

            if (y < 0) current[1] = 0;
            else current[1] = height - 1;
        }
        this.dirtyImage = true;
    }
};

P.cleanCopyDimensions = function () {

    const natWidth = this.sourceNaturalWidth,
        natHeight = this.sourceNaturalHeight;

    if (xta(natWidth, natHeight) && natWidth > 0 && natHeight > 0) {

        this.dirtyCopyDimensions = false;

        const dims = this.copyDimensions,
            currentDims = this.currentCopyDimensions,
            width = dims[0],
            height = dims[1];

        if (width.substring) currentDims[0] = (parseFloat(width) / 100) * natWidth;
        else currentDims[0] = width;

        if (height.substring) currentDims[1] = (parseFloat(height) / 100) * natHeight;
        else currentDims[1] = height;

        const currentWidth = currentDims[0],
            currentHeight = currentDims[1];

        if (currentWidth <= 0 || currentWidth > natWidth) {

            if (currentWidth <= 0) currentDims[0] = 1;
            else currentDims[0] = natWidth;
        }

        if (currentHeight <= 0 || currentHeight > natHeight) {

            if (currentHeight <= 0) currentDims[1] = 1;
            else currentDims[1] = natHeight;
        }
        this.dirtyImage = true;
    }
};

P.prepareStamp = function() {

    if (this.dirtyAsset) this.cleanAsset();

    if (this.asset) {

        if (this.asset.type === T_SPRITE) this.checkSpriteFrame(this);
        else {

            if (this.asset.checkSource) this.asset.checkSource(this.sourceNaturalWidth, this.sourceNaturalHeight);
            else this.dirtyAsset = true;
        }
    }

    this.setGradientCacheFlags();

    if (this.dirtyDimensions || this.dirtyHandle || this.dirtyScale) this.dirtyPaste = true;

    if (this.dirtyScale || this.dirtyDimensions || this.dirtyStart || this.dirtyOffset || this.dirtyHandle) {

        this.dirtyPathObject = true;
        if (this.useFillGradientCache) this.dirtyFillGradientCache = true;
        if (this.useDrawGradientCache) this.dirtyDrawGradientCache = true;
    }

    if (this.dirtyRotation) {

        if (this.useFillGradientCache) this.dirtyFillGradientCache = true;
        if (this.useDrawGradientCache) this.dirtyDrawGradientCache = true;
    }

    if (this.dirtyScale) this.cleanScale();
    if (this.dirtyDimensions) this.cleanDimensions();
    if (this.dirtyLock) this.cleanLock();
    if (this.dirtyStart) this.cleanStart();
    if (this.dirtyOffset) this.cleanOffset();
    if (this.dirtyHandle) this.cleanHandle();
    if (this.dirtyRotation) this.cleanRotation();

    if (this.isBeingDragged || this.lockTo.includes(MOUSE) || this.lockTo.includes(PARTICLE)) {

        this.dirtyStampPositions = true;
        this.dirtyStampHandlePositions = true;
    }

    if (this.dirtyStampPositions || this.dirtyStampHandlePositions) {

        if (this.useFillGradientCache) this.dirtyFillGradientCache = true;
        if (this.useDrawGradientCache) this.dirtyDrawGradientCache = true;
    }

    if (this.dirtyStampPositions) this.cleanStampPositions();
    if (this.dirtyStampHandlePositions) this.cleanStampHandlePositions();

    if (this.dirtyCopyStart) this.cleanCopyStart();
    if (this.dirtyCopyDimensions) this.cleanCopyDimensions();
    if (this.dirtyImage) this.cleanImage();
    if (this.dirtyPaste) this.preparePasteObject();

    if (this.dirtyPathObject) this.cleanPathObject();

    if (this.dirtyPositionSubscribers) this.updatePositionSubscribers();

    if (this.dirtyImageSubscribers) this.updateImageSubscribers();

    this.prepareStampTabsHelper();
};

P.preparePasteObject = function () {

    this.dirtyPaste = false;

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

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

    const pasteArray = this.pasteArray;

    pasteArray.length = 0;
    pasteArray.push(~~x, ~~y, ~~w, ~~h);

    this.dirtyPathObject = true;
};

P.cleanPathObject = function () {

    this.dirtyPathObject = false;

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

        if (!this.pasteArray || this.pasteArray.length !== 4) this.preparePasteObject();

        if (this.pasteArray.length !== 4) this.dirtyPathObject = true;
        else {

            const p = this.pathObject = new Path2D();

            p.rect(...this.pasteArray);
        }
    }
};

P.draw = function (engine) {

    const apply = this.applyFromWorkstore.bind(this);

    if (this.identifierDrawGradientCache) apply(engine, this.identifierDrawGradientCache);
    else engine.stroke(this.pathObject);
};

P.fill = function (engine) {

    const [x, y, w, h] = this.copyArray;
    if (this.source && w && h) engine.drawImage(this.source, x, y, w, h, ...this.pasteArray);
};

P.drawAndFill = function (engine) {

    const [x, y, w, h] = this.copyArray;

    if (this.source && w && h) {

        const [_x, _y, _w, _h] = this.pasteArray;
        const p = this.pathObject,
            apply = this.applyFromWorkstore.bind(this),
            drawUse = this.useDrawGradientCache,
            drawId = this.identifierDrawGradientCache;

        if (drawUse) apply(engine, drawId);
        else engine.stroke(p);

        engine.drawImage(this.source, x, y, w, h, _x, _y, _w, _h);

        this.currentHost.clearShadow();

        if (drawUse) apply(engine, drawId);
        else engine.stroke(p);

        engine.drawImage(this.source, x, y, w, h, _x, _y, _w, _h);
    }
};

P.fillAndDraw = function (engine) {

    const [x, y, w, h] = this.copyArray;

    if (this.source && w && h) {

        const [_x, _y, _w, _h] = this.pasteArray;
        const p = this.pathObject,
            apply = this.applyFromWorkstore.bind(this),
            drawUse = this.useDrawGradientCache,
            drawId = this.identifierDrawGradientCache;

        engine.drawImage(this.source, x, y, w, h, _x, _y, _w, _h);

        if (drawUse) apply(engine, drawId);
        else engine.stroke(p);

        this.currentHost.clearShadow();

        engine.drawImage(this.source, x, y, w, h, _x, _y, _w, _h);

        if (drawUse) apply(engine, drawId);
        else engine.stroke(p);
    }

    engine.stroke(this.pathObject);
};

P.drawThenFill = function (engine) {

    const [x, y, w, h] = this.copyArray;

    if (this.source && w && h) {

        const p = this.pathObject,
            apply = this.applyFromWorkstore.bind(this),
            drawUse = this.useDrawGradientCache,
            drawId = this.identifierDrawGradientCache;

        if (drawUse) apply(engine, drawId);
        else engine.stroke(p);

        engine.drawImage(this.source, x, y, w, h, ...this.pasteArray);
    }
};

P.fillThenDraw = function (engine) {

    const [x, y, w, h] = this.copyArray;

    if (this.source && w && h) {

        const p = this.pathObject,
            apply = this.applyFromWorkstore.bind(this),
            drawUse = this.useDrawGradientCache,
            drawId = this.identifierDrawGradientCache;

        engine.drawImage(this.source, x, y, w, h, ...this.pasteArray);

        if (drawUse) apply(engine, drawId);
        else engine.stroke(p);
    }
};

P.checkHitReturn = function (x, y) {

    if (this.checkHitIgnoreTransparency) {

        const img = this.stashedImageData;

        if (img) {

            const index = (((y * img.width) + x) * 4) + 3;

            if (img.data[index]) {

                return {
                    x: x,
                    y: y,
                    artefact: this
                };
            }
        }
        return false;
    }
    else {

        return {
            x: x,
            y: y,
            artefact: this
        };
    }
};

export const makePicture = function (items) {

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

constructors.Picture = Picture;