busy-web/ember-date-time

/**
 * @module components
 *
 */
import $ from 'jquery';
import { Promise as EmberPromise, resolve } from 'rsvp';
import { observer, computed, get, getWithDefault, set } from '@ember/object';
import { isNone, isEmpty } from '@ember/utils';
//import { on } from '@ember/object/evented';
import { run, later } from '@ember/runloop';
import TextField from "@ember/component/text-field"
import keyEvent from '@busy-web/ember-date-time/utils/key-event';
import _time from '@busy-web/ember-date-time/utils/time';
import { bind, unbind, isEventLocal } from '@busy-web/ember-date-time/utils/event';

import {
    getCursorPosition,
    getFormatSection,
    longFormatDate
} from '@busy-web/ember-date-time/utils/format';

import {
    YEAR_FLAG,
    MONTH_FLAG,
    //WEEKDAY_FLAG,
    DAY_FLAG,
    HOUR_FLAG,
    MINUTE_FLAG,
    SECONDS_FLAG,
    MERIDIAN_FLAG
} from '@busy-web/ember-date-time/utils/constant';

/***/

/**
 *
 */
export default TextField.extend({
    classNames: ['busyweb', 'emberdatetime', 'p-date-input'],
    classNameBindings: ['isDateInRange::invalid', 'active'],

    type: 'text',

    timestamp: null,
    min: null,
    max: null,

    format: 'MM/DD/YYYY',

    _date: null,
    //value: '',
    active: false,

    name: null,
    selection: 0,
    position: 0,
    defaultFocus: 0,

    isDateInRange: computed('value', function() {
        // before render the position has not been set so
        // resume calculations as if position were 0
        let position = 0;
        if (this.$() && this.$().length && !isEmpty(getData(this.$(), 'format'))) {
            let meta = getMeta(this);
            position = meta.position;
        }

        // when value is null or lastNumIndex is null or lastNumIndex is not 0 then it is in a temp state when invalid is ignored
        if (isNone(getValue(this)) || isNone(position) || position !== 0) {
            return true;
        }

        // get the current value as a date object
        const date = getDate(this);

        // date must be valid and within range to be a valid date range
        if (date.isValid() && this.isDateInBounds(date)) {
            return true;
        }
        return false;
    }),

    /**
     * initialize the value before the component
     * is rendered.
     *
     */
    init(...args) {
        this._super(...args);

        let date;
        if (!isNone(get(this, 'timestamp'))) {
            date = _time(get(this, 'timestamp'));
        } else {
            date = _time();
        }

        setValue(this, date.format(get(this, 'format')));
        set(this, '_date', date.timestamp());
        set(this, '_dateRef', date.timestamp());
    },

    /**
     * initialize the DOM object after render has
     * finished.
     *
     */
    didInsertElement(...args) {
        this._super(...args);

        const target = this.$().get(0);

        bind(
            target,
            'click',
            `ember-date-time.date-input.${this.get('elementId')}`,
            (...args) => this.clickEvent(...args),
            { capture: true, rebind: true }
        );

        bind(
            target,
            'focusin',
            `ember-date-time.date-input.${this.get('elementId')}`,
            (...args) => this.focusInEvent(...args),
            { capture: true, rebind: true }
        );

        bind(
            target,
            'focusout',
            `ember-date-time.date-input.${this.get('elementId')}`,
            (...args) => this.focusOutEvent(...args),
            { capture: true, rebind: true }
        );

        let format = get(this, 'format');
        format = longFormatDate(format);

        setData(this.$(), 'format', format);
        setData(this.$(), 'selection', 0);
        setData(this.$(), 'position', 0);
        setData(this.$(), 'linked', null);

        set(this, 'keyboard', getKeyboardStyle());
    },

    willDestroyElement(...args) {
        this._super(...args);

        const target = this.$().get(0);

        unbind(target, 'click', `ember-date-time.date-input.${this.get('elementId')}`);
        unbind(target, 'focusin', `ember-date-time.date-input.${this.get('elementId')}`);
        unbind(target, 'focusout', `ember-date-time.date-input.${this.get('elementId')}`);
    },

    timestampChange: observer('timestamp', function() {
        let date = _time(get(this, 'timestamp'));
        setValue(this, date.format(get(this, 'format')));
        set(this, '_date', date.timestamp());
        set(this, '_dateRef', date.timestamp());
    }),

    isValid(date) {
        if (date.isValid()) {
            return true;
        }
        return false;
    },

    isDateInBounds(date) {
        const max = get(this, 'max');
        const min = get(this, 'min');
        if (isNone(max) && isNone(min)) {    // no min or max date
            return true;
        } else if (date.timestamp() >= min && isNone(max)) { // date is greater than min date and no max date
            return true;
        } else if (isNone(min) && date.timestamp() <= max) { // no min date and date is less than max date
            return true;
        } else if (date.timestamp() >= min && date.timestamp() <= max) { // date is greater than min date and date is less than max date
            return true;
        }
        return false;
    },

    submitChange(value) {
        if (this.isValid(value)) {
            let val = value.timestamp();
            set(this, '_date', val);
            this.sendAction('onchange', val);
            return true;
        }
        return false;
    },

    finalizeDateSection() {
        let date = getInBoundsDate(getDate(this), get(this, 'min'), get(this, 'max'));
        let selectRound = getWithDefault(this, 'selectRound', 1);
        if (selectRound%date.minute() !== 0) {
            date = _time(_time.round(date.timestamp(), selectRound));
            setValue(this, date.format(get(this, 'format')));
        }

        if (date.isValid()) {
            if (get(this, '_date') !== date.timestamp()) {
                this.submitChange(date);
            }
            setData(this.$(), 'position', 0);
            return true;
        }
        return false;
    },

    fixDate() {
        let { start, end } = getMeta(this);
        let { min, max } = sectionBounds(this);
        let valueSection = getValue(this).substring(start, end);

        if (parseInt(valueSection, 10) < min) {
            valueSection = ('0000000' + min).substr(-(`${max}`.length));
        } else if (parseInt(valueSection, 10) > max) {
            valueSection = `${max}`;
        }
        let newVal = mergeString(getValue(this), valueSection, start, end);

        setValue(this, newVal);
    },

    setDateSection(valueSection, position) {
        let { sectionFormat, start, end } = getMeta(this);
        let { min, max } = sectionBounds(this);

        // moves the start ahead on position when the valueSection
        // is intended for a format section that has less position
        // than the max numbers positions.
        if (sectionFormat.length < `${max}`.length) {
            if (position > sectionFormat.length) {
                start += 1;
            }
        }

        // merge the date string section into the current date string
        let newVal = mergeString(getValue(this), valueSection, start, end);

        setValue(this, newVal);

        // set new number position and handle cursor selection
        let num = parseInt(valueSection, 10);
        if ((position >= `${max}`.length) || (num > min && num*10 > max)) {
            // create a new date object
            this.fixDate();
            this.finalizeDateSection();
            moveToNextPosition(this);
        } else {
            setData(this.$(), 'position', position);
            handleCursor(this, '');
        }
    },

    handleNumberKeys(event, handler) {
        let { sectionFormat, position } = getMeta(this);
        if (!/^(D(o|D))|(M(o|M))|(Y{1,4})|(hh?)|(HH?)|(mm?)|(ss?)$/.test(sectionFormat)) {
            return handler.preventDefault();
        }

        let valueSection = createSection(this, handler.keyName, position, false);
        position = position + 1;

        this.setDateSection(valueSection, position);
        return handler.preventDefault();
    },

    handleLetterKeys(event, handler) {
        let { sectionFormat } = getMeta(this);
        if (!/^(MMMM?|A|a)$/.test(sectionFormat)) {
            return handler.preventDefault();
        }

        if (/^[aA]$/.test(sectionFormat)) {
            meridianLetters(this, handler.keyName);
        } else {
            monthLetters(this, handler.keyName);
        }

        return handler.preventDefault();
    },

    handleDeleteKey(event, handler) {
        let { position } = getMeta(this);
        if (position > 0) {
            let valueSection = createSection(this, 0, position, true);
            position = position - 1;
            this.setDateSection(valueSection, position);
        } else {
            moveToPrevPosition(this).then(result => {
                if (result.isNewInput) {
                    let e = $.Event( 'keydown', { which: event.which } );
                    result.input.trigger(e);
                } else {
                    this.handleDeleteKey(event, handler);
                }
            });
        }
        return handler.preventDefault();
    },

    upDownArrows(keyName) {
        const { sectionFormat, start, end } = getMeta(this);
        const type = sectionFormatType(this);
        let _date = get(this, '_date');

        let isUp = ['ArrowUp', '=', '+'].indexOf(keyName) !== -1;
        let isDown = ['ArrowDown', '-', '_'].indexOf(keyName) !== -1;

        // for am pm up down arrows increase the time or decrease
        // the time accordingly so that the day does not change.
        // So hitting up arrow 2 times will change from 'am' => 'pm' => 'am'
        // and the actual date has not changed.
        if (type === MERIDIAN_FLAG) {
            const substr = getValue(this).substring(start, end);
            if (isUp && substr.toLowerCase() === 'pm') {
                isUp = false;
                isDown = true;
            } else if (isDown && substr.toLowerCase() === 'am') {
                isDown = false;
                isUp = true;
            }
        } else if (/^mm?/.test(type)) {
            if (getWithDefault(this, 'selectRound', 1) > 1) {
                if (isUp) {
                    _date = _time(_date).add(get(this, 'selectRound')-1, 'minutes').timestamp();
                } else {
                    _date = _time(_date).subtract(get(this, 'selectRound')+1, 'minutes').timestamp();
                }
            }
        }

        let val;
        if (isUp) {
            val = _time(_date).addFormatted(1, sectionFormat);
        } else if (isDown) {
            val = _time(_date).subFormatted(1, sectionFormat);
        }

        let bounds = _time.isDateInBounds(val, get(this, 'min'), get(this, 'max'));
        if (bounds.isAfter || bounds.isBefore) {
            if (/^M(M|o)?$/.test(sectionFormat)) {
                if (isUp && !_time.isDateAfter(_time(val).startOf('month'), get(this, 'max'))) {
                    val = val.date(_time(get(this, 'max')).date());
                    bounds = _time.isDateInBounds(val, get(this, 'min'), get(this, 'max'));
                } else if (!isUp && !_time.isDateBefore(_time(val).endOf('month'))) {
                    val = val.date(_time(get(this, 'min')).date());
                    bounds = _time.isDateInBounds(val, get(this, 'min'), get(this, 'max'));
                }
            } else if (/^Y{1,4}$/.test(sectionFormat)) {
                if (isUp && !_time.isDateAfter(_time(val).startOf('year'), get(this, 'max'))) {
                    val = val.date(_time(get(this, 'max')).date());
                    bounds = _time.isDateInBounds(val, get(this, 'min'), get(this, 'max'));
                } else if (!isUp && !_time.isDateBefore(_time(val).endOf('year'))) {
                    val = val.date(_time(get(this, 'min')).date());
                    bounds = _time.isDateInBounds(val, get(this, 'min'), get(this, 'max'));
                }
            }
        }

        if (val) {
            if (!bounds.isBefore && !bounds.isAfter) {
                const newVal = val.format(get(this, 'format'));
                fixSelection(this, newVal);
                setValue(this, newVal);
                handleCursor(this, '');
            } else {
                flashWarn(this);
            }
        }
    },

    handleArrowKeys(event, handler) {
        if (/^[*/><^]$/.test(handler.keyName)) {
            return handler.preventDefault();
        }

        if (handler.keyName === 'ArrowLeft') {
            handleCursor(this, 'prev');
        } else if (handler.keyName === 'ArrowRight') {
            handleCursor(this, 'next');
        } else {
            this.upDownArrows(handler.keyName);
        }

        this.finalizeDateSection();
        return handler.preventDefault();
    },

    focusInEvent(event) {
        //let data = this.$().data();

        // prevent open picker from selecting the wrong section
        //if (!this.$().is(':active') || get(data, 'forceSelection') === true) {
            this.$().data('forceSelection', false);

            let { selection, position } = getMeta(this, this.$());
            handleFocus(this, selection, position, true);
        //}

        let type = sectionFormatType(this);
        this.sendAction('onfocus', event, type);

        let os = getOSType();
        if (os === 'iOS') {
            if (!getData(this.$(), 'overrideFocus')) {
                this.$().blur();
            } else {
                setData(this.$(), 'overrideFocus', false);
            }
        } else if (os === 'Android') {
            this.$().blur();
        }
    },

    focusOutEvent(event) {
        // check if the evt.target is local to this elements main parent
        let isLocal = isEventLocal(event, get(this, 'elementId'), '.emberdatetime');
        if (!isLocal) {
            this.set('active', false);
            this.sendAction('onblur', event);
        }
    },

    clickEvent(event) {
        event.stopPropagation();
        let index = event.target.selectionStart;

        set(this, '__lastType', null);
        handleFocus(this, index, 0);

        let type = sectionFormatType(this);
        this.sendAction('onclick', event, index, type);

        // hand mobile focus
        let os = getOSType();
        if (os === 'iOS' || os === 'Android') {
            setData(this.$(), 'overrideFocus', true);
            later(() => this.$().focus(), 10);
        }
    },

    dragStart() {
        // store the current value so it can be fixed after the
        // drag is complete
        set(this, '__saveDragValue', getValue(this));
    },

    dragEnd() {
        // if the drag has changed the value then
        // replace it with the old value so the date format
        // is not changed
        if (getValue(this) !== get(this, '__saveDragValue')) {
            setValue(this, get(this, '__saveDragValue'));
        }
    },

    keyDown(event) {
        if (isModifierKeyActive(this, event)) {
            return true;
        }

        let handler = keyEvent({ event, disable: ['composition'] });
        if (handler.allowed) {
            if (!handler.throttle) {
                if (handler.type === 'arrow' || handler.type === 'math' || handler.keyName === '_') {
                    return this.handleArrowKeys(event, handler);
                } else if (handler.type === 'number') {
                    return this.handleNumberKeys(event, handler);
                } else if (handler.type === 'letter') {
                    return this.handleLetterKeys(event, handler);
                } else if (handler.keyName === 'Backspace') {
                    return this.handleDeleteKey(event, handler);
                } else if (handler.keyName === 'Tab') {
                    if (this.get('allowTab')) {
                        return this.sendAction('ontabkey', event, handler);
                    } else {
                        this.sendAction('ontabkey', event, handler);
                    }
                } else if (handler.keyName === 'Enter') {
                    this.sendAction('onsubmit', event, get(this, '_date'), handler);
                }
            }
        }
        return handler.preventDefault();
    }
});

