/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

/* eslint-env mocha */

'use strict'

const assert = require('assert')
const composer = require('../composer')
const conductor = require('../conductor')
const name = 'TestAction'
const wsk = conductor({ ignore_certs: process.env.IGNORE_CERTS && process.env.IGNORE_CERTS !== 'false' && process.env.IGNORE_CERTS !== '0' })

// deploy action
const define = action => wsk.actions.delete(action.name).catch(() => { }).then(() => wsk.actions.create(action))

// deploy and invoke composition
const invoke = (composition, params = {}, blocking = true) => wsk.compositions.deploy(Object.assign({ name }, composition.compile()), true)
  .then(() => wsk.actions.invoke({ name, params, blocking }))
  .then(activation => activation.response.success ? activation : Promise.reject(Object.assign(new Error(), { error: activation })))

// redis configuration
const redis = process.env.REDIS ? { uri: process.env.REDIS } : false
if (process.env.REDIS && process.env.REDIS_CA) redis.ca = process.env.REDIS_CA

describe('composer', function () {
  let n, x, y // dummy variables

  this.timeout(60000)

  before('deploy test actions', function () {
    if (!redis) console.error('------------------------------------------------\nMissing redis configuration, skipping some tests\n------------------------------------------------')
    return define({ name: 'echo', action: 'const main = x=>x' })
      .then(() => define({ name: 'DivideByTwo', action: 'function main({n}) { return { n: n / 2 } }' }))
      .then(() => define({ name: 'TripleAndIncrement', action: 'function main({n}) { return { n: n * 3 + 1 } }' }))
      .then(() => define({ name: 'isNotOne', action: 'function main({n}) { return { value: n != 1 } }' }))
      .then(() => define({ name: 'isEven', action: 'function main({n}) { return { value: n % 2 == 0 } }' }))
      .then(() => wsk.compositions.deploy(Object.assign({ name: '_DivideByTwo' }, composer.seq('DivideByTwo').compile()), true))
  })

  describe('blocking invocations', function () {
    describe('actions', function () {
      it('action must return true', function () {
        return invoke(composer.action('isNotOne'), { n: 0 }).then(activation => assert.deepStrictEqual(activation.response.result, { value: true }))
      })

      it('action must return false', function () {
        return invoke(composer.action('isNotOne'), { n: 1 }).then(activation => assert.deepStrictEqual(activation.response.result, { value: false }))
      })

      it('action must return activationId', function () {
        return invoke(composer.async('isNotOne'), { n: 1 }).then(activation => assert.ok(activation.response.result.activationId))
      })

      it('action name must parse to fully qualified', function () {
        let combos = [
          { n: 42, s: false, e: 'Name must be a string' },
          { n: '', s: false, e: 'Name is not valid' },
          { n: ' ', s: false, e: 'Name is not valid' },
          { n: '/', s: false, e: 'Name is not valid' },
          { n: '//', s: false, e: 'Name is not valid' },
          { n: '/a', s: false, e: 'Name is not valid' },
          { n: '/a/b/c/d', s: false, e: 'Name is not valid' },
          { n: '/a/b/c/d/', s: false, e: 'Name is not valid' },
          { n: 'a/b/c/d', s: false, e: 'Name is not valid' },
          { n: '/a/ /b', s: false, e: 'Name is not valid' },
          { n: 'a', e: false, s: '/_/a' },
          { n: 'a/b', e: false, s: '/_/a/b' },
          { n: 'a/b/c', e: false, s: '/a/b/c' },
          { n: '/a/b', e: false, s: '/a/b' },
          { n: '/a/b/c', e: false, s: '/a/b/c' }
        ]
        combos.forEach(({ n, s, e }) => {
          if (s) {
            // good cases
            assert.ok(composer.action(n).name, s)
          } else {
            // error cases
            try {
              composer.action(n)
              assert.fail()
            } catch (error) {
              assert.ok(error.message.startsWith(e))
            }
          }
        })
      })

      it('invalid options', function () {
        try {
          invoke(composer.action('foo', 42))
          assert.fail()
        } catch (error) {
          assert.ok(error.message.startsWith('Invalid argument'))
        }
      })

      it('too many arguments', function () {
        try {
          invoke(composer.action('foo', {}, 'foo'))
          assert.fail()
        } catch (error) {
          assert.ok(error.message.startsWith('Too many arguments'))
        }
      })
    })

    describe('dynamic', function () {
      it('dynamic action invocation', function () {
        return invoke(composer.dynamic(), { type: 'action', name: 'DivideByTwo', params: { n: 42 } }).then(activation => assert.deepStrictEqual(activation.response.result, { n: 21 }))
      })

      it('missing type', function () {
        return invoke(composer.dynamic(), { name: 'DivideByTwo', params: { n: 42 } }).then(() => assert.fail(), activation => assert.ok(activation.error.response.result.error))
      })

      it('invalid type', function () {
        return invoke(composer.dynamic(), { type: 42, name: 'DivideByTwo', params: { n: 42 } }).then(() => assert.fail(), activation => assert.ok(activation.error.response.result.error))
      })

      it('missing name', function () {
        return invoke(composer.dynamic(), { type: 'action', params: { n: 42 } }).then(() => assert.fail(), activation => assert.ok(activation.error.response.result.error))
      })

      it('missing params', function () {
        return invoke(composer.dynamic(), { type: 'action', name: 'DivideByTwo' }).then(() => assert.fail(), activation => assert.ok(activation.error.response.result.error))
      })
    })

    describe('literals', function () {
      it('true', function () {
        return invoke(composer.literal(true)).then(activation => assert.deepStrictEqual(activation.response.result, { value: true }))
      })

      it('42', function () {
        return invoke(composer.literal(42)).then(activation => assert.deepStrictEqual(activation.response.result, { value: 42 }))
      })

      it('invalid argument', function () {
        try {
          invoke(composer.literal(invoke))
          assert.fail()
        } catch (error) {
          assert.ok(error.message.startsWith('Invalid argument'))
        }
      })

      it('too many arguments', function () {
        try {
          invoke(composer.literal('foo', 'foo'))
          assert.fail()
        } catch (error) {
          assert.ok(error.message.startsWith('Too many arguments'))
        }
      })
    })

    describe('functions', function () {
      it('function must return true', function () {
        return invoke(composer.function(({ n }) => n % 2 === 0), { n: 4 }).then(activation => assert.deepStrictEqual(activation.response.result, { value: true }))
      })

      it('function must return false', function () {
        return invoke(composer.function(function ({ n }) { return n % 2 === 0 }), { n: 3 }).then(activation => assert.deepStrictEqual(activation.response.result, { value: false }))
      })

      it('function must fail', function () {
        return invoke(composer.function(() => n)).then(() => assert.fail(), activation => assert.ok(activation.error.response.result.error))
      })

      it('function must throw', function () {
        return invoke(composer.function(() => ({ error: 'foo', n: 42 }))).then(() => assert.fail(), activation => assert.deepStrictEqual(activation.error.response.result, { error: 'foo' }))
      })

      it('function must mutate params', function () {
        return invoke(composer.function(params => { params.foo = 'foo' }), { n: 42 }).then(activation => assert.deepStrictEqual(activation.response.result, { foo: 'foo', n: 42 }))
      })

      it('function as string', function () {
        return invoke(composer.function('({ n }) => n % 2 === 0'), { n: 4 }).then(activation => assert.deepStrictEqual(activation.response.result, { value: true }))
      })

      it('function may return a promise', function () {
        return invoke(composer.function(({ n }) => Promise.resolve(n % 2 === 0)), { n: 4 }).then(activation => assert.deepStrictEqual(activation.response.result, { value: true }))
      })

      it('invalid argument', function () {
        try {
          invoke(composer.function(42))
          assert.fail()
        } catch (error) {
          assert.ok(error.message.startsWith('Invalid argument'))
        }
      })

      it('too many arguments', function () {
        try {
          invoke(composer.function(() => n, () => { }))
          assert.fail()
        } catch (error) {
          assert.ok(error.message.startsWith('Too many arguments'))
        }
      })
    })

    describe('deserialize', function () {
      it('should deserialize a serialized composition', function () {
        const json = {
          'type': 'sequence',
          'components': [{
            'type': 'action',
            'name': 'echo'
          }, {
            'type': 'action',
            'name': 'echo'
          }]
        }
        return invoke(composer.parse(json), { message: 'hi' }).then(activation => assert.deepStrictEqual(activation.response.result, { message: 'hi' }))
      })
    })

    describe('tasks', function () {
      describe('action tasks', function () {
        it('action must return true', function () {
          return invoke(composer.task('isNotOne'), { n: 0 }).then(activation => assert.deepStrictEqual(activation.response.result, { value: true }))
        })
      })

      describe('function tasks', function () {
        it('function must return true', function () {
          return invoke(composer.task(({ n }) => n % 2 === 0), { n: 4 }).then(activation => assert.deepStrictEqual(activation.response.result, { value: true }))
        })
      })

      describe('null task', function () {
        it('null task must return input', function () {
          return invoke(composer.task(null), { foo: 'foo' }).then(activation => assert.deepStrictEqual(activation.response.result, { foo: 'foo' }))
        })

        it('null task must fail on error input', function () {
          return invoke(composer.task(null), { error: 'foo' }).then(() => assert.fail(), activation => assert.deepStrictEqual(activation.error.response.result, { error: 'foo' }))
        })
      })

      describe('invalid tasks', function () {
        it('a Boolean is not a valid task', function () {
          try {
            invoke(composer.task(false))
            assert.fail()
          } catch (error) {
            assert.ok(error.message.startsWith('Invalid argument'))
          }
        })

        it('a number is not a valid task', function () {
          try {
            invoke(composer.task(42))
            assert.fail()
          } catch (error) {
            assert.ok(error.message.startsWith('Invalid argument'))
          }
        })

        it('a dictionary is not a valid task', function () {
          try {
            invoke(composer.task({ foo: 'foo' }))
            assert.fail()
          } catch (error) {
            assert.ok(error.message.startsWith('Invalid argument'))
          }
        })
      })

      it('too many arguments', function () {
        try {
          invoke(composer.task('foo', 'foo'))
          assert.fail()
        } catch (error) {
          assert.ok(error.message.startsWith('Too many arguments'))
        }
      })
    })

    describe('combinators', function () {
      describe('sequence', function () {
        it('flat', function () {
          return invoke(composer.sequence('TripleAndIncrement', 'DivideByTwo', 'DivideByTwo'), { n: 5 })
            .then(activation => assert.deepStrictEqual(activation.response.result, { n: 4 }))
        })

        it('nested right', function () {
          return invoke(composer.sequence('TripleAndIncrement', composer.sequence('DivideByTwo', 'DivideByTwo')), { n: 5 })
            .then(activation => assert.deepStrictEqual(activation.response.result, { n: 4 }))
        })

        it('nested left', function () {
          return invoke(composer.sequence(composer.sequence('TripleAndIncrement', 'DivideByTwo'), 'DivideByTwo'), { n: 5 })
            .then(activation => assert.deepStrictEqual(activation.response.result, { n: 4 }))
        })

        it('seq', function () {
          return invoke(composer.seq('TripleAndIncrement', 'DivideByTwo', 'DivideByTwo'), { n: 5 })
            .then(activation => assert.deepStrictEqual(activation.response.result, { n: 4 }))
        })
      })

      describe('parallel', function () {
        const test = redis ? it : it.skip
        test('parallel', function () {
          return invoke(composer.parallel('TripleAndIncrement', 'DivideByTwo'), { n: 42, $composer: { redis } })
            .then(activation => assert.deepStrictEqual(activation.response.result, { value: [{ n: 127 }, { n: 21 }] }))
        })

        test('par', function () {
          return invoke(composer.par('DivideByTwo', 'TripleAndIncrement', 'isEven'), { n: 42, $composer: { redis } })
            .then(activation => assert.deepStrictEqual(activation.response.result, { value: [{ n: 21 }, { n: 127 }, { value: true }] }))
        })

        test('map', function () {
          return invoke(composer.map('TripleAndIncrement', 'DivideByTwo'), { value: [{ n: 3 }, { n: 5 }, { n: 7 }], $composer: { redis } })
            .then(activation => assert.deepStrictEqual(activation.response.result, { value: [{ n: 5 }, { n: 8 }, { n: 11 }] }))
        })
      })

      describe('if', function () {
        it('condition = true', function () {
          return invoke(composer.if('isEven', 'DivideByTwo', 'TripleAndIncrement'), { n: 4 })
            .then(activation => assert.deepStrictEqual(activation.response.result, { n: 2 }))
        })

        it('condition = false', function () {
          return invoke(composer.if('isEven', 'DivideByTwo', 'TripleAndIncrement'), { n: 3 })
            .then(activation => assert.deepStrictEqual(activation.response.result, { n: 10 }))
        })

        it('condition = true, then branch only', function () {
          return invoke(composer.if('isEven', 'DivideByTwo'), { n: 4 })
            .then(activation => assert.deepStrictEqual(activation.response.result, { n: 2 }))
        })

        it('condition = false, then branch only', function () {
          return invoke(composer.if('isEven', 'DivideByTwo'), { n: 3 })
            .then(activation => assert.deepStrictEqual(activation.response.result, { n: 3 }))
        })

        it('condition = true, nosave option', function () {
          return invoke(composer.if_nosave('isEven', params => { params.then = true }, params => { params.else = true }), { n: 2 })
            .then(activation => assert.deepStrictEqual(activation.response.result, { value: true, then: true }))
        })

        it('condition = false, nosave option', function () {
          return invoke(composer.if_nosave('isEven', params => { params.then = true }, params => { params.else = true }), { n: 3 })
            .then(activation => assert.deepStrictEqual(activation.response.result, { value: false, else: true }))
        })

        it('too many arguments', function () {
          try {
            invoke(composer.if('isEven', 'DivideByTwo', 'TripleAndIncrement', 'TripleAndIncrement'))
            assert.fail()
          } catch (error) {
            assert.ok(error.message.startsWith('Too many arguments'))
          }
        })
      })

      describe('while', function () {
        it('a few iterations', function () {
          return invoke(composer.while('isNotOne', ({ n }) => ({ n: n - 1 })), { n: 4 })
            .then(activation => assert.deepStrictEqual(activation.response.result, { n: 1 }))
        })

        it('no iteration', function () {
          return invoke(composer.while(() => false, ({ n }) => ({ n: n - 1 })), { n: 1 })
            .then(activation => assert.deepStrictEqual(activation.response.result, { n: 1 }))
        })

        it('nosave option', function () {
          return invoke(composer.while_nosave(({ n }) => ({ n, value: n !== 1 }), ({ n }) => ({ n: n - 1 })), { n: 4 })
            .then(activation => assert.deepStrictEqual(activation.response.result, { value: false, n: 1 }))
        })

        it('too many arguments', function () {
          try {
            invoke(composer.while('isNotOne', ({ n }) => ({ n: n - 1 }), ({ n }) => ({ n: n - 1 })), { n: 4 })
            assert.fail()
          } catch (error) {
            assert.ok(error.message.startsWith('Too many arguments'))
          }
        })
      })

      describe('dowhile', function () {
        it('a few iterations', function () {
          return invoke(composer.dowhile(({ n }) => ({ n: n - 1 }), 'isNotOne'), { n: 4 })
            .then(activation => assert.deepStrictEqual(activation.response.result, { n: 1 }))
        })

        it('one iteration', function () {
          return invoke(composer.dowhile(({ n }) => ({ n: n - 1 }), () => false), { n: 1 })
            .then(activation => assert.deepStrictEqual(activation.response.result, { n: 0 }))
        })

        it('nosave option', function () {
          return invoke(composer.dowhile_nosave(({ n }) => ({ n: n - 1 }), ({ n }) => ({ n, value: n !== 1 })), { n: 4 })
            .then(activation => assert.deepStrictEqual(activation.response.result, { value: false, n: 1 }))
        })

        it('too many arguments', function () {
          try {
            invoke(composer.dowhile(({ n }) => ({ n: n - 1 }), 'isNotOne', ({ n }) => ({ n: n - 1 })), { n: 4 })
            assert.fail()
          } catch (error) {
            assert.ok(error.message.startsWith('Too many arguments'))
          }
        })
      })

      describe('try', function () {
        it('no error', function () {
          return invoke(composer.try(() => true, error => ({ message: error.error })))
            .then(activation => assert.deepStrictEqual(activation.response.result, { value: true }))
        })

        it('error', function () {
          return invoke(composer.try(() => ({ error: 'foo' }), error => ({ message: error.error })))
            .then(activation => assert.deepStrictEqual(activation.response.result, { message: 'foo' }))
        })

        it('try must throw', function () {
          return invoke(composer.try(composer.task(null), error => ({ message: error.error })), { error: 'foo' })
            .then(activation => assert.deepStrictEqual(activation.response.result, { message: 'foo' }))
        })

        it('while must throw', function () {
          return invoke(composer.try(composer.while(composer.literal(false), null), error => ({ message: error.error })), { error: 'foo' })
            .then(activation => assert.deepStrictEqual(activation.response.result, { message: 'foo' }))
        })

        it('if must throw', function () {
          return invoke(composer.try(composer.if(composer.literal(false), null), error => ({ message: error.error })), { error: 'foo' })
            .then(activation => assert.deepStrictEqual(activation.response.result, { message: 'foo' }))
        })

        it('retain', function () {
          return invoke(composer.retain(composer.try(() => ({ p: 4 }), null)), { n: 3 })
            .then(activation => assert.deepStrictEqual(activation.response.result, { params: { n: 3 }, result: { p: 4 } }))
        })

        it('too many arguments', function () {
          try {
            invoke(composer.try('isNotOne', 'isNotOne', 'isNotOne'))
            assert.fail()
          } catch (error) {
            assert.ok(error.message.startsWith('Too many arguments'))
          }
        })
      })

      describe('finally', function () {
        it('no error', function () {
          return invoke(composer.finally(() => true, params => ({ params })))
            .then(activation => assert.deepStrictEqual(activation.response.result, { params: { value: true } }))
        })

        it('error', function () {
          return invoke(composer.finally(() => ({ error: 'foo' }), params => ({ params })))
            .then(activation => assert.deepStrictEqual(activation.response.result, { params: { error: 'foo' } }))
        })

        it('too many arguments', function () {
          try {
            invoke(composer.finally('isNotOne', 'isNotOne', 'isNotOne'))
            assert.fail()
          } catch (error) {
            assert.ok(error.message.startsWith('Too many arguments'))
          }
        })
      })

      describe('let', function () {
        it('one variable', function () {
          return invoke(composer.let({ x: 42 }, () => x))
            .then(activation => assert.deepStrictEqual(activation.response.result, { value: 42 }))
        })

        it('masking', function () {
          return invoke(composer.let({ x: 42 }, composer.let({ x: 69 }, () => x)))
            .then(activation => assert.deepStrictEqual(activation.response.result, { value: 69 }))
        })

        it('two variables', function () {
          return invoke(composer.let({ x: 42 }, composer.let({ y: 69 }, () => x + y)))
            .then(activation => assert.deepStrictEqual(activation.response.result, { value: 111 }))
        })

        it('two variables combined', function () {
          return invoke(composer.let({ x: 42, y: 69 }, () => x + y))
            .then(activation => assert.deepStrictEqual(activation.response.result, { value: 111 }))
        })

        it('scoping', function () {
          return invoke(composer.let({ x: 42 }, composer.let({ x: 69 }, () => x), ({ value }) => value + x))
            .then(activation => assert.deepStrictEqual(activation.response.result, { value: 111 }))
        })

        it('invalid argument', function () {
          try {
            invoke(composer.let(invoke))
            assert.fail()
          } catch (error) {
            assert.ok(error.message.startsWith('Invalid argument'))
          }
        })
      })

      describe('mask', function () {
        it('let/let/mask', function () {
          return invoke(composer.let({ x: 42 }, composer.let({ x: 69 }, composer.mask(() => x))))
            .then(activation => assert.deepStrictEqual(activation.response.result, { value: 42 }))
        })

        it('let/mask/let', function () {
          return invoke(composer.let({ x: 42 }, composer.mask(composer.let({ x: 69 }, () => x))))
            .then(activation => assert.deepStrictEqual(activation.response.result, { value: 69 }))
        })

        it('let/let/try/mask', function () {
          return invoke(composer.let({ x: 42 }, composer.let({ x: 69 },
            composer.try(composer.mask(() => x), () => { }))))
            .then(activation => assert.deepStrictEqual(activation.response.result, { value: 42 }))
        })

        it('let/let/let/mask', function () {
          return invoke(composer.let({ x: 42 }, composer.let({ x: 69 },
            composer.let({ x: -1 }, composer.mask(() => x)))))
            .then(activation => assert.deepStrictEqual(activation.response.result, { value: 69 }))
        })

        it('let/let/let/mask/mask', function () {
          return invoke(composer.let({ x: 42 }, composer.let({ x: 69 },
            composer.let({ x: -1 }, composer.mask(composer.mask(() => x))))))
            .then(activation => assert.deepStrictEqual(activation.response.result, { value: 42 }))
        })

        it('let/let/mask/let/mask', function () {
          return invoke(composer.let({ x: 42 }, composer.let({ x: 69 },
            composer.mask(composer.let({ x: -1 }, composer.mask(() => x))))))
            .then(activation => assert.deepStrictEqual(activation.response.result, { value: 42 }))
        })
      })

      describe('retain', function () {
        it('base case', function () {
          return invoke(composer.retain('TripleAndIncrement'), { n: 3 })
            .then(activation => assert.deepStrictEqual(activation.response.result, { params: { n: 3 }, result: { n: 10 } }))
        })

        it('throw error', function () {
          return invoke(composer.retain(() => ({ error: 'foo' })), { n: 3 })
            .then(() => assert.fail(), activation => assert.deepStrictEqual(activation.error.response.result, { error: 'foo' }))
        })

        it('catch error', function () {
          return invoke(composer.retain_catch(() => ({ error: 'foo' })), { n: 3 })
            .then(activation => assert.deepStrictEqual(activation.response.result, { params: { n: 3 }, result: { error: 'foo' } }))
        })
      })

      describe('merge', function () {
        it('base case', function () {
          return invoke(composer.merge('TripleAndIncrement'), { n: 3, p: 4 })
            .then(activation => assert.deepStrictEqual(activation.response.result, { n: 10, p: 4 }))
        })
      })

      describe('repeat', function () {
        it('a few iterations', function () {
          return invoke(composer.repeat(3, 'DivideByTwo'), { n: 8 })
            .then(activation => assert.deepStrictEqual(activation.response.result, { n: 1 }))
        })

        it('invalid argument', function () {
          try {
            invoke(composer.repeat('foo'))
            assert.fail()
          } catch (error) {
            assert.ok(error.message.startsWith('Invalid argument'))
          }
        })
      })

      describe('retry', function () {
        it('success', function () {
          return invoke(composer.let({ x: 2 }, composer.retry(2, () => x-- > 0 ? { error: 'foo' } : 42)))
            .then(activation => assert.deepStrictEqual(activation.response.result, { value: 42 }))
        })

        it('failure', function () {
          return invoke(composer.let({ x: 2 }, composer.retry(1, () => x-- > 0 ? { error: 'foo' } : 42)))
            .then(() => assert.fail(), activation => assert.deepStrictEqual(activation.error.response.result.error, 'foo'))
        })

        it('invalid argument', function () {
          try {
            invoke(composer.retry('foo'))
            assert.fail()
          } catch (error) {
            assert.ok(error.message.startsWith('Invalid argument'))
          }
        })
      })
    })
  })

  describe('compositions', function () {
    describe('collatz', function () {
      it('composition must return { n: 1 }', function () {
        return invoke(composer.while('isNotOne', composer.if('isEven', 'DivideByTwo', 'TripleAndIncrement')), { n: 5 })
          .then(activation => assert.deepStrictEqual(activation.response.result, { n: 1 }))
      })
    })
  })
})