//node
import { isNullOrUndefined } from 'util';

//libs
import * as moment from 'moment';
import 'moment/locale/pt-br';

//this

export function formatHHMMSS(valueDate: Date): string {
    if (isNullOrUndefined(valueDate)) {
        return undefined;
    }
    return moment(valueDate).format('HH:mm:ss');
}

export function formatDDMMYYYYHHMMSS(valueDate: Date): string {
    if (isNullOrUndefined(valueDate)) {
        return undefined;
    }
    return moment(valueDate).format('DD/MM/YYYY HH:mm:ss');
}

export function formatDDMMYYYY(valueDate: Date): string {
    if (isNullOrUndefined(valueDate)) {
        return undefined;
    }
    return moment(valueDate).format('L');
}

export function formatYYYYMMDD(valueDate: Date): string {
    if (isNullOrUndefined(valueDate)) {
        return undefined;
    }
    return moment(valueDate).format('YYYY-MM-DD');
}

export function hoje(): Date {
    let momentValue: moment.Moment = moment();
    momentValue.set({ hour: 0, minute: 0, second: 0, millisecond: 0 });

    return momentValue.toDate();
}

export function resetHours(valueDate: Date): Date {
    if (isNullOrUndefined(valueDate)) {
        return undefined;
    }
    let momentValue: moment.Moment = moment(valueDate);
    momentValue.set({ hour: 0, minute: 0, second: 0, millisecond: 0 });

    return momentValue.toDate();
}

export function getNameMes(mes: number): string {
    if (isNullOrUndefined(mes)) {
        return undefined;
    }
    return moment().month(mes).format('MMMM');
}

export function getNameDiaSemana(dia: number, semAcentuacao?: boolean): string {
    if (isNullOrUndefined(dia)) {
        return undefined;
    }
    if (semAcentuacao) {
        let nomeDia: string;
        switch (dia) {
            case 0:
                nomeDia = 'domingo';
                break;
            case 1:
                nomeDia = 'segunda';
                break;
            case 2:
                nomeDia = 'terca';
                break;
            case 3:
                nomeDia = 'quarta';
                break;
            case 4:
                nomeDia = 'quinta';
                break;
            case 5:
                nomeDia = 'sexta';
                break;
            case 6:
                nomeDia = 'sabado';
                break;
        }
        return nomeDia;
    } else {
        return moment().day(dia).format('dddd');
    }
}

export function HHMMSSToDate(value: string, dataDefault?: Date): Date {
    if (isNullOrUndefined(value)) {
        return undefined;
    }
    let momentValue: moment.Moment;
    if (isNullOrUndefined(dataDefault)) {
        dataDefault = new Date();
    }
    momentValue = moment(dataDefault);
    let time = HHMMSSGetHourMinutesSecond(value);
    momentValue.set({ hour: time.hours, minute: time.minutes, seconds: time.seconds, millisecond: 0 });

    return momentValue.toDate();
}

export function HHMMSSGetHourMinutesSecond(value: string): { hours: number, minutes: number, seconds: number } {
    if (isNullOrUndefined(value)) {
        return undefined;
    }
    let regex: RegExp = /(\d{2})[\:](\d{2})[\:](\d{2})|(\d{2})[\:](\d{2})/gi;
    if (regex.exec(value)) {
        value.replace(regex, '$1, $2, $3, $4, $5');
        let hours: number;
        let minutes: number;
        if (RegExp.$1 === '') {
            hours = +RegExp.$4;
            minutes = +RegExp.$5;
        } else {
            hours = +RegExp.$1;
            minutes = +RegExp.$2;
        }

        return { hours: hours, minutes: minutes, seconds: +RegExp.$3 };
    }
}

export function dataConflito(dataInicial: Date, dataFinal: Date, dataInicial_2: Date, dataFinal_2: Date): boolean {
    if (isNullOrUndefined(dataInicial) || isNullOrUndefined(dataFinal) || isNullOrUndefined(dataInicial_2) || isNullOrUndefined(dataFinal_2)) {
        return undefined;
    }
    return (dataInicial < dataInicial_2 && dataFinal >= dataInicial_2)
        || (dataInicial <= dataFinal_2 && dataFinal > dataFinal_2)
        || (dataInicial >= dataInicial_2 && dataFinal <= dataFinal_2)
        || (dataInicial <= dataInicial_2 && dataFinal >= dataFinal_2);
}

export function compareDate(data_1: Date, data_2: Date): boolean {
    if (isNullOrUndefined(data_1) || isNullOrUndefined(data_2)) {
        return undefined;
    }
    return data_1.getDate() === data_2.getDate()
        && data_1.getMonth() === data_2.getMonth()
        && data_1.getFullYear() === data_2.getFullYear();
}

