const state = {
    loadingPaymentTerms: false,
    paymentTerms: [],
    paymentMethods: ['Efectivo', 'Banco'],
    paymentTerm: null,
    paymentType: 'cash',
    paymentMethod: 'Efectivo',
    amountToPay: 0,
    initialPayment: 0,
    amountResidual: 0,
    paymentLines: [],
    firstPaymentDate: new Date(),
    firstPaymentAfterDate: new Date(),
    bankPaymentData: null,
}

const getters = {
    paymentTerms(state) {
        return state.paymentTerms
    },
    paymentMethods(state) {
        return state.paymentMethods.filter(p => p !== state.paymentMethod)
    },
    loadingPaymentTerms(state) {
        return state.loadingPaymentTerms
    },
    paymentTerm(state) {
        return state.paymentTerm
    },
    paymentType(state) {
        return state.paymentType
    },
    paymentMethod(state) {
        return state.paymentMethod
    },
    amountToPay(state) {
        return state.amountToPay
    },
    amountToPayInOtherCurrencies(state, { settings, currencies, user, selectedCurrency, cartTotal }) {
        let values = []

        if (!user || !selectedCurrency || cartTotal === 0) {
            return values
        }

        const base = currencies.find(c => c.id === user.company.currencyId)

        for(let currency of settings.currencies) {
            if (currency.id === selectedCurrency.id) {
                continue
            }

            const rate = base.rateSilent / currency.rateSilent

            values.push({
                currency,
                amount: cartTotal / rate,
            })
        }

        return values
    },
    initialPayment(state) {
        return state.initialPayment
    },
    amountResidual(state) {
        return state.amountResidual
    },
    paymentLines(state) {
        return state.paymentLines
    },
    firstPaymentDate(state) {
        if (state.paymentLines && state.paymentLines.length > 1) {
            const date = new Date(state.paymentLines[0].date)

            if (moment(date).isSameOrAfter(state.firstPaymentDate)) {
                return date
            }
        }

        return state.firstPaymentDate
    },
    firstPaymentAfterDate(state) {
        return state.firstPaymentAfterDate
    },
    bankPaymentData(state) {
        return state.bankPaymentData
    }
}

const mutations = {
    setPaymentTerms(state, payload) {
        state.paymentTerms = payload
    },
    setLoadingPaymentTerms(state, payload) {
        state.loadingPaymentTerms = !!payload
    },
    autoSelectPaymentTerm(state, payload) {
        if (!payload || payload === 'cash') {
            state.paymentTerm = state.paymentTerms.find(t => t.lines.length === 1 && t.lines[0].days === 0) || state.paymentTerms.find(t => t.lines.length === 1 && t.lines[0].days >= 0)
        } else {
            state.paymentTerm = state.paymentTerms.find(t => t.lines[0].days > 0)
        }
    },
    setPaymentTerm(state, payload) {
        if (!payload) {
            state.paymentTerm = payload
            return
        }

        state.paymentTerm = state.paymentTerms.find(item => item.id === payload)
    },
    setPaymentType(state, payload) {
        state.paymentType = payload
    },
    setPaymentMethod(state, payload) {
        state.paymentMethod = payload
    },
    setAmountToPay(state, amount) {
        if (!this.getters.baseCurrency) {
            return
        }

        let rate = 1

        if (this.getters.baseCurrency.id !== this.getters.selectedCurrency.id) {
            rate = this.getters.baseCurrency.rateSilent / this.getters.selectedCurrency.rateSilent
        }

        state.amountToPay = amount / rate
    },
    setAmountResidual(state) {
        state.amountResidual = state.initialPayment < state.amountToPay ? 0 : state.initialPayment - state.amountToPay
    },
    computePaymentInCurrency(state, { fromSymbol, toSymbol }) {
        const fromCurrency = this.getters.currencies.find(c => c.symbol === fromSymbol)
        const toCurrency = this.getters.currencies.find(c => c.symbol === toSymbol)

        if (!fromCurrency || !toCurrency) {
            return
        }

        const rate = fromCurrency.rateSilent / toCurrency.rateSilent

        state.amountToPay = state.amountToPay / rate
        state.initialPayment = state.initialPayment / rate
        state.amountResidual = state.amountResidual / rate
    },
    setInitialPayment(state, payload) {
        state.initialPayment = payload
    },
    setPaymentLines(state, payload) {
        state.paymentLines = []

        if (!payload) {
            return
        }

        let percentPaid = state.initialPayment / payload.total
        let distributedPercentage = -(percentPaid / state.paymentTerm.lines.length)
        let totals = []
        let residual = payload.total
        let dueDate = null

        for (let line of state.paymentTerm.lines) {
            dueDate = moment(payload.date).add(line.days + line.days2, 'days').format('DD/MM/YYYY')

            if(percentPaid && percentPaid < 1) {
                let firstDate = moment(payload.date).format('DD/MM/YYYY')

                totals.push([firstDate, percentPaid])
                percentPaid = 0

                if (dueDate === firstDate) {
                    distributedPercentage = ((totals[0][1] - line.valueAmount) / (state.paymentTerm.lines.length - 1))
                    continue
                }
            }

            if (line.value !== 'balance') {
                totals.push([dueDate, line.valueAmount + distributedPercentage])
                continue
            }

            totals.push([dueDate, line.valueAmount])

            for (let line of totals) {
                let currentPrice = (payload.total * line[1]).toFixed(2)

                if (currentPrice < 0) {
                    continue
                }

                residual = residual - currentPrice

                state.paymentLines.push({
                    date: line[0],
                    total: parseFloat(currentPrice !== parseFloat(0).toFixed(2) ? currentPrice : residual.toFixed(2))
                })
            }

            totals = []
        }
    },
    setFirstPaymentDate(state, paymentDate) {
        state.firstPaymentDate = paymentDate

        if (moment(state.firstPaymentAfterDate).isSameOrBefore(paymentDate)) {
            state.firstPaymentAfterDate = paymentDate
        }
    },
    setBankPaymentData(state, bankPaymentData) {
        state.bankPaymentData = bankPaymentData
    }
}

