import DateFormat from 'dateformat'
import OriginMoment from 'moment'
import { extendMoment } from 'moment-range'
const Moment = extendMoment(OriginMoment)

import { CHECK_LEAVES_DAY, DATES_FORMAT } from 'Constants/others'

// Keep start before end
const orderStartEnd = callback => (start, end) => start.isBefore(end) ? callback(start, end) : callback(end, start)

// Check if date is Saturday or Sunday
const isSaturday = date => date.day() === 6
const isSunday = date => date.day() === 0
const isWeekendDay = date => isSaturday(date) || isSunday(date)

// Core function of getYearPublicHolidays
const MemoizegetYearPublicHolidays = year => {
    // Some obscure code
    let G = year % 19
    let C = Math.floor(year / 100)
    let H = (C - Math.floor(C / 4) - Math.floor((8 * C + 13) / 25) + 19 * G + 15) % 30
    let I = H - Math.floor(H / 28) * (1 - Math.floor(H / 28) * Math.floor(29 / (H + 1)) * Math.floor((21 - G) / 11))
    let J = (year * 1 + Math.floor(year / 4) + I + 2 - C + Math.floor(C / 4)) % 7
    let L = I - J
    let EasterMonth = 3 + Math.floor((L + 40) / 44)
    let EasterDay = L + 28 - 31 * Math.floor(EasterMonth / 4)
    let EasterSunday = Moment(`${EasterDay}/${EasterMonth}/${year}`, DATES_FORMAT) // Dimanche de Pâques

    const holidays = [
        Moment(`01/01/${year}`, DATES_FORMAT), // Jour de l'an
        EasterSunday.clone().add(1, 'day'), // Lundi de Pâques
        Moment(`01/05/${year}`, DATES_FORMAT), // Fête du travail
        Moment(`08/05/${year}`, DATES_FORMAT), // Victoire 1945
        EasterSunday.clone().add(39, 'day'), // Jeudi de l'ascension
        EasterSunday.clone().add(50, 'day'), // Lundi de Pentecôte
        Moment(`14/07/${year}`, DATES_FORMAT), // Fête nationale
        Moment(`15/08/${year}`, DATES_FORMAT), // Assomption
        Moment(`01/11/${year}`, DATES_FORMAT), // Toussaint
        Moment(`11/11/${year}`, DATES_FORMAT), // Armistice
        Moment(`25/12/${year}`, DATES_FORMAT) // Noël
    ]

    return holidays.filter(date => !isWeekendDay(date))
}

// Store public holiday per year for memoization
const publicHolidaysPerYear = {}

// [Memoized] Determine public holiday in a year (Public days who are week-end day are removed)
export const getYearPublicHolidays = year => {
    if (!publicHolidaysPerYear[year]) {
        publicHolidaysPerYear[year] = MemoizegetYearPublicHolidays(year)
    }

    return publicHolidaysPerYear[year]
}

export const getPublicHolidaysInPeriod = orderStartEnd((start, end) => {
    let holidays = []
    // Loop on years
    for (let year = start.year(); year <= end.year(); year++) {
        // If start or end year
        if (year === start.year() || year === end.year()) {
            holidays = holidays.concat(
                getYearPublicHolidays(year)
                    .filter(date => date.isSameOrAfter(start) && date.isSameOrBefore(end))
            )
        } else {
            holidays = holidays.concat(getYearPublicHolidays(year))
        }
    }

    return holidays
})

export const countPublicHolidaysInPeriod = orderStartEnd((start, end) => {
    let count = 0

    // Loop on years
    for (let year = start.year(); year <= end.year(); year++) {
        // If start or end year
        if (year === start.year() || year === end.year()) {
            count += getYearPublicHolidays(year)
                .filter(date => date.isSameOrAfter(start) && date.isSameOrBefore(end))
                .length
        } else {
            count += getYearPublicHolidays(year).length
        }
    }

    return count
})

export const countWeekendDaysInPeriod = orderStartEnd((start, end) => {
    // start and end are the same day
    if (start.clone().startOf('day').isSame(end.clone().startOf('day'))) {
        return isWeekendDay(start) ? 1 : 0
    }

    // start and end are in the same week
    if (start.week() === end.week() && Moment.range(start, end).diff('weeks') === 0) {
        let count = 0
        if (isSunday(start))
            count++
        if (isSaturday(end))
            count++
        return count
    }

    // start and end are in different weeks
    let count = 0
    let startWeek = start.clone().startOf('week')
    let endWeek = end.clone().startOf('week')

    // Loop on weeks
    for (let date = startWeek.clone(); date.isSameOrBefore(endWeek); date.add(1, 'weeks')) {
        if (date.isSame(startWeek)) {
            count += isSunday(start) ? 2 : 1
        } else if (date.isSame(endWeek)) {
            count += isSaturday(end) ? 2 : 1
        } else {
            count += 2
        }
    }

    return count
})

