/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes} checked by tsc
 */
/**
 * Copyright (C) 2018 Michael Czechowski <mail@dailysh.it>
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the Free
 * Software Foundation; version 2.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
 * more details.
 *
 * You should have received a copy of the GNU General Public License along with
 * this program; if not, write to the Free Software Foundation, Inc., 51
 * Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 */
import { ViewChild, Component, Input, Output, EventEmitter, HostListener } from '@angular/core';
import { NlsCanvasService } from './../services/canvas.service';
import { NlsHistoryService } from './../services/history.service';
import { NlsMathService } from './../services/math.service';
import { NlsGraphService } from './../services/graph.service';
/** @type {?} */
const RESIZING_TIMEOUT = 800;
export class NlsGraphsComponent {
    /**
     * @param {?} canvasService
     * @param {?} historyService
     * @param {?} math
     * @param {?} graphService
     */
    constructor(canvasService, historyService, math, graphService) {
        this.canvasService = canvasService;
        this.historyService = historyService;
        this.math = math;
        this.graphService = graphService;
        this.svgChange = new EventEmitter();
        this.graphChange = new EventEmitter();
        this.genLoadedAllGraphs = this.countLoadedGraphs();
        this.resizingWindow = false;
    }
    /**
     * @param {?} event
     * @return {?}
     */
    onResize(event) {
        clearTimeout(this.resizingWindow);
        this.resizingWindow = setTimeout(() => {
            this.canvas = this.adjustCanvas();
            this.matrix = this.calcMatrix();
            this.updateGraphs();
        }, RESIZING_TIMEOUT);
    }
    /**
     * @param {?} changes
     * @return {?}
     */
    ngOnChanges(changes) {
        this.canvas = this.adjustCanvas();
        this.matrix = this.calcMatrix();
        if (changes["config"]) {
            this.updateGraphs();
        }
        if (this.restoredHistory && this.restoredHistory.hash !== this.hash) {
            this.restoreGraph();
        }
    }
    /**
     * @return {?}
     */
    restoreGraph() {
        this.graphs = this.restoredHistory.graphs;
        this.hash = this.restoredHistory.hash;
    }
    /**
     * @return {?}
     */
    saveHistory() {
        this.hash = this.historyService.hash(this.graphs);
        this.historyService.save(this.graphs, this.config);
    }
    /**
     * @return {?}
     */
    saveGraph() {
        this.graphService.set(this.graphs);
    }
    /**
     * @return {?}
     */
    updateGraphs() {
        /** @type {?} */
        const genShiftStart = this.shiftPoint(this.matrix.start, this.config.vectors.start);
        /** @type {?} */
        const genShiftEnd = this.shiftPoint(this.matrix.end, this.config.vectors.end, false);
        console.log(this.matrix);
        /** @type {?} */
        const curveList = [
            {
                color: this.config.colors.primary,
                start: genShiftStart.next().value,
                end: genShiftEnd.next().value
            },
            {
                color: this.config.colors.secondary,
                start: genShiftEnd.next().value,
                end: genShiftStart.next().value
            }
        ];
        this.graphs = curveList.map(curve => {
            return Object.assign({}, this.adjustGraph(curve), { spread: this.config.spread, interval: this.config.interval });
        });
        this.hash = this.historyService.hash(this.graphs);
        this.saveHistory();
        this.saveGraph();
    }
    /**
     * @param {?} curve
     * @return {?}
     */
    adjustGraph(curve) {
        return Object.assign(curve, {
            stroke: this.config.stroke,
            start: Object.assign(curve.start, {
                direction: this.genVectorPoint(curve.start.point, curve.start.vector)
            }),
            end: Object.assign(curve.end, {
                direction: this.genVectorPoint(curve.end.point, curve.end.vector)
            }),
            nodes: this.genRandomPoints(this.config.nodes)
        });
    }
    /**
     * @param {?} num
     * @return {?}
     */
    genRandomPoints(num) {
        /** @type {?} */
        const generatedPoints = [];
        for (let i = 0; i < this.config.nodes; i++) {
            generatedPoints.push(this.math.randomPoint(this.matrix, this.config.overlap));
        }
        return generatedPoints;
    }
    /**
     * @param {?} x
     * @return {?}
     */
    flipflop(x) {
        return (x === 'start') ? 'end' : 'start';
    }
    /**
     * @return {?}
     */
    adjustCanvas() {
        this.canvasService.set(this.canvas);
        this.canvasService.adjustToWindow();
        return this.svgElementRef.nativeElement;
    }
    /**
     * @return {?}
     */
    calcMatrix() {
        /** @type {?} */
        const canvasWidth = this.canvas.getBoundingClientRect().width;
        /** @type {?} */
        const canvasHeight = this.canvas.getBoundingClientRect().height;
        /** @type {?} */
        const totalArea = Math.abs(canvasWidth * canvasHeight);
        /** @type {?} */
        const totalCenter = this.math.centerOfArea(canvasWidth, canvasHeight);
        return {
            start: {
                x: 0,
                y: canvasHeight - this.config.vectors.spacing - this.config.margin.y
            },
            end: {
                x: canvasWidth - this.config.vectors.spacing - this.config.margin.x,
                y: 0
            },
            width: canvasWidth,
            height: canvasHeight,
            center: totalCenter
        };
    }
    /**
     * @param {?} point
     * @param {?} vector
     * @return {?}
     */
    genVectorPoint(point, vector) {
        /** @type {?} */
        const range = this.math.Δ(this.matrix.start, this.matrix.end) * this.config.vectors.range;
        return {
            x: range * Math.sin(Math.PI * vector) + point.x,
            y: range * Math.cos(Math.PI * vector) + point.y
        };
    }
    /**
     * @param {?} point
     * @param {?} vector
     * @param {?=} startPositive
     * @return {?}
     */
    *shiftPoint(point, vector, startPositive = true) {
        /** @type {?} */
        const genShiftX = this.shiftNumber(this.config.vectors.spacing, vector, startPositive);
        /** @type {?} */
        const genShiftY = this.shiftNumber(this.config.vectors.spacing, vector, startPositive);
        while (true) {
            yield {
                point: {
                    x: Math.cos(Math.PI * vector) * genShiftX.next().value + point.x,
                    y: Math.sin(Math.PI * vector) * genShiftY.next().value + point.y,
                },
                vector: vector
            };
        }
    }
    /**
     * @param {?} space
     * @param {?} vector
     * @param {?=} startPositive
     * @return {?}
     */
    *shiftNumber(space, vector, startPositive = true) {
        /** @type {?} */
        let current = 0;
        /** @type {?} */
        let index = 0;
        /** @type {?} */
        const sign = this.math.flipSign(startPositive);
        while (true) {
            yield current = sign.next().value * index * space + current;
            index++;
        }
    }
    /**
     * @param {?} guillocheElement
     * @return {?}
     */
    prepareGuillocheExport(guillocheElement) {
        if (this.genLoadedAllGraphs.next().value) {
            this.svgChange.emit(this.svgElementRef);
        }
    }
    /**
     * @return {?}
     */
    *countLoadedGraphs() {
        /** @type {?} */
        let cycles = 1;
        while (true) {
            if (cycles < this.graphs.length) {
                yield false;
                cycles++;
            }
            else {
                yield true;
                cycles = 1;
            }
        }
    }
}
NlsGraphsComponent.decorators = [
    { type: Component, args: [{
                selector: 'nls-graphs',
                template: `<svg #svg width="100%" height="100%" xmlns="http://www.w3.org/2000/svg"
version="1.1" shape-rendering="geometricPrecision">
  <g nlsGuilloche *ngFor="let graph of graphs" [graph]="graph" [animation]="animation"></g>
</svg>
`,
                styles: [`:host{position:absolute;width:100%;height:100%;top:0;left:0;overflow:hidden}`]
            },] },
];
/** @nocollapse */
NlsGraphsComponent.ctorParameters = () => [
    { type: NlsCanvasService },
    { type: NlsHistoryService },
    { type: NlsMathService },
    { type: NlsGraphService }
];
NlsGraphsComponent.propDecorators = {
    config: [{ type: Input }],
    restoredHistory: [{ type: Input }],
    animation: [{ type: Input }],
    svgChange: [{ type: Output }],
    graphChange: [{ type: Output }],
    svgElementRef: [{ type: ViewChild, args: ['svg',] }],
    onResize: [{ type: HostListener, args: ['window:resize', ['$event'],] }]
};
function NlsGraphsComponent_tsickle_Closure_declarations() {
    /** @type {?} */
    NlsGraphsComponent.prototype.canvas;
    /** @type {?} */
    NlsGraphsComponent.prototype.matrix;
    /** @type {?} */
    NlsGraphsComponent.prototype.graphs;
    /** @type {?} */
    NlsGraphsComponent.prototype.windowHeight;
    /** @type {?} */
    NlsGraphsComponent.prototype.windowWidth;
    /** @type {?} */
    NlsGraphsComponent.prototype.genShiftPoint;
    /** @type {?} */
    NlsGraphsComponent.prototype.genLoadedAllGraphs;
    /** @type {?} */
    NlsGraphsComponent.prototype.hash;
    /** @type {?} */
    NlsGraphsComponent.prototype.resizingWindow;
    /** @type {?} */
    NlsGraphsComponent.prototype.config;
    /** @type {?} */
    NlsGraphsComponent.prototype.restoredHistory;
    /** @type {?} */
    NlsGraphsComponent.prototype.animation;
    /** @type {?} */
    NlsGraphsComponent.prototype.svgChange;
    /** @type {?} */
    NlsGraphsComponent.prototype.graphChange;
    /** @type {?} */
    NlsGraphsComponent.prototype.svgElementRef;
    /** @type {?} */
    NlsGraphsComponent.prototype.canvasService;
    /** @type {?} */
    NlsGraphsComponent.prototype.historyService;
    /** @type {?} */
    NlsGraphsComponent.prototype.math;
    /** @type {?} */
    NlsGraphsComponent.prototype.graphService;
}

