import test from 'ava'
import Chance from '../chance.js'
import _ from 'lodash'

const chance = new Chance()

// chance.cc()
test('cc() passes the luhn algorithm', t => {
    _.times(1000, () => {
        let number = chance.cc()
        t.true(chance.luhn_check(number))
    })
})

test('cc() can take a type arg and obey it', t => {
    _.times(1000, () => {
        let type = chance.cc_type({ raw: true })
        let number = chance.cc({ type: type.name })
        t.is(number.length, type.length)
    })
})

test('cc() can take a short_name type arg and obey it', t => {
    _.times(1000, () => {
        let type = chance.cc_type({ raw: true })
        let number = chance.cc({ type: type.short_name })
        t.is(number.length, type.length)
    })
})

// chance.cc_type()
test('cc_type() returns a random credit card type', t => {
    _.times(1000, () => {
        t.true(_.isString(chance.cc_type()))
    })
})

test('cc_type() can take a raw arg and obey it', t => {
    _.times(1000, () => {
        let type = chance.cc_type({ raw: true })
        t.truthy(type.name)
        t.truthy(type.short_name)
        t.truthy(type.prefix)
        t.truthy(type.length)
    })
})

test('cc_type() can take a name arg and obey it', t => {
    _.times(1000, () => {
        let type = chance.cc_type({ name: 'Visa', raw: true })
        t.is(type.name, 'Visa')
    })
})

test('cc_type() with bogus type throws', t => {
    const fn = () => chance.cc_type({ name: 'potato' })
    t.throws(fn, 'Chance: Credit card type \'potato\' is not supported')
})

// chance.cc_types()
test('cc_types() returns an array of credit card types', t => {
    t.true(_.isArray(chance.cc_types()))
})

// chance.currency()
test('currency() returns a currency', t => {
    _.times(1000, () => {
        let currency = chance.currency()
        t.true(_.isObject(currency))
        t.truthy(currency.code)
        t.is(currency.code.length, 3)
        t.truthy(currency.name)
    })
})

// chance.currency_pair()
test('currency_pair() returns a currency pair', t => {
    _.times(1000, () => {
        let currency_pair = chance.currency_pair()
        t.true(_.isArray(currency_pair))
        t.is(currency_pair.length, 2)
        t.not(currency_pair[0].code, currency_pair[1].code)
    })
})

test('currency_pair() can return string version', t => {
    _.times(1000, () => {
        let currency_pair = chance.currency_pair(true)
        t.true(_.isString(currency_pair))
        t.is(currency_pair.length, 7)
        t.true(/^[A-Z][A-Z][A-Z]+\/[A-Z][A-Z][A-Z]$/.test(currency_pair))
    })
})

// chance.dollar()
test('dollar() returns a proper dollar amount', t => {
    let dollar = chance.dollar()
    t.true(/\$[0-9]+\.[0-9]+/.test(dollar))
    let dollarFloat = parseFloat(dollar.substring(1, dollar.length))
    t.true(dollarFloat < 10001)
})

test('dollar() obeys min and max, if provided', t => {
    _.times(1000, () => {
        let dollar = chance.dollar({ max: 20 })
        let dollarFloat = parseFloat(dollar.substring(1, dollar.length))
        t.true(dollarFloat <= 20)
    })

    _.times(1000, () => {
        let dollar = chance.dollar({ min: 20 })
        let dollarFloat = parseFloat(dollar.substring(1, dollar.length))
        t.true(dollarFloat >= 20)
    })
})

test('dollar() can take negative min and max', t => {
    _.times(1000, () => {
        let dollar = chance.dollar({ min: -200, max: -1 })
        t.is(dollar.charAt(0), '-')
        let dollarFloat = parseFloat(dollar.substring(2, dollar.length))
        // This is necessary because we strip the - when parsing
        dollarFloat *= -1
        t.true(dollarFloat <= -1)
        t.true(dollarFloat >= -200)
    })
})

// chance.euro()
test('euro() returns a proper euro amount', t => {
    let euro = chance.euro()
    t.true(/[0-9]+,?\.?[0-9]+?€/.test(euro))
    let euroFloat = parseFloat(euro.substring(euro.length, -1))
    t.true(euroFloat < 10001)
})

// chance.exp()
test('exp() looks correct', t => {
    _.times(1000, () => {
        let exp = chance.exp()
        t.true(_.isString(exp))
        t.is(exp.length, 7)
        t.true(/([0-9]{2})\/([0-9]{4})/.test(exp))
    })
})

test('exp() will respect object argument', t => {
    _.times(1000, () => {
        let exp = chance.exp({ raw: true })
        t.true(_.isObject(exp))
        t.truthy(exp.month)
        t.true(_.isString(exp.month))
        t.truthy(exp.year)
        t.true(_.isString(exp.year))
    })
})

test('exp() returs a valid credit card expiration (in a future date)', t => {
    _.times(1000, () => {
        let exp = chance.exp({ raw: true })
        let now = new Date()
        let nowMonth = now.getMonth() + 1
        let nowYear = now.getFullYear()
        let expMonth = parseInt(exp.month, 10)
        let expYear = parseInt(exp.year, 10)

        t.true(expYear >= nowYear)
        if (expYear === nowYear) {
            t.true(expMonth >= nowMonth)
        }
    })
})

// chance.exp_month()
test('exp_month() returns a numeric month with leading 0', t => {
    _.times(1000, () => {
        let month = chance.exp_month()
        t.true(_.isString(month))
        t.is(month.length, 2)
    })
})

// chance.exp_year()
test('exp_year() returns an expiration year', t => {
    _.times(1000, () => {
        let year = chance.exp_year()
        t.true(_.isString(year))
        let parsedYear = parseInt(year, 10)
        let curYear = new Date().getFullYear()
        t.true(parsedYear >= curYear)
        t.true(parsedYear <= curYear + 10)
    })
})

test('exp_month() will return a future month if requested', t => {
    _.times(1000, () => {
        let nowMonth = new Date().getMonth() + 1
        let expMonth = parseInt(chance.exp_month({ future: true }), 10)
        if (nowMonth !== 12) {
            t.true(expMonth > nowMonth)
        } else {
            t.true(expMonth >= 1)
            t.true(expMonth <= 12)
        }
    })
})

// chance.luhn_check()
test('luhn_check() properly checks if number passes the Luhn algorithm', t => {
    t.true(chance.luhn_check(49927398716))
    t.true(chance.luhn_check(1234567812345670))
    t.false(chance.luhn_check(49927398717))
    t.false(chance.luhn_check(1234567812345678))
})

test('iban() returns an iban', t => {
    let iban = chance.iban()
    t.true(_.isString(iban))
    t.true(/^[A-Z]{2}[0-9]{2}[A-Z0-9]{4}[0-9]{1,26}$/.test(iban))
})