const actions = {
    initPaymentTerms({ commit }, payload) {
        commit('setPaymentTerms', payload)
        commit('autoSelectPaymentTerm')
        commit('setLoadingPaymentTerms')
    },
    selectPaymentTerm({ commit }, payload) {
        if (!payload) {
            return
        }

        commit('setPaymentTerm', payload)
    },
    changePaymentType({ commit, dispatch, getters }, paymentType) {
        commit('setPaymentType', paymentType)
        commit('autoSelectPaymentTerm', paymentType)
        commit('setInitialPayment', 0)
        commit('setPaymentLines')

        if (getters.paymentType === 'credit') {
            dispatch('computePaymentLines')
        }
    },
    changePaymentMethod({ commit, dispatch }, methodName) {
        if (methodName === 'Banco') {
            dispatch('toggleBankPayment')
        }

        commit('setPaymentMethod', methodName)
        dispatch('changeInitialPayment', 0)
    },
    changeAmountToPay({ commit }, amount) {
        commit('setAmountToPay', amount)
    },
    changeInitialPayment({ commit, dispatch, getters }, payload) {
        commit('setInitialPayment', payload)
        commit('setAmountResidual')

        if (getters.paymentType === 'credit') {
            dispatch('computePaymentLines')
        }
    },
    changeFirstPaymentDate({ commit }, paymentDate) {
        commit('setFirstPaymentDate', paymentDate)
    },
    changeBankPaymentData({ commit, dispatch }, bankPaymentData) {
        commit('setBankPaymentData', bankPaymentData)

        if (bankPaymentData.amount) {
            dispatch('changeInitialPayment', bankPaymentData.amount)
        }
    },
    computePaymentLines({ commit, getters }) {
        commit('setPaymentLines', {
            date: getters.date,
            total: getters.amountToPay
        })
    },
    resetPayment({ getters, commit }) {
        if (getters.isWired) {
            commit('setLoadingPaymentTerms', true)
            commit('setPaymentTerms', [])

        }
        
        commit('setPaymentTerm', null)
        commit('setPaymentType', 'cash')
        commit('setPaymentMethod', 'Efectivo')
        commit('setAmountToPay', 0)
        commit('setInitialPayment', 0)
        commit('setAmountResidual')

        commit('autoSelectPaymentTerm')
    }
}

export default {
    state,
    getters,
    mutations,
    actions
}