function flashWarn(target) {
    const el = target.$().parents('.emberdatetime');
    const className = 'flash-warn';
    el.addClass(className);
    setTimeout(() => el.removeClass(className), 100);
}

function getOSType() {
    if (/(iPhone|iPad|iPod)/.test(window.navigator.userAgent)) {
        return 'iOS';
    } else if (/Android/.test(window.navigator.userAgent)) {
        return 'Android';
    }
}

function getDate(target) {
    let format = getData(target.$(), 'format');

    if (isEmpty(format)) {
        format = get(target, 'format');
        format = longFormatDate(format);
    }

    let value = getValue(target);
    value = value.replace(/[ ]*$/, '');
    ({ value, format } = addFormat(target, format, value));

    return _time(value, format);
}

function addFormat(target, format, value) {
    let dRef = _time(get(target, '_dateRef'));
    let stdTypes = _time.standardFormatTypes();

    Object.keys(stdTypes).forEach((key) => {
        let typeExp = new RegExp(stdTypes[key]);
        if (!typeExp.test(format)) {
            format = format + ' ' + key;
            value = value + ' ' + dRef.format(key);
        }
    });
    return { value, format };
}

function setValue(target, value) {
    set(target, 'value', value.replace(/[ ]*$/, '  '));
}

function getValue(target) {
    return get(target, 'value');
}