// Count worked days in a period (Don't count public holidays and weekend)
export const countWorkedDaysInPeriod = orderStartEnd((start, end) => {
    return Moment.range(start, end).diff('days') + 1 -
        countPublicHolidaysInPeriod(start, end) -
        countWeekendDaysInPeriod(start, end)
})

// Calculate worked days in a year (memoized)
const memoizeCountWorkedDaysInYear = {}
export const countWorkedDaysInYear = year => {
    if (!memoizeCountWorkedDaysInYear[year]) {
        memoizeCountWorkedDaysInYear[year] = countWorkedDaysInPeriod(
            Moment(`01/01/${year}`, 'DD/MM/YYYY'),
            Moment(`31/12/${year}`, 'DD/MM/YYYY')
        )
    }

    return memoizeCountWorkedDaysInYear[year]
}

export const getLastStartMonth = date => date.clone().startOf('month')

export const getNextStartMonth = date => date.clone().add(1, 'month').startOf('month')

export const getLastJanuary1st = date => date.clone().startOf('year')

export const getNextJanuary1st = date => date.clone().add(1, 'years').startOf('year')

export const getLastJune1st = date => {
    // June 1st of date's year
    let june1st = date.clone().date(1).month(5).startOf('day')
    if (date.isBefore(june1st)) {
        june1st.subtract(1, 'years')
    }
    return june1st
}

export const getNextJune1st = date => {
    // June 1st of date's year
    let june1st = date.clone().date(1).month(5).startOf('day')
    if (date.isAfter(june1st)) {
        june1st.add(1, 'years')
    }
    return june1st
}

export const getLastCheckDay = date => {
    // Check day of date's month
    let checkDay = date.clone().date(CHECK_LEAVES_DAY).startOf('day')
    if (date.isBefore(checkDay)) {
        checkDay.subtract(1, 'months')
    }
    return checkDay
}

export const getNextCheckDay = date => {
    // Check day of date's month
    let checkDay = date.clone().date(CHECK_LEAVES_DAY).startOf('day')
    if (date.isAfter(checkDay)) {
        checkDay.add(1, 'months')
    }
    return checkDay
}











// ----------------------------------------------------------------------------

export function JFYear(an) {
    var df = 'yyyy-mm-dd'
    var JourAn = Moment(DateFormat(new Date(an, '00', '01'), df))
    var FeteTravail = Moment(DateFormat(new Date(an, '04', '01'), df))
    var Victoire1945 = Moment(DateFormat(new Date(an, '04', '08'), df))
    var FeteNationale = Moment(DateFormat(new Date(an, '06', '14'), df))
    var Assomption = Moment(DateFormat(new Date(an, '07', '15'), df))
    var Toussaint = Moment(DateFormat(new Date(an, '10', '01'), df))
    var Armistice = Moment(DateFormat(new Date(an, '10', '11'), df))
    var Noel = Moment(DateFormat(new Date(an, '11', '25'), df))
    //**var SaintEtienne = new Date(an, '11', '26');**//

    var G = an % 19
    var C = Math.floor(an / 100)
    var H = (C - Math.floor(C / 4) - Math.floor((8 * C + 13) / 25) + 19 * G + 15) % 30
    var I = H - Math.floor(H / 28) * (1 - Math.floor(H / 28) * Math.floor(29 / (H + 1)) * Math.floor((21 - G) / 11))
    var J = (an * 1 + Math.floor(an / 4) + I + 2 - C + Math.floor(C / 4)) % 7
    var L = I - J
    var MoisPaques = 3 + Math.floor((L + 40) / 44)
    var JourPaques = L + 28 - 31 * Math.floor(MoisPaques / 4)
    var Paques = Moment(DateFormat(new Date(an, MoisPaques - 1, JourPaques), df))
    //**var VendrediSaint = new Date(an, MoisPaques-1, JourPaques-2);**//
    var LundiPaques = Moment(DateFormat(new Date(an, MoisPaques - 1, JourPaques + 1), df))
    var Ascension = Moment(DateFormat(new Date(an, MoisPaques - 1, JourPaques + 39), df))
    var Pentecote = Moment(DateFormat(new Date(an, MoisPaques - 1, JourPaques + 49), df))
    var LundiPentecote = Moment(DateFormat(new Date(an, MoisPaques - 1, JourPaques + 50), df))

    //**SaintEtienne et Vendredi Saint sont des fêtes exclusivement**//
    //**alscacienne. On les ignore dans notre cas.**//
    var res = [JourAn, Paques, LundiPaques, FeteTravail, Victoire1945, Ascension, Pentecote, LundiPentecote, FeteNationale, Assomption, Toussaint, Armistice, Noel]
    return (res)
}


