Cog factory

import { constructors } from '../core/library.js';
import { mergeOver, Ωempty } from '../core/utilities.js';

import { requestVector, releaseVector } from './vector.js';

import baseMix from '../mixin/base.js';
import shapeMix from '../mixin/shapeBasic.js';

const Cog = function (items = Ωempty) {

    this.shapeInit(items);
    return this;
};

let P = Cog.prototype = Object.create(Object.prototype);
P.type = 'Cog';
P.lib = 'entity';
P.isArtefact = true;
P.isAsset = false;

P = baseMix(P);
P = shapeMix(P);

let defaultAttributes = {

    outerRadius: 0,
    innerRadius: 0,
    outerControlsDistance: 0,
    innerControlsDistance: 0,
    outerControlsOffset: 0,
    innerControlsOffset: 0,
    points: 0,
    twist: 0,
    curve: 'bezier',
};
P.defs = mergeOver(P.defs, defaultAttributes);

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

S.outerRadius = function (item) {

    this.outerRadius = item;
    this.updateDirty();
};
D.outerRadius = function (item) {

    this.outerRadius += item;
    this.updateDirty();
};
S.innerRadius = function (item) {

    this.innerRadius = item;
    this.updateDirty();
};
D.innerRadius = function (item) {

    this.innerRadius += item;
    this.updateDirty();
};

S.outerControlsDistance = function (item) {

    this.outerControlsDistance = item;
    this.updateDirty();
};
D.outerControlsDistance = function (item) {

    this.outerControlsDistance += item;
    this.updateDirty();
};
S.innerControlsDistance = function (item) {

    this.innerControlsDistance = item;
    this.updateDirty();
};
D.innerControlsDistance = function (item) {

    this.innerControlsDistance += item;
    this.updateDirty();
};

S.outerControlsOffset = function (item) {

    this.outerControlsOffset = item;
    this.updateDirty();
};
D.outerControlsOffset = function (item) {

    this.outerControlsOffset += item;
    this.updateDirty();
};
S.innerControlsOffset = function (item) {

    this.innerControlsOffset = item;
    this.updateDirty();
};
D.innerControlsOffset = function (item) {

    this.innerControlsOffset += item;
    this.updateDirty();
};

S.points = function (item) {

    this.points = item;
    this.updateDirty();
};
D.points = function (item) {

    this.points += item;
    this.updateDirty();
};

S.twist = function (item) {

    this.twist = item;
    this.updateDirty();
};
D.twist = function (item) {

    this.twist += item;
    this.updateDirty();
};

S.curve = function (item) {

    if (item && ['line', 'quadratic', 'bezier'].indexOf(item) >= 0) {

        this.curve = item;
        this.updateDirty();
    }
    else {

        this.curve = 'bezier';
        this.updateDirty();
    }
};

P.cleanSpecies = function () {

    this.dirtySpecies = false;

    let p = 'M0,0';
    p = this.makeCogPath();

    this.pathDefinition = p;
};