function isModifierKeyActive(target, event) {
    let keyboard = getKeyboardStyle();
    if (keyboard === 'MAC' && event.metaKey) {
        return true;
    } else if (keyboard === 'PC' && event.ctrlKey) {
        return true;
    } else if (event.altKey) {
        event.preventDefault();
        return true;
    }
    return false;
}

function getKeyboardStyle() {
    if (/Macintosh/.test(window.navigator.userAgent)) {
        return 'MAC';
    } else {
        return 'PC';
    }
}

function getMeta(target, el) {
    el = el || target.$();
    let format = getData(el, 'format');
    let selection = getData(el, 'selection', 0);
    let position = getData(el, 'position', 0);

    let start, end, sectionFormat;
    let value = getValue(target);
    sectionFormat = getFormatSection(format, value, selection);
    let cursor = getCursorPosition(format, value, selection);
    if (!isNone(cursor)) {
        start = cursor.start;
        end = cursor.end;
    }
    return { format, selection, position, sectionFormat, start, end };
}

function fixSelection(target, val) {
    let { selection } = getMeta(target);
    let value = getValue(target).trim()
    let v1 = value.substr(selection - value.length);
    let v2 = val.substr(selection - val.length);
    if (v2.length > v1.length) {
        setData(target.$(), 'selection', selection+1);
    }
}