//******************************************************************************************************************************//
//************************              Renvoie les jours feriers existants entre 2 date                 ***********************//
//******************************************************************************************************************************//

export function JoursFeries(start, end) {
    var a1 = JFYear(start.year())
    var a2 = JFYear(end.year())
    var a = a1.concat(a2)
    var b = a.slice(0)
    a.forEach(function (fer) {
        if ((start > fer) || (end < fer)) {
            var index = b.indexOf(fer)
            b.splice(index, 1)
        }
    })
    return (b)
}

//******************************************************************************************************************************//
//************************         Fonction diff entre 2 jours renvoi le nbr de jours ecoulées           ***********************//
//******************************************************************************************************************************//

export function isFerier(day, start, end) {
    var res = (JoursFeries(start, end))
    var estunJF = false
    res.forEach(function (fer) {
        if (day.isSame(fer)) {              // Si je retrouve un jour férié
            //console.log('comparaison de : ', day, 'et de : ' ,fer)
            estunJF = true
            //console.log('JF détécté : ', day)
            //console.log('')
        }
    })
    return (estunJF)
}

//******************************************************************************************************************************//
//************************        Donne les intervalles de jours ouvrées pour une demande de congé       ***********************//
//******************************************************************************************************************************//

export function demandeConge(dayA, dayB) {
    // Jamais utilisé !
    //var res = (JoursFeries(dayA, dayB))

    // Declaration des variables
    var day = dayA.clone()
    var fin = dayB.add(1, 'days')
    var v = []
    var premierJour = true
    var buffer = 0
    var flag = false

    while (!(day.isSame(fin))) {            // tant que je ne depasse pas le jour de fin des congés
        //console.log('Nous sommes le ', day)
        //console.log('premierJour = ', premierJour, 'flag = ', flag)
        if (isFerier(day, dayA, dayB) || day.day() === 6 || day.day() === 0) {
            //console.log('c est un jour F ou un WE ', day)
            flag = true
            buffer = buffer + 1

            if ((buffer === 1) && (!premierJour)) {
                //console.log('ce n est pas le premier jour de demande de conge mais c un premier JF donc on push J-1', day)
                var d = day.clone()
                v.push(d.subtract(1, 'days'))
            }

            if (premierJour && day.day === 0){
                //console.log('c est le premier jour et c est un dimanche ', day)
                premierJour = false
                flag = true
            }

            if (buffer > 1){
                //console.log('encore un JF ou un WE', day)
                premierJour = false
            }
        }

        else {
            let d
            buffer = 0

            if (premierJour) {
                //console.log('Premier Jour Ouvré on push', day)
                d = day.clone()
                v.push(d)
                premierJour = false
                flag = false
            }
            else {
                if (flag) {
                    //console.log('un Jour Ouvré qui suit un JF ou WE', day)
                    d = day.clone()
                    v.push(d)
                    flag = false
                }
            }
        }
        day.add(1, 'days')
    }
    dayB.subtract(1, 'days')
    if (!(isFerier(dayB, dayA, dayB) || dayB.day() === 6 || dayB.day() === 0)) {
        v.push(dayB)
    }

    var answer = []
    var s, e
    for (var i = 0; i < v.length; i++) {
        s = v[i]
        e = v[i + 1]
        answer.push(Moment.range(s, e))
        i++
    }

    return (answer)
}



export function nbrJours(start, end, midstart, midend){
    var array = demandeConge(start, end)
    var sum = 0
    //console.log(array)

    array.forEach (function(range){
        sum += (range.valueOf() / 86400000) + 1
    })

    sum *= 2

    if (midstart && sum>0 && !((isFerier(start, start, end) || (start.day() === 6) || (start.day() === 0))))
        sum = sum - 1
    if (midend && sum>0 && !((isFerier(end, start, end) || (end.day() === 6) || (end.day() === 0))))
        sum = sum - 1
    return (sum)
}

//******************************************************************************************************************************//
//************************                                Donne le nombre de jours ouvrés par afn                          ***********************//
//******************************************************************************************************************************//

export function howManyOuvres(year) {
    let ouvres = 0
    let moment = Moment(year + '-01-01')
    let day = moment.clone()

    while (day.year() == year){
        if (( (isFerier(day, Moment(year + '-01-01'), Moment(year + '-12-31'))) || (day.day() === 0) || (day.day() === 6))){
            // console.log('Jours non travaillé : ', day.format('YYYY-MM-DD'))
        }
        else {
            ouvres ++
        }
        day.add(1, 'days')
    }
    return (ouvres)
}