Wheel factory

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

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

import baseMix from '../mixin/base.js';
import entityMix from '../mixin/entity.js';

import { _radian, DIMENSIONS, ENTITY, PC } from '../helper/shared-vars.js';

const T_WHEEL = 'Wheel';

const ensureFloat = (val, precision) => {

    val = parseFloat(val);

    if (!isa_number(val)) val = 0;
    if (!isa_number(precision)) precision = 0;

    return parseFloat(val.toFixed(precision));
};

const Wheel = function (items = Ωempty) {

    if (!xto(items.dimensions, items.width, items.height, items.radius)) items.radius = 5;

    this.currentRadius = 5;

    this.entityInit(items);

    return this;
};

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

baseMix(P);
entityMix(P);

const defaultAttributes = {

    radius: 5,

    startAngle: 0,
    endAngle: 360,

    clockwise: true,

    includeCenter: false,

    closed: true,
};
P.defs = mergeOver(P.defs, defaultAttributes);

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

S.width = function (val) {

    if (val != null) {

        const dims = this.dimensions;

        dims[0] = dims[1] = val;
        this.dimensionsHelper();
    }
};
D.width = function (val) {

    const dims = this.dimensions;

    dims[0] = dims[1] = addStrings(dims[0], val);
    this.dimensionsHelper();
};

S.height = function (val) {

    if (val != null) {

        const dims = this.dimensions;

        dims[0] = dims[1] = val;
        this.dimensionsHelper();
    }
};
D.height = function (val) {

    const dims = this.dimensions;

    dims[0] = dims[1] = addStrings(dims[0], val);
    this.dimensionsHelper();
};

S.dimensions = function (w, h) {

    this.setCoordinateHelper(DIMENSIONS, w, h);
    this.dimensionsHelper();
};
D.dimensions = function (w, h) {

    this.setDeltaCoordinateHelper(DIMENSIONS, w, h);
    this.dimensionsHelper();
}

S.radius = function (val) {

    this.radius = val;
    this.radiusHelper();
};
D.radius = function (val) {

    this.radius = addStrings(this.radius, val);
    this.radiusHelper();
};

S.startAngle = function (val) {

    this.startAngle = ensureFloat(val, 4);
    this.dirtyPathObject = true;
    this.dirtyFilterIdentifier = true;
    this.dirtyDrawGradientCache = true;
    this.dirtyfillGradientCache = true;
};
D.startAngle = function (val) {

    this.startAngle += ensureFloat(val, 4);
    this.dirtyPathObject = true;
    this.dirtyFilterIdentifier = true;
    this.dirtyDrawGradientCache = true;
    this.dirtyfillGradientCache = true;
};

S.endAngle = function (val) {

    this.endAngle = ensureFloat(val, 4);
    this.dirtyPathObject = true;
    this.dirtyFilterIdentifier = true;
    this.dirtyDrawGradientCache = true;
    this.dirtyfillGradientCache = true;
};
D.endAngle = function (val) {

    this.endAngle += ensureFloat(val, 4);
    this.dirtyPathObject = true;
    this.dirtyFilterIdentifier = true;
    this.dirtyDrawGradientCache = true;
    this.dirtyfillGradientCache = true;
};

S.closed = function (bool) {

    if(xt(bool)) {

        this.closed = !!bool;
        this.dirtyPathObject = true;
        this.dirtyFilterIdentifier = true;
        this.dirtyDrawGradientCache = true;
        this.dirtyfillGradientCache = true;
    }
};

S.includeCenter = function (bool) {

    if(xt(bool)) {

        this.includeCenter = !!bool;
        this.dirtyPathObject = true;
        this.dirtyFilterIdentifier = true;
        this.dirtyDrawGradientCache = true;
        this.dirtyfillGradientCache = true;
    }
};

S.clockwise = function (bool) {

    if(xt(bool)) {

        this.clockwise = !!bool;
        this.dirtyPathObject = true;
        this.dirtyFilterIdentifier = true;
        this.dirtyDrawGradientCache = true;
        this.dirtyfillGradientCache = true;
    }
};

P.dimensionsHelper = function () {

    const width = this.dimensions[0];

    if (width.substring) this.radius = `${(parseFloat(width) / 2)}%`;
    else this.radius = (width / 2);

    this.dirtyDimensions = true;
    this.dirtyFilterIdentifier = true;
    this.dirtyDrawGradientCache = true;
    this.dirtyfillGradientCache = true;
};
P.radiusHelper = function () {

    const radius = this.radius,
        dims = this.dimensions;

    if (radius.substring) dims[0] = dims[1] = (parseFloat(radius) * 2) + PC;
    else dims[0] = dims[1] = (radius * 2);

    this.dirtyDimensions = true;
    this.dirtyFilterIdentifier = true;
    this.dirtyDrawGradientCache = true;
    this.dirtyfillGradientCache = true;
};

P.cleanDimensionsAdditionalActions = function () {

    const radius = this.radius,
        dims = this.currentDimensions,
        calculatedRadius = (radius.substring) ? (parseFloat(radius) / 100) * dims[0] : radius;

    if (dims[0] !== calculatedRadius * 2) {

        dims[1] = dims[0];
        this.currentRadius = dims[0] / 2;
    }
    else this.currentRadius = calculatedRadius;
};

P.cleanPathObject = function () {

    this.dirtyPathObject = false;

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

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

        const handle = this.currentStampHandlePosition,
            scale = this.currentScale,
            radius = this.currentRadius * scale,
            x = radius - (handle[0] * scale),
            y = radius - (handle[1] * scale),
            starts = this.startAngle * _radian,
            ends = this.endAngle * _radian;

        p.arc(x, y, radius, starts, ends, !this.clockwise);

        if (this.includeCenter) {

            p.lineTo(x, y);
            p.closePath();
        }
        else if (this.closed) p.closePath();
    }
};

export const makeWheel = function (items) {

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

constructors.Wheel = Wheel;