function sectionBounds(target) {
    let type = sectionFormatType(target);
    let max, min = 1;
    if (type === DAY_FLAG) {
        const date = _time(get(target, '_date'));
        max = date.daysInMonth();
    } else if (type === MONTH_FLAG) {
        max = 12;
    } else if (type === YEAR_FLAG) {
        max = isNone(get(target, 'max')) ? _time().add(100, 'years').endOf('year').year() : _time(get(target, 'max')).endOf('year').year();
        min = isNone(get(target, 'min')) ? _time().subtract(100, 'years').startOf('year').year() : _time(get(target, 'min')).startOf('year').year();
    } else if (type === HOUR_FLAG) {
        max = 12;
    } else if (type === `m-${HOUR_FLAG}`) {
        min = 0;
        max = 24;
    } else if (type === MINUTE_FLAG) {
        min = 0;
        max = 59;
    } else if (type === SECONDS_FLAG) {
        min = 0;
        max = 59;
    }
    return { min, max }
}

function sectionFormatType(target) {
    const { sectionFormat } = getMeta(target);
    return _time.formatStringType(sectionFormat);
}

function handleFocus(target, index=0, num=0, triggerChange=true) {
    const defaultFocus = get(target, 'defaultFocus') || 0;
    const value = getValue(target);

    if (index >= value.length) {
        index = defaultFocus;
    } else if (index === value.length-1) {
        index = index-1;
    }

    // set cursor index and last num index
    setData(target.$(), 'selection', index);
    setData(target.$(), 'position', num);

    handleCursor(target, '', triggerChange);
    set(target, 'active', true);
}