export function compareDateAndTime(data_1: Date, data_2: Date): boolean {
    if (isNullOrUndefined(data_1) || isNullOrUndefined(data_2)) {
        return undefined;
    }
    return data_1.getDate() === data_2.getDate()
        && data_1.getMonth() === data_2.getMonth()
        && data_1.getFullYear() === data_2.getFullYear()
        && data_1.getHours() === data_2.getHours()
        && data_1.getMinutes() === data_2.getMinutes()
        && data_1.getSeconds() === data_2.getSeconds()
        && data_1.getMilliseconds() === data_2.getMilliseconds();
}
export function dataPorExtenso(data: Date): string {
    if (isNullOrUndefined(data)) {
        return undefined;
    }
    return getNameDiaSemana(data.getDay())
        + ', ' + data.getDate()
        + ' de ' + getNameMes(data.getMonth())
        + ' de ' + data.getFullYear();
}

export function getDiasMesCalendar(mes: number, ano: number): any[] {
    if (isNullOrUndefined(mes) || isNullOrUndefined(ano)) {
        return undefined;
    }
    let dataAtual: Date = hoje();
    let date: Date = new Date(ano, mes, 1);
    let dias: any[] = [];
    while (date.getMonth() === mes) {
        let value = new Date(date.getTime());
        dias.push({ color: getColorCalendar(value, mes), value: value, visible: value >= dataAtual, isMesAtual: date.getMonth() === mes });
        date.setDate(date.getDate() + 1);
    }
    return dias;
}

export function getColorCalendar(data: Date, mes: number): "#ffcd00" | "#ededed" | "#7fb29e" | "#bad6e4" {
    if (isNullOrUndefined(data) || isNullOrUndefined(mes)) {
        return undefined;
    }
    let dataAtual: Date = new Date();
    if (compareDate(data, dataAtual)) {
        return '#ffcd00';
    }
    if (data.getMonth() !== mes) {
        return '#ededed';
    }
    if (data.getDay() === 0 || data.getDay() === 6) {
        return '#7fb29e';
    }
    return '#bad6e4';
}

export function getDiasCalendar(mes: number, ano: number): any[] {
    if (isNullOrUndefined(mes) || isNullOrUndefined(ano)) {
        return undefined;
    }
    let dias: any[] = getDiasMesCalendar(mes, ano);
    let diaInicial: Date = new Date(dias[0].value);
    while (dias[0].value.getDay() != 0) {
        diaInicial.setDate(diaInicial.getDate() - 1);
        let value = new Date(diaInicial);
        dias.unshift({ color: getColorCalendar(value, mes), value: value });
    }
    let indexUltimoDia: number = dias.length - 1;
    let diaFinal: Date = new Date(dias[indexUltimoDia].value);
    while (dias[indexUltimoDia].value.getDay() != 6) {
        diaFinal.setDate(diaFinal.getDate() + 1);
        let value = new Date(diaFinal);
        dias.push({ color: getColorCalendar(value, mes), value: new Date(diaFinal) });
        indexUltimoDia = dias.length - 1;
    }

    return dias;
}

export function formatListDDMMYYYY(list: any[], field: string): void {
    if (isNullOrUndefined(list) || isNullOrUndefined(field)) {
        return undefined;
    }
    list.forEach(function (element) {
        if (element[field]) {
            element[field] = formatDDMMYYYY(element[field]);
        }
    });
}

export function addHours(hours: number, dateValue: Date): Date {
    if (isNullOrUndefined(hours) || isNullOrUndefined(dateValue)) {
        return undefined;
    }
    return moment(dateValue).add(hours, 'h').toDate();
}

export function subtractHours(hours: number, dateValue: Date): Date {
    if (isNullOrUndefined(hours) || isNullOrUndefined(dateValue)) {
        return undefined;
    }
    return moment(dateValue).subtract(hours, 'h').toDate();
}

export function stringToDate(dateValue: string): Date {
    if (isNullOrUndefined(dateValue)) {
        return undefined;
    }
    let regexYYYYMMDD: RegExp = /(\d{4})[-](\d{2})[-](\d{2})/gi;
    let regexDDMMYYYY: RegExp = /(\d{2})[\/](\d{2})[\/](\d{4})/gi;
    let regexISO: RegExp = /(\d{4})[-](\d{2})[-](\d{2})[T](\d{2})[:](\d{2})[:](\d{2})[.](\d{3})[Z]/gi;
    let regexDateTime: RegExp = /(\d{2})[\/](\d{2})[\/](\d{4})[ ](\d{2})[:](\d{2})[:](\d{2})/gi;
    let day: number;
    let month: number;
    let year: number;
    let hour: number = 0;
    let minute: number = 0;
    let second: number = 0;
    let millisecond: number = 0;

    if (regexISO.exec(dateValue)) {
        dateValue.replace(regexISO, '$1, $2, $3, $4, $5, $6');

        year = +RegExp.$1;
        month = +RegExp.$2 - 1;
        day = +RegExp.$3;
        hour = +RegExp.$4;
        minute = +RegExp.$5;
        second = +RegExp.$6;
    } else if (regexDateTime.exec(dateValue)) {
        dateValue.replace(regexDateTime, '$1, $2, $3, $4, $5, $6');
        day = +RegExp.$1;
        month = +RegExp.$2 - 1;
        year = +RegExp.$3;
        hour = +RegExp.$4;
        minute = +RegExp.$5;
        second = +RegExp.$6;
    } else if (regexYYYYMMDD.exec(dateValue)) {
        dateValue.replace(regexYYYYMMDD, '$1, $2, $3');
        day = +RegExp.$3;
        month = +RegExp.$2 - 1;
        year = +RegExp.$1;
    } else if (regexDDMMYYYY.exec(dateValue)) {
        dateValue.replace(regexYYYYMMDD, '$1, $2, $3');
        day = +RegExp.$1;
        month = +RegExp.$2 - 1;
        year = +RegExp.$3;
    }
    return moment([year, month, day, hour, minute, second, millisecond]).toDate();
}

