Quadratic factory

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

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

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

import baseMix from '../mixin/base.js';
import shapeMix from '../mixin/shape-basic.js';
import curveMix from '../mixin/shape-curve.js';

import { CONTROL, ENTITY, PATH, QUADRATIC, T_QUADRATIC, ZERO_PATH, ZERO_STR } from '../helper/shared-vars.js';

const CONTROL_PARTICLE = 'controlParticle',
    CONTROL_PATH = 'controlPath',
    CONTROL_PIVOT = 'controlPivot';

const Quadratic = function (items = Ωempty) {

    this.control = makeCoordinate();
    this.currentControl = makeCoordinate();
    this.controlLockTo = 'coord';

    this.curveInit(items);
    this.shapeInit(items);

    this.dirtyControl = true;

    return this;
};

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

baseMix(P);
shapeMix(P);
curveMix(P);

const defaultAttributes = {

    control: null,

    controlPivot: ZERO_STR,
    controlPivotCorner: ZERO_STR,
    controlPivotIndex: -1,
    addControlPivotHandle: false,
    addControlPivotOffset: false,

    controlPath: ZERO_STR,
    controlPathPosition: 0,
    addControlPathHandle: false,
    addControlPathOffset: true,

    controlParticle: ZERO_STR,

    controlLockTo: ZERO_STR,
};
P.defs = mergeOver(P.defs, defaultAttributes);

P.packetCoordinates = pushUnique(P.packetCoordinates, ['control']);
P.packetObjects = pushUnique(P.packetObjects, ['controlPivot', 'controlPath']);

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

S.controlPivot = function (item) {

    this.setControlHelper(item, CONTROL_PIVOT, CONTROL);
    this.updateDirty();
    this.dirtyControl = true;
};

S.controlParticle = function (item) {

    this.setControlHelper(item, CONTROL_PARTICLE, CONTROL);
    this.updateDirty();
    this.dirtyControl = true;
};

S.controlPath = function (item) {

    this.setControlHelper(item, CONTROL_PATH, CONTROL);
    this.updateDirty();
    this.dirtyControl = true;
    this.currentControlPathData = false;
};

S.controlPathPosition = function (item) {

    this.controlPathPosition = item;
    this.dirtyControl = true;
    this.currentControlPathData = false;
    this.dirtyFilterIdentifier = true;
};
D.controlPathPosition = function (item) {

    this.controlPathPosition += item;
    this.dirtyControl = true;
    this.currentControlPathData = false;
    this.dirtyFilterIdentifier = true;
};

G.controlPositionX = function () {

    return this.currentControl[0];
};
G.controlPositionY = function () {

    return this.currentControl[1];
};
G.controlPosition = function () {

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

S.controlX = function (coord) {

    if (coord != null) {

        this.control[0] = coord;
        this.updateDirty();
        this.dirtyControl = true;
        this.currentControlPathData = false;
    }
};
S.controlY = function (coord) {

    if (coord != null) {

        this.control[1] = coord;
        this.updateDirty();
        this.dirtyControl = true;
        this.currentControlPathData = false;
    }
};
S.control = function (x, y) {

    this.setCoordinateHelper(CONTROL, x, y);
    this.updateDirty();
    this.dirtyControl = true;
    this.currentControlPathData = false;
};
D.controlX = function (coord) {

    const c = this.control;
    c[0] = addStrings(c[0], coord);
    this.updateDirty();
    this.dirtyControl = true;
    this.currentControlPathData = false;
};
D.controlY = function (coord) {

    const c = this.control;
    c[1] = addStrings(c[1], coord);
    this.updateDirty();
    this.dirtyControl = true;
    this.currentControlPathData = false;
};
D.control = function (x, y) {

    this.setDeltaCoordinateHelper(CONTROL, x, y);
    this.updateDirty();
    this.dirtyControl = true;
    this.currentControlPathData = false;
};

S.controlLockTo = function (item) {

    this.controlLockTo = item;
    this.updateDirty();
    this.dirtyControlLock = true;
    this.currentControlPathData = false;
};

P.cleanSpecies = function () {

    this.dirtySpecies = false;
    this.pathDefinition = this.makeQuadraticPath();
};

P.makeQuadraticPath = function () {

    const [startX, startY] = this.currentStampPosition;
    const [controlX, controlY] = this.currentControl;
    const [endX, endY] = this.currentEnd;

    return `${ZERO_PATH}q${(controlX - startX).toFixed(2)},${(controlY - startY).toFixed(2)} ${(endX - startX).toFixed(2)},${(endY - startY).toFixed(2)}`;
};

P.cleanDimensions = function () {

    this.dirtyDimensions = false;
    this.dirtyHandle = true;
    this.dirtyOffset = true;

    this.dirtyStart = true;
    this.dirtyControl = true;
    this.dirtyEnd = true;

    this.dirtyFilterIdentifier = true;
};

P.preparePinsForStamp = function () {

    const dirtyPins = this.dirtyPins,
        ePivot = this.endPivot,
        ePath = this.endPath,
        cPivot = this.controlPivot,
        cPath = this.controlPath;

    for (let i = 0, iz = dirtyPins.length, name; i < iz; i++) {

        name = dirtyPins[i];

        if ((cPivot && cPivot.name === name) || (cPath && cPath.name === name)) {

            this.dirtyControl = true;
            if (this.controlLockTo.includes(PATH)) this.currentControlPathData = false;
        }

        if ((ePivot && ePivot.name === name) || (ePath && ePath.name === name)) {

            this.dirtyEnd = true;
            if (this.endLockTo.includes(PATH)) this.currentEndPathData = false;
        }
    }
    dirtyPins.length = 0;
};

export const makeQuadratic = function (items = Ωempty) {

    if (!items) return false;
    items.species = QUADRATIC;
    return new Quadratic(items);
};

constructors.Quadratic = Quadratic;