function handleCursor(target, action='', triggerChange=true) {
    return new EmberPromise(resolve => {
        later(() => {
            const { format, selection } = getMeta(target);
            const value = getValue(target);

            let cursor;
            if (action === 'next') {
                cursor = getCursorPosition(format, value, selection, true, false);
            } else if (action === 'prev') {
                cursor = getCursorPosition(format, value, selection, false, true);
            } else {
                cursor = getCursorPosition(format, value, selection, false, false);
            }

            if (cursor.end !== value.length-1) {
                setSelectionRange(target.$(), cursor.start, cursor.end);
                if (selection !== cursor.start) {
                    setData(target.$(), 'selection', cursor.start);
                }

                // test for section with escape chars and skip the section
                // if they are found.
                let { start, sectionFormat } = getMeta(target);
                if (/^\[([\s\S])*\]$/.test(sectionFormat)) {
                    if (action !== '') {
                        handleCursor(target, action, triggerChange);
                    } else {
                        handleCursor(target, (start === 0 ? 'next' : 'prev'), triggerChange);
                    }
                }

                if (triggerChange) {
                    let lastType = get(target, '__lastType');
                    let type = sectionFormatType(target);
                    if (lastType !== type) {
                        set(target, '__lastType', type);
                        target.sendAction('oncursor', type);
                    }
                }
            } else {
                handleCursor(target, '', triggerChange);
            }

            run(null, resolve, null);
        }, 10);
    });
}

function linkedInputData(target) {
    let inputData = getData(target.$(), 'linked');
    if (isNone(inputData)) {
        let link = get(target, 'name');
        if (!isEmpty(link)) {
            let inputs = $(`input[name=${link}]`);
            let elementId = get(target, 'elementId');
            let self = inputs.filter((key, el) => el.id === elementId);
            let index = inputs.index(self);

            inputData = { inputs, self, index };
            setData(target.$(), 'linked', inputData);
        }
    }
    return inputData;
}

function inputFor(target, type='') {
    let { inputs, index } = linkedInputData(target);

    if (type === 'next') {
        index = index+1;
    } else if (type === 'prev') {
        index = index-1;
    }

    if (index < 0) {
        index = inputs.length-1;
    } else if (index >= inputs.length) {
        index = 0;
    }

    let input = inputs[index];
    return { input, index };
}