P.makeCogPath = function () {

    let {points, twist, outerRadius, innerRadius, outerControlsDistance, innerControlsDistance, outerControlsOffset, innerControlsOffset, curve} = this;

    let turn = 360 / points,
        xPts = [],
        currentTrailX, currentTrailY, currentPointX, currentPointY, currentLeadX, currentLeadY, 
        controlStartX, controlStartY, deltaX, deltaY, controlEndX, controlEndY,
        myMin, myXoffset, myYoffset, i,
        myPath = '';

    if (outerRadius.substring || innerRadius.substring || outerControlsDistance.substring || innerControlsDistance.substring || outerControlsOffset.substring || innerControlsOffset.substring) {

        let host = this.getHost();

        if (host) {

            let [hW, hH] = host.currentDimensions;

            outerRadius = (outerRadius.substring) ? (parseFloat(outerRadius) / 100) * hW : outerRadius;
            innerRadius = (innerRadius.substring) ? (parseFloat(innerRadius) / 100) * hW : innerRadius;
            outerControlsDistance = (outerControlsDistance.substring) ? (parseFloat(outerControlsDistance) / 100) * hW : outerControlsDistance;
            innerControlsDistance = (innerControlsDistance.substring) ? (parseFloat(innerControlsDistance) / 100) * hW : innerControlsDistance;
            outerControlsOffset = (outerControlsOffset.substring) ? (parseFloat(outerControlsOffset) / 100) * hW : outerControlsOffset;
            innerControlsOffset = (innerControlsOffset.substring) ? (parseFloat(innerControlsOffset) / 100) * hW : innerControlsOffset;
        } 
    }

    let outerPoint = requestVector({x: 0, y: -outerRadius}),
        innerPoint = requestVector({x: 0, y: -innerRadius}),
        outerPointLead = requestVector({x: outerControlsDistance + outerControlsOffset, y: -outerRadius}),
        innerPointTrail = requestVector({x: -innerControlsDistance + innerControlsOffset, y: -innerRadius}),
        innerPointLead = requestVector({x: innerControlsDistance + innerControlsOffset, y: -innerRadius}),
        outerPointTrail = requestVector({x: -outerControlsDistance + outerControlsOffset, y: -outerRadius});

    innerPointTrail.rotate(-turn/2);
    innerPointTrail.rotate(twist);
    innerPoint.rotate(-turn/2);
    innerPoint.rotate(twist);
    innerPointLead.rotate(-turn/2);
    innerPointLead.rotate(twist);

    currentPointX = outerPoint.x;
    currentPointY = outerPoint.y;

    xPts.push(currentPointX);

    if (curve == 'bezier') {

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

            deltaX = parseFloat((outerPointLead.x - currentPointX).toFixed(1));
            deltaY = parseFloat((outerPointLead.y - currentPointY).toFixed(1));
            myPath += `${deltaX},${deltaY} `;

            innerPointTrail.rotate(turn);
            innerPoint.rotate(turn);
            innerPointLead.rotate(turn);

            deltaX = parseFloat((innerPointTrail.x - currentPointX).toFixed(1));
            deltaY = parseFloat((innerPointTrail.y - currentPointY).toFixed(1));
            myPath += `${deltaX},${deltaY} `;

            deltaX = parseFloat((innerPoint.x - currentPointX).toFixed(1));
            currentPointX += deltaX;
            xPts.push(currentPointX);
            deltaY = parseFloat((innerPoint.y - currentPointY).toFixed(1));
            currentPointY += deltaY;
            myPath += `${deltaX},${deltaY} `;

            deltaX = parseFloat((innerPointLead.x - currentPointX).toFixed(1));
            deltaY = parseFloat((innerPointLead.y - currentPointY).toFixed(1));
            myPath += `${deltaX},${deltaY} `;

            outerPointTrail.rotate(turn);
            outerPoint.rotate(turn);
            outerPointLead.rotate(turn);

            deltaX = parseFloat((outerPointTrail.x - currentPointX).toFixed(1));
            deltaY = parseFloat((outerPointTrail.y - currentPointY).toFixed(1));
            myPath += `${deltaX},${deltaY} `;

            deltaX = parseFloat((outerPoint.x - currentPointX).toFixed(1));
            currentPointX += deltaX;
            xPts.push(currentPointX);
            deltaY = parseFloat((outerPoint.y - currentPointY).toFixed(1));
            currentPointY += deltaY;
            myPath += `${deltaX},${deltaY} `;
        }
    }
    else if (curve == 'quadratic') {

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

            deltaX = parseFloat((outerPointLead.x - currentPointX).toFixed(1));
            deltaY = parseFloat((outerPointLead.y - currentPointY).toFixed(1));
            myPath += `${deltaX},${deltaY} `;

            innerPoint.rotate(turn);
            innerPointLead.rotate(turn);

            deltaX = parseFloat((innerPoint.x - currentPointX).toFixed(1));
            currentPointX += deltaX;
            xPts.push(currentPointX);
            deltaY = parseFloat((innerPoint.y - currentPointY).toFixed(1));
            currentPointY += deltaY;
            myPath += `${deltaX},${deltaY} `;

            deltaX = parseFloat((innerPointLead.x - currentPointX).toFixed(1));
            deltaY = parseFloat((innerPointLead.y - currentPointY).toFixed(1));
            myPath += `${deltaX},${deltaY} `;

            outerPoint.rotate(turn);
            outerPointLead.rotate(turn);

            deltaX = parseFloat((outerPoint.x - currentPointX).toFixed(1));
            currentPointX += deltaX;
            xPts.push(currentPointX);
            deltaY = parseFloat((outerPoint.y - currentPointY).toFixed(1));
            currentPointY += deltaY;
            myPath += `${deltaX},${deltaY} `;
        }
    }
    else {

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

            deltaX = parseFloat((outerPointLead.x - currentPointX).toFixed(1));
            currentPointX += deltaX;
            xPts.push(currentPointX);
            deltaY = parseFloat((outerPointLead.y - currentPointY).toFixed(1));
            currentPointY += deltaY;
            myPath += `${deltaX},${deltaY} `;

            innerPointTrail.rotate(turn);
            innerPoint.rotate(turn);
            innerPointLead.rotate(turn);

            deltaX = parseFloat((innerPointTrail.x - currentPointX).toFixed(1));
            currentPointX += deltaX;
            xPts.push(currentPointX);
            deltaY = parseFloat((innerPointTrail.y - currentPointY).toFixed(1));
            currentPointY += deltaY;
            myPath += `${deltaX},${deltaY} `;

            deltaX = parseFloat((innerPoint.x - currentPointX).toFixed(1));
            currentPointX += deltaX;
            xPts.push(currentPointX);
            deltaY = parseFloat((innerPoint.y - currentPointY).toFixed(1));
            currentPointY += deltaY;
            myPath += `${deltaX},${deltaY} `;

            deltaX = parseFloat((innerPointLead.x - currentPointX).toFixed(1));
            currentPointX += deltaX;
            xPts.push(currentPointX);
            deltaY = parseFloat((innerPointLead.y - currentPointY).toFixed(1));
            currentPointY += deltaY;
            myPath += `${deltaX},${deltaY} `;

            outerPointTrail.rotate(turn);
            outerPoint.rotate(turn);
            outerPointLead.rotate(turn);

            deltaX = parseFloat((outerPointTrail.x - currentPointX).toFixed(1));
            currentPointX += deltaX;
            xPts.push(currentPointX);
            deltaY = parseFloat((outerPointTrail.y - currentPointY).toFixed(1));
            currentPointY += deltaY;
            myPath += `${deltaX},${deltaY} `;

            deltaX = parseFloat((outerPoint.x - currentPointX).toFixed(1));
            currentPointX += deltaX;
            xPts.push(currentPointX);
            deltaY = parseFloat((outerPoint.y - currentPointY).toFixed(1));
            currentPointY += deltaY;
            myPath += `${deltaX},${deltaY} `;
        }
    }
    releaseVector(outerPoint, outerPointLead, outerPointTrail, innerPoint, innerPointLead, innerPointTrail);

    myMin = Math.min(...xPts);
    myXoffset = Math.abs(myMin).toFixed(1);

    if (curve == 'bezier') return `m${myXoffset},0c${myPath}z`;
    if (curve == 'quadratic') return `m${myXoffset},0q${myPath}z`;
    return `m${myXoffset},0l${myPath}z`;
};

const makeCog = function (items) {

    if (!items) return false;
    items.species = 'cog';
    return new Cog(items);
};

constructors.Cog = Cog;

export {
    makeCog,
};