//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"graphs.component.js","sourceRoot":"ng://nls-guilloche/","sources":["nls/components/graphs.component.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Copyright (C) 2018 Michael Czechowski <mail@dailysh.it>\n * This program is free software; you can redistribute it and/or modify it\n * under the terms of the GNU General Public License as published by the Free\n * Software Foundation; version 2.\n *\n * This program is distributed in the hope that it will be useful, but WITHOUT\n * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or\n * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for\n * more details.\n *\n * You should have received a copy of the GNU General Public License along with\n * this program; if not, write to the Free Software Foundation, Inc., 51\n * Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.\n */\n\nimport { ViewChild, Component, Input, Output, SimpleChanges, OnChanges, EventEmitter, HostListener } from '@angular/core';\nimport { Observable, interval } from 'rxjs';\nimport * as Selection from 'd3-selection';\nimport * as Shape from 'd3-shape';\nimport * as Random from 'd3-random';\nimport * as Drag from 'd3-drag';\n\nimport { Graph } from './../models/graph.model';\nimport { Config } from './../models/config.model';\nimport { Point } from './../models/point.model';\nimport { NlsCanvasService } from './../services/canvas.service';\nimport { NlsHistoryService } from './../services/history.service';\nimport { NlsMathService } from './../services/math.service';\nimport { NlsGuillocheDirective } from './../directives/guilloche.directive';\nimport { NlsGraphService } from './../services/graph.service';\n\nconst RESIZING_TIMEOUT = 800;\n\n@Component({\n  selector: 'nls-graphs',\n  template: `<svg #svg width=\"100%\" height=\"100%\" xmlns=\"http://www.w3.org/2000/svg\"\nversion=\"1.1\" shape-rendering=\"geometricPrecision\">\n  <g nlsGuilloche *ngFor=\"let graph of graphs\" [graph]=\"graph\" [animation]=\"animation\"></g>\n</svg>\n`,\n  styles: [`:host{position:absolute;width:100%;height:100%;top:0;left:0;overflow:hidden}`]\n})\nexport class NlsGraphsComponent implements OnChanges {\n\n  public canvas: any | null;\n  public matrix: any | null;\n  public graphs: Graph[];\n  public windowHeight: number | null;\n  public windowWidth: number | null;\n\n  private genShiftPoint: any | null;\n  private genLoadedAllGraphs: any | null;\n  private hash: string;\n  private resizingWindow: any;\n\n  @Input() config: Config;\n  @Input() restoredHistory: any;\n  @Input() animation: boolean;\n  @Output() svgChange = new EventEmitter();\n  @Output() graphChange = new EventEmitter();\n  @ViewChild('svg') svgElementRef;\n\n  @HostListener('window:resize', ['$event'])\n  onResize(event) {\n    clearTimeout(this.resizingWindow);\n\n    this.resizingWindow = setTimeout(() => {\n      this.canvas = this.adjustCanvas();\n      this.matrix = this.calcMatrix();\n      this.updateGraphs();\n    }, RESIZING_TIMEOUT);\n  }\n\n  constructor(\n    private canvasService: NlsCanvasService,\n    private historyService: NlsHistoryService,\n    private math: NlsMathService,\n    private graphService: NlsGraphService\n  ) {\n    this.genLoadedAllGraphs = this.countLoadedGraphs();\n    this.resizingWindow = false;\n  }\n\n  ngOnChanges(changes: SimpleChanges) {\n    this.canvas = this.adjustCanvas();\n    this.matrix = this.calcMatrix();\n\n    if (changes.config) {\n      this.updateGraphs();\n    }\n\n    if (this.restoredHistory && this.restoredHistory.hash !== this.hash) {\n      this.restoreGraph();\n    }\n  }\n\n  private restoreGraph() {\n    this.graphs = this.restoredHistory.graphs;\n    this.hash = this.restoredHistory.hash;\n  }\n\n  private saveHistory() {\n    this.hash = this.historyService.hash(this.graphs);\n    this.historyService.save(this.graphs, this.config);\n  }\n\n  private saveGraph() {\n    this.graphService.set(this.graphs);\n  }\n\n  private updateGraphs(): void {\n    const genShiftStart = this.shiftPoint(this.matrix.start, this.config.vectors.start);\n    const genShiftEnd = this.shiftPoint(this.matrix.end, this.config.vectors.end, false);\n\n    console.log(this.matrix);\n\n    const curveList = [\n      {\n        color: this.config.colors.primary,\n        start: genShiftStart.next().value,\n        end: genShiftEnd.next().value\n        // start: {\n        //   point: this.matrix.start,\n        //   vector: this.config.vectors.start\n        // },\n        // end: {\n        //   point: this.matrix.end,\n        //   vector: this.config.vectors.end\n        // }\n      },\n      {\n        color: this.config.colors.secondary,\n        start: genShiftEnd.next().value,\n        end: genShiftStart.next().value\n        // end: {\n        //   point: this.matrix.start,\n        //   vector: this.config.vectors.start\n        // },\n        // start: {\n        //   point: this.matrix.end,\n        //   vector: this.config.vectors.end\n        // }\n      }\n    ];\n\n    this.graphs = curveList.map(curve => {\n      return {\n        ...this.adjustGraph(curve),\n        spread: this.config.spread,\n        interval: this.config.interval\n      };\n    });\n    this.hash = this.historyService.hash(this.graphs);\n    this.saveHistory();\n    this.saveGraph();\n  }\n\n  private adjustGraph(curve) {\n    return Object.assign(curve, {\n      stroke: this.config.stroke,\n      start: Object.assign(curve.start, {\n        direction: this.genVectorPoint(curve.start.point, curve.start.vector)\n      }),\n      end: Object.assign(curve.end, {\n        direction: this.genVectorPoint(curve.end.point, curve.end.vector)\n      }),\n      nodes: this.genRandomPoints(this.config.nodes)\n    });\n  }\n\n  private genRandomPoints(num: number) {\n    const generatedPoints = [];\n\n    for (let i = 0; i < this.config.nodes; i++) {\n      generatedPoints.push(this.math.randomPoint(this.matrix, this.config.overlap));\n    }\n\n    return generatedPoints;\n  }\n\n  private flipflop(x: string) {\n    return (x === 'start') ? 'end' : 'start';\n  }\n\n  private adjustCanvas(): void {\n    this.canvasService.set(this.canvas);\n    this.canvasService.adjustToWindow();\n\n    return this.svgElementRef.nativeElement;\n  }\n\n  private calcMatrix() {\n    const canvasWidth = this.canvas.getBoundingClientRect().width;\n    const canvasHeight = this.canvas.getBoundingClientRect().height;\n    const totalArea = Math.abs(canvasWidth * canvasHeight);\n    const totalCenter = this.math.centerOfArea(canvasWidth, canvasHeight);\n\n    return {\n      start: {\n        x: 0,\n        y: canvasHeight - this.config.vectors.spacing - this.config.margin.y\n      },\n      end: {\n        x: canvasWidth - this.config.vectors.spacing - this.config.margin.x,\n        y: 0\n      },\n      width: canvasWidth,\n      height: canvasHeight,\n      center: totalCenter\n    };\n  }\n\n  private genVectorPoint(point: Point, vector: number) {\n    const range = this.math.Δ(this.matrix.start, this.matrix.end) * this.config.vectors.range;\n\n    return {\n      x: range * Math.sin(Math.PI * vector) + point.x,\n      y: range * Math.cos(Math.PI * vector) + point.y\n    };\n  }\n\n  private *shiftPoint(point: Point, vector: number, startPositive: boolean = true) {\n    const genShiftX = this.shiftNumber(this.config.vectors.spacing, vector, startPositive);\n    const genShiftY = this.shiftNumber(this.config.vectors.spacing, vector, startPositive);\n\n    while (true) {\n      yield {\n        point: {\n          x: Math.cos(Math.PI * vector) * genShiftX.next().value + point.x,\n          y: Math.sin(Math.PI * vector) * genShiftY.next().value + point.y,\n        },\n        vector: vector\n      };\n    }\n  }\n\n  private *shiftNumber(space: number, vector: number, startPositive: boolean = true) {\n    let current = 0;\n    let index = 0;\n    const sign = this.math.flipSign(startPositive);\n\n    while (true) {\n      yield current = sign.next().value * index * space + current;\n      index++;\n    }\n  }\n\n  public prepareGuillocheExport(guillocheElement) {\n    if (this.genLoadedAllGraphs.next().value) {\n      this.svgChange.emit(this.svgElementRef);\n    }\n  }\n\n  private *countLoadedGraphs() {\n    let cycles = 1;\n\n    while (true) {\n      if (cycles < this.graphs.length) {\n        yield false;\n        cycles++;\n      } else {\n        yield true;\n        cycles = 1;\n      }\n    }\n  }\n}\n"]}