function moveToNextPosition(target) {
    const { format, end } = getMeta(target);

    setData(target.$(), 'position', 0);
    if (end === format.length) {
        let { input } = inputFor(target, 'next');
        input = $(input);
        setData(input, 'selection', 0);
        setData(input, 'position', 0);
        input.focus();
        return resolve({ isNewInput: true, input });
    } else {
        return handleCursor(target, 'next').then(() => {
            setData(target.$(), 'position', 0);
            return { isNewInput: false, input: target };
        });
    }
}

function moveToPrevPosition(target) {
    const { start } = getMeta(target);
    if (start === 0) {
        let { input } = inputFor(target, 'prev');
        input = $(input);
        const { sectionFormat, format } = getMeta(input);
        setData(input, 'selection', format.length);
        setData(input, 'position', sectionFormat.length);
        input.focus();
        return EmberPromise(resolve => {
            later(() => {
                run(null, resolve, { isNewInput: true, input });
            }, 1);
        });
    } else {
        return handleCursor(target, 'prev').then(() => {
            const { sectionFormat } = getMeta(target);
            setData(target.$(), 'position', sectionFormat.length);
            return { isNewInput: false, input: target };
        });
    }
}

function meridianLetters(target, keyName) {
    const value = getValue(target);
    let newVal;
    if (/^[aA]$/.test(keyName)) {
        newVal = value.replace(/[AP]M/, 'AM').replace(/[ap]m/, 'am');
    } else if (/^[pP]$/.test(keyName)) {
        newVal = value.replace(/[AP]M/, 'PM').replace(/[ap]m/, 'pm');
    } else if (/^[mM]$/.test(keyName)) {
        target.finalizeDateSection();
        moveToNextPosition(target);
    }

    if (!isEmpty(newVal)) {
        setValue(target, newVal);
        handleCursor(target, '');
    }
}

function monthLetters(target, keyName) {
    const { sectionFormat, position, start, end }  = getMeta(target);
    const value = getValue(target);
    const current = value.substr(start, end-start);
    const localeData = _time.localeData();
    let monthData = localeData._monthsShort;
    if (sectionFormat === 'MMMM') {
        monthData = localeData._months;
    }

    let startStr = current.substr(0, position) + keyName;
    let reg = new RegExp('^' + startStr, 'i');

    let results = monthData.filter(i => reg.test(i));
    let first = results[0];
    if (!isEmpty(first)) {
        let newVal = value.replace(current, first);
        setValue(target, newVal);
        if (results.length > 1) {
            setData(target.$(), 'position', position+1);
        } else {
            target.finalizeDateSection();
            moveToNextPosition(target);
        }
    }
}

function createSection(target, num, position, isReverse=false) {
    const value = getValue(target);
    const { sectionFormat, start, end } = getMeta(target);
    const substr = value.substring(start, end);
    let ds;

    // calculate new date from input
    if (isReverse) {
        ds = shiftRight(substr, num);
    } else {
        ds = shiftLeft(substr, num);
        if (position === 0) {
            let template = `000000000`.slice(0, sectionFormat.length);
            ds = shiftLeft(template, num);
        }
    }
    return ds;
}

function shiftLeft(str, val) {
    return (str + val).substr(1);
}

function shiftRight(str, val) {
    return (val + str).substr(0, str.length);
}

function mergeString(str, insert, start, end) {
    return str.substr(0, start) + insert + str.substr(end);
}

function setSelectionRange(el, start, end) {
    el.get(0).setSelectionRange(start, end);
}

function setData(el, key, value) {
    el.data(key, value);
}

function getData(el, key, defaultValue=null) {
    return el.data(key) || defaultValue;
}


function getInBoundsDate(date, min, max) {
    const adjustTime = (d1, d2) => {
        if (d1.hours() < d2.hours()) d2.hours(d1.hours());
        if (d1.minutes() < d2.minutes()) d2.minutes(d1.minutes());
        if (d1.seconds() < d2.seconds()) d2.seconds(d1.seconds());
        return d2;
    };

    if (_time.isDateAfter(date, max)) {
        return adjustTime(_time(date), _time(max));
    } else if (_time.isDateBefore(date, min)) {
        return adjustTime(_time(min), _time(date));
    }
    return _time(date);
}