export function YYYYMMDDtoDDMMYYYY(value: string): string {
    if (isNullOrUndefined(value)) {
        return undefined;
    }
    let regex: RegExp = /(\d{4})[-](\d{2})[-](\d{2})/gi;
    value.replace(regex, '$1, $2, $3');

    return `${RegExp.$3}/${RegExp.$2}/${RegExp.$1}`;
}

export function addMonth(dateValue: Date, valueAdd: number): Date {
    if (isNullOrUndefined(dateValue) || isNullOrUndefined(valueAdd)) {
        return undefined;
    }
    return moment(dateValue).add(valueAdd, 'M').toDate();
}

export function subtractMonth(dateValue: Date, valueSubtract: number): Date {
    if (isNullOrUndefined(dateValue) || isNullOrUndefined(valueSubtract)) {
        return undefined;
    }
    return moment(dateValue).subtract(valueSubtract, 'M').toDate();
}

export function ISOToYYYYMMDD(dateValue: string): string {
    if (isNullOrUndefined(dateValue)) {
        return undefined;
    }
    return moment(dateValue).format('YYYY-MM-DD');
}

export function diffDatesToString(date_1: Date, date_2: Date): string {
    if (isNullOrUndefined(date_1) || isNullOrUndefined(date_2)) {
        return undefined;
    }
    let retorno: string = date_1 > date_2 ? '-' : '';
    let duracao = moment.duration(date_2.getTime() - date_1.getTime(), 'milliseconds');

    let hours: number = Math.abs(duracao.hours());
    let labelHours: string = hours < 10
        ? `0${hours}`
        : `${hours}`;

    let minutes: number = Math.abs(duracao.minutes());
    let labelMinutes: string = minutes < 10
        ? `0${minutes}`
        : `${minutes}`;

    let seconds: number = Math.abs(duracao.seconds());
    let labelSeconds: string = seconds < 10
        ? `0${seconds}`
        : `${seconds}`;

    if (Math.abs(duracao.months()) > 0) {
        let dias: number = Math.abs(Math.round(duracao.asDays()));
        retorno = retorno.concat(`${dias} dias, `);
    } else if (Math.abs(duracao.days()) > 0) {
        let dias: number = Math.abs(Math.round(duracao.asDays()));
        retorno = retorno.concat(`${dias} dia${dias > 1 ? 's,' : ','} `);
    }

    return retorno.concat(`${labelHours}h:${labelMinutes}m:${labelSeconds}s`);
}

export function addHoursInTime(hours: number, timeValue: string): string {
    if (isNullOrUndefined(hours) || isNullOrUndefined(timeValue)) {
        return undefined;
    }
    let momentValue: moment.Moment = moment();
    let time = HHMMSSGetHourMinutesSecond(timeValue);
    momentValue.set({ hour: time.hours, minute: time.minutes, seconds: time.seconds, millisecond: 0 });

    return momentValue.add(hours, 'h').format('HH:mm:ss');
}

export function subtractHoursInTime(hours: number, timeValue: string): string {
    if (isNullOrUndefined(hours) || isNullOrUndefined(timeValue)) {
        return undefined;
    }
    let momentValue: moment.Moment = moment();
    let time = HHMMSSGetHourMinutesSecond(timeValue);
    momentValue.set({ hour: time.hours, minute: time.minutes, seconds: time.seconds, millisecond: 0 });

    return momentValue.subtract(hours, 'h').format('HH:mm:ss');
}

export function addMinutesInTime(minutes: number, timeValue: string): string {
    if (isNullOrUndefined(minutes) || isNullOrUndefined(timeValue)) {
        return undefined;
    }
    let momentValue: moment.Moment = moment();
    let time = HHMMSSGetHourMinutesSecond(timeValue);
    momentValue.set({ hour: time.hours, minute: time.minutes, seconds: time.seconds, millisecond: 0 });

    return momentValue.add(minutes, 'm').format('HH:mm:ss');
}

export function subtractMinutesInTime(minutes: number, timeValue: string): string {
    if (isNullOrUndefined(minutes) || isNullOrUndefined(timeValue)) {
        return undefined;
    }
    let momentValue: moment.Moment = moment();
    let time = HHMMSSGetHourMinutesSecond(timeValue);
    momentValue.set({ hour: time.hours, minute: time.minutes, seconds: time.seconds, millisecond: 0 });

    return momentValue.subtract(minutes, 'm').format('HH:mm:ss');
}