// syntax ideas:

// .pipe(options) .line()
FP.pipe()
  .map(...).tap(...).get(...)
  .line()


// .pipe(options) .pipeEnd()
FP.pipe()
  .map(...).get(...)
  .pipeEnd()

const loud = value => (''+ value).toUpperCase()

const chainFn = FP.build()
    .then(loud)
    .tap(console.log)
    .then(s => s + '!!!')
    .toPromise()

chainFn('dan levy')
  .then(s => console.log(`Hi ${s}`)) // Hi DAN LEVY!!!


const callbackFn = FP.chain()
  .then(loud)
  .toCallback()

callbackFn('dan levy', (err, upperStr) => {
  console.log(`Hello ${upperStr}`) //=> Hello DAN LEVY
})

const listenFn = FP.chain()
  .get('target')
  .get('textContent')
  .then(loud)
  .tap(str => console.log('Loud: ' + str))
  .toListener()

listenFn(statusFooter, 'click', 'mouseover')

const started = Date.now()

FP.resolve([1, 2, 3, 4])
  .concurrency(10)
  // now only 1 map() callback happens at a time
  .map(num => {
    return FP
      .delay(50)
      .resolve(num)
  })
  .then(() => {
    const runtime = Date.now() - started
    console.log(`Delayed ${runtime}ms.`)
    console.log(`Success: ${runtime >= 200}`)
  })

const fetch = FP.wrap(fetch);
// Now you can call the FP enhanced`fetch`

fetch('/profile', {method: 'GET'})
  .thenIf(
    res => res.ok, // Check for 
    res => res.json(), // Success, so pass along the JSON-parsed body
    res => Promise.reject(new Error('Profile GET Failed'))) // Fails here if response not `ok`
  .get('avatar') // Get the response JSON object's `avatar` key value
  .then(avatarUrl => imageElem.src = avatarUrl)

const fetch  = require('isomorphic-fetch');

FP.resolve(fetch('https://api.github.com/users/justsml'))
  .tap(res => console.log(`github user req ok? ${res.ok}`))
  .then(res => res.json())
  .then(data => console.log('data', data.avatar_url))
  // NEXT LINE SHOULD WORK!!!
  .tap(data => console.log('github result', data))
  //.then(data => console.log(data))

const user = FP.resolve({username, password})
const userArr = FP.resolve([123, 'Smith', 'Agent'])

const user = FP.resolve({username, password})
const userArr = FP.resolve([123, 'Smith', 'Agent'])

// https://runkit.com/justsml/fp-bug-error-handling

const FP = require('functional-promises')

const errorTwoMaps = FP.chain()
  .map(x => Promise.reject(x))
  .map(x => Promise.reject(x))
  .catch(e => {
    console.log(e); 
    return new Error("silly");
  })
  .chainEnd();

const errorOneMap = FP.chain()
  .quiet(0)
  .map(x => Promise.reject(x))  
  .chainEnd();

errorOneMap([41])
    .then(console.info.bind(console, 'ONE:'))
    .catch(console.error.bind(console))

errorTwoMaps([42])
    .then(console.info.bind(console, 'TWO:'))
    .catch(console.error.bind(console))

const Users = mongoose.collections('users')

// initial non-FP promise wrapped with static helper `FP.timeout(fn/promise, msec)`
const getUserSocialData = id => FP.timeout(Users.find({_id: id}), 5000)
  .timeout(1000) // set 1 sec limit
  .then(user => api.getAllSocialData(user)) // 1 sec limit
  .get('socialAccounts') // extract
  .map(account => loadSupportHistory(account)) // no timeout limit

const Users = mongoose.collections('users')

const getUserSocialData = id => FP.chain({timeout: 10000})
  .then(() => Users.find({_id: id}))
  .then(user => api.getAllSocialData(user))
  .get('socialAccounts') // extract
  .map(account => loadSupportHistory(account))
  .run() // optional arg would be passed to the first thenable in the chain

FP.resolve([1, 0])
  .map(count => FP.resolve(count).then(c => 1 / c).catch(err => 'Error ignored!'))

FP.resolve([1, 0])
  .quiet()
  .map(count => FP.resolve(count).then(c => 1 / c))
  .catch(err => 'Error ignored!')

const FP = require('functional-promises')
const iThrowThings = async () => {
  throw new Error('🔪🔪🔪🔪🔪🔪🔪')
}

const brokenPromises = () => FP.resolve([{ tears: true }])
  .map(iThrowThings)
  .then(() => {
    console.log('whaaaa')
  }).catch(ex => { throw ex })

try {
  brokenPromises()
} catch (ex) {
  console.log('dumb me')
}

function findInLogs(searchText, logName = 'system') {
  return FP.stream(fs.createReadStream(`/var/log/${logName}`, {encoding: 'utf8'}))
  .on('data', data => {
    if (data.indexOf(searchText) > -1) {
      this.resolve(`Found ${searchText} in logs!`);
    }
  })
  .on('error', err => this.reject(err))
  .on('finish', () => this.resolve(`Searched text not found!`));
}

        super(message); // 'Error' breaks prototype chain here
        Object.setPrototypeOf(this, new.target.prototype); // restore prototype chain

// options ref: https://lodash.com/docs/4.17.10#throttle

// proposed options for .chain:
const doLotsOfThings = FP.chain({throttle: { wait: 1000, leading: false, trailing: true }})
  .then(doThing)
  .tap(logThing)
  .map(transformThings)
  .tap(() => console.log('end chain'))
  .chainEnd()

doLotsOfThings()
// output: end chain

doLotsOfThings()
// wait: ~1,000 milliseconds
// output: end chain
doLotsOfThings()
// wait: ~2,000 milliseconds
// output: end chain

const throttle = require('lodash/fp/throttle');
// lodash auto curries, so we just wrap chain with `throttle(1000, fn)`

const doLotsOfThings = throttle(1000, FP.chain()  // < ... yea, any better?
  .then(doThing)
  .tap(logThing)
  .map(transformThings)
  .chainEnd())

const throttle = require('lodash/fp/throttle');
// lodash auto curries, so we just pass `throttle(1000)` into the .chainEnd()

const doLotsOfThings = FP.chain()
  .then(doThing)
  .tap(logThing)
  .map(transformThings)
  .chainEnd({wrappers: [throttle(1000)]}) // < ... yea, any better?