"use strict";

function _typeof(obj) {
    if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
        _typeof = function _typeof(obj) {
            return typeof obj;
        };
    } else {
        _typeof = function _typeof(obj) {
            return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
        };
    }
    return _typeof(obj);
}

function _classCallCheck(instance, Constructor) {
    if (!(instance instanceof Constructor)) {
        throw new TypeError("Cannot call a class as a function");
    }
}

function _defineProperties(target, props) {
    for (var i = 0; i < props.length; i++) {
        var descriptor = props[i];
        descriptor.enumerable = descriptor.enumerable || false;
        descriptor.configurable = true;
        if ("value" in descriptor) descriptor.writable = true;
        Object.defineProperty(target, descriptor.key, descriptor);
    }
}

function _createClass(Constructor, protoProps, staticProps) {
    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
    if (staticProps) _defineProperties(Constructor, staticProps);
    return Constructor;
}

var FlipDown = function () {
    function FlipDown(uts) {
        var el = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "flipdown";
        var opt = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};

        _classCallCheck(this, FlipDown);

        if (typeof uts !== "number") {
            throw new Error("FlipDown: Constructor expected unix timestamp, got ".concat(_typeof(uts), " instead."));
        }

        if (_typeof(el) === "object") {
            opt = el;
            el = "flipdown";
        }

        this.version = "0.3.2";
        this.initialised = false;
        this.now = this._getTime();
        this.epoch = uts;
        this.countdownEnded = false;
        this.hasEndedCallback = null;
        this.element = document.getElementById(el);
        this.rotors = [];
        this.rotorLeafFront = [];
        this.rotorLeafRear = [];
        this.rotorTops = [];
        this.rotorBottoms = [];
        this.countdown = null;
        this.daysRemaining = 0;
        this.clockValues = {};
        this.clockStrings = {};
        this.clockValuesAsString = [];
        this.prevClockValuesAsString = [];
        this.opts = this._parseOptions(opt);

        this._setOptions();

        console.log("FlipDown ".concat(this.version, " (Theme: ").concat(this.opts.theme, ")"));
    }

    _createClass(FlipDown, [{
        key: "start",
        value: function start() {
            if (!this.initialised) this._init();
            this.countdown = setInterval(this._tick.bind(this), 1000);
            return this;
        }
    }, {
        key: "ifEnded",
        value: function ifEnded(cb) {
            this.hasEndedCallback = function () {
                cb();
                this.hasEndedCallback = null;
            };

            return this;
        }
    }, {
        key: "_getTime",
        value: function _getTime() {
            return new Date().getTime() / 1000;
        }
    }, {
        key: "_hasCountdownEnded",
        value: function _hasCountdownEnded() {
            if (this.epoch - this.now < 0) {
                this.countdownEnded = true;

                if (this.hasEndedCallback != null) {
                    this.hasEndedCallback();
                    this.hasEndedCallback = null;
                }

                return true;
            } else {
                this.countdownEnded = false;
                return false;
            }
        }
    }, {
        key: "_parseOptions",
        value: function _parseOptions(opt) {
            var headings = ["Days", "Hours", "Minutes", "Seconds"];

            if (opt.headings && opt.headings.length === 4) {
                headings = opt.headings;
            }

            return {
                theme: opt.hasOwnProperty("theme") ? opt.theme : "dark",
                headings: headings
            };
        }
    }, {
        key: "_setOptions",
        value: function _setOptions() {
            this.element.classList.add("flipdown__theme-".concat(this.opts.theme));
        }
    }, {
        key: "_init",
        value: function _init() {
            this.initialised = true;

            if (this._hasCountdownEnded()) {
                this.daysremaining = 0;
            } else {
                this.daysremaining = Math.floor((this.epoch - this.now) / 86400).toString().length;
            }

            var dayRotorCount = this.daysremaining <= 2 ? 2 : this.daysremaining;

            for (var i = 0; i < dayRotorCount + 6; i++) {
                this.rotors.push(this._createRotor(0));
            }

            var dayRotors = [];

            for (var i = 0; i < dayRotorCount; i++) {
                dayRotors.push(this.rotors[i]);
            }

            this.element.appendChild(this._createRotorGroup(dayRotors, 0));
            var count = dayRotorCount;

            for (var i = 0; i < 3; i++) {
                var otherRotors = [];

                for (var j = 0; j < 2; j++) {
                    otherRotors.push(this.rotors[count]);
                    count++;
                }

                this.element.appendChild(this._createRotorGroup(otherRotors, i + 1));
            }

            this.rotorLeafFront = Array.prototype.slice.call(this.element.getElementsByClassName("rotor-leaf-front"));
            this.rotorLeafRear = Array.prototype.slice.call(this.element.getElementsByClassName("rotor-leaf-rear"));
            this.rotorTop = Array.prototype.slice.call(this.element.getElementsByClassName("rotor-top"));
            this.rotorBottom = Array.prototype.slice.call(this.element.getElementsByClassName("rotor-bottom"));

            this._tick();

            this._updateClockValues(true);
            $('#flipdown div:first').addClass('d-none');

            return this;
        }
    }, {
        key: "_createRotorGroup",
        value: function _createRotorGroup(rotors, rotorIndex) {
            var rotorGroup = document.createElement("div");
            rotorGroup.className = "rotor-group";
            var dayRotorGroupHeading = document.createElement("div");
            dayRotorGroupHeading.className = "rotor-group-heading";
            dayRotorGroupHeading.setAttribute("data-before", this.opts.headings[rotorIndex]);
            rotorGroup.appendChild(dayRotorGroupHeading);
            appendChildren(rotorGroup, rotors);
            return rotorGroup;
        }
    }, {
        key: "_createRotor",
        value: function _createRotor() {
            var v = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
            var rotor = document.createElement("div");
            var rotorLeaf = document.createElement("div");
            var rotorLeafRear = document.createElement("figure");
            var rotorLeafFront = document.createElement("figure");
            var rotorTop = document.createElement("div");
            var rotorBottom = document.createElement("div");
            rotor.className = "rotor";
            rotorLeaf.className = "rotor-leaf";
            rotorLeafRear.className = "rotor-leaf-rear";
            rotorLeafFront.className = "rotor-leaf-front";
            rotorTop.className = "rotor-top";
            rotorBottom.className = "rotor-bottom";
            rotorLeafRear.textContent = v;
            rotorTop.textContent = v;
            rotorBottom.textContent = v;
            appendChildren(rotor, [rotorLeaf, rotorTop, rotorBottom]);
            appendChildren(rotorLeaf, [rotorLeafRear, rotorLeafFront]);
            return rotor;
        }
    }, {
        key: "_tick",
        value: function _tick() {
            this.now = this._getTime();
            var diff = this.epoch - this.now <= 0 ? 0 : this.epoch - this.now;
            this.clockValues.d = Math.floor(diff / 86400);
            diff -= this.clockValues.d * 86400;
            this.clockValues.h = Math.floor(diff / 3600);
            diff -= this.clockValues.h * 3600;
            this.clockValues.m = Math.floor(diff / 60);
            diff -= this.clockValues.m * 60;
            this.clockValues.s = Math.floor(diff);

            this._updateClockValues();

            this._hasCountdownEnded();
        }
    }, {
        key: "_updateClockValues",
        value: function _updateClockValues() {
            var _this = this;

            var init = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
            this.clockStrings.d = pad(this.clockValues.d, 2);
            this.clockStrings.h = pad(this.clockValues.h, 2);
            this.clockStrings.m = pad(this.clockValues.m, 2);
            this.clockStrings.s = pad(this.clockValues.s, 2);
            this.clockValuesAsString = (this.clockStrings.d + this.clockStrings.h + this.clockStrings.m + this.clockStrings.s).split("");
            this.rotorLeafFront.forEach(function (el, i) {
                el.textContent = _this.prevClockValuesAsString[i];
            });
            this.rotorBottom.forEach(function (el, i) {
                el.textContent = _this.prevClockValuesAsString[i];
            });

            function rotorTopFlip() {
                var _this2 = this;

                this.rotorTop.forEach(function (el, i) {
                    if (el.textContent != _this2.clockValuesAsString[i]) {
                        el.textContent = _this2.clockValuesAsString[i];
                    }
                });
            }

            function rotorLeafRearFlip() {
                var _this3 = this;

                this.rotorLeafRear.forEach(function (el, i) {
                    if (el.textContent != _this3.clockValuesAsString[i]) {
                        el.textContent = _this3.clockValuesAsString[i];
                        el.parentElement.classList.add("flipped");
                        var flip = setInterval(function () {
                            el.parentElement.classList.remove("flipped");
                            clearInterval(flip);
                        }.bind(_this3), 500);
                    }
                });
            }

            if (!init) {
                setTimeout(rotorTopFlip.bind(this), 500);
                setTimeout(rotorLeafRearFlip.bind(this), 500);
            } else {
                rotorTopFlip.call(this);
                rotorLeafRearFlip.call(this);
            }

            this.prevClockValuesAsString = this.clockValuesAsString;
        }
    }]);

    return FlipDown;
}();

function pad(n, len) {
    n = n.toString();
    return n.length < len ? pad("0" + n, len) : n;
}

function appendChildren(parent, children) {
    children.forEach(function (el) {
        parent.appendChild(el);
    });
}

