import { createTrader } from 'devalpha'

const feeds = {
  myQuandlFeed: [1, 2, 3, 4],
  myStreamFeed: fs.createReadStream(...)
}

const strategy = (context, action) => {

  // Place an order
  if (action.type === 'myQuandlFeed') {
    context.order({
      identifier: action.payload.identifier,
      quantity: 100 * action.payload.signalStrength,
      price: 1000
    })
  }

  // Get current portfolio state
  const state = context.state()

  // Cancel an order
  if (state.capital.cash < 10000) {
    context.cancel({
      id: 123
    })
  }
}

// Create the trading stream
const stream = createTrader({ feeds }, strategy)

// Consumer the stream and make money!
stream.done(() => {
  console.log('Finished!')
})

const settings = {

  /* Toggle backtesting/realtime mode. In backtesting mode, events from the feed stream are pulled
  as needed rather than pushed as created. This allows you to do a number of events for each feed
  item, and then pull the next one only when you're finished with the current.
  
  NOTE: DevAlpha will only activate realtime mode when this parameter is explicitly set to `false`.
  This means that setting `backtesting: 0` will not do the job. */
  backtesting: true,

  /* Only used in realtime mode. The client manages order execution, and is provided to the 
  internal broker middleware. */
  client: null,

  /* Define the starting capital of your algorithm. Use only in backtesting mode. In realtime mode
  you're better of using the `initialStates` setting instead. */
  startCapital: 0,
  
  /* Provide initial states for your algorithm. One obvious use case would be when realtime
  trading, and you want to fetch positions, capital, or order information from your broker. */
  initialStates: {},

  /* An object mapping event names to stream-like objects. See https://highlandjs.org/#_(source)
  for a definition of "stream-like". Keys will be used as event type names. */
  feeds: {},

  /* Settings for your backtest. */
  backtest: {
    
    /* Denotes when your backtest is started (the first date of your backtesting data). */
    timestamp: 0,

    /* A number or a function used when calculating expected commission. */
    commission: 0

  },

  /* Settings for the guard middleware, which will prevent or alter orders (based on your
  configuration). */
  guard: {
    
    /* Allow/disallow shorting. */
    shorting: false,
    
    /* Allow/disallow trading on margin. */
    margin: false,

    /* An array of restricted instrument identifiers. Example: ['GOOG', 'SPOT']. */
    restricted: []

  },

  /* DevAlpha dashboard settings. */
  dashboard: {

    /* Toggle the DevAlpha dashboard. */
    active: false,

    /* Port used to pipe portfolio data. */
    port: 4449
  }

}

const settings = {...}
const strategy = (context, action) => {...}

createTrader(settings, strategy).resume()

import { createTrader, ORDER_FILLED, ORDER_FAILED } from 'devalpha'

const settings = {...}
const strategy = (context, action) => {...}

const stream = createTrader(settings, strategy)

const slackStream = stream.fork()
const redisStream = stream.fork()

// Get Slack notifications on filled or failed orders
slackStream.each((event) => {
  if (event.action.type === ORDER_FILLED) {
    slackLogger.log('Hooray! An order was filled!')
  } else if (event.action.type === ORDER_FAILED) {
    slackLogger.log('Whoops! One of your orders was not executed!')
  }
})

// Place the current state in a Redis store
redisStream.each((event) => {
  redisClient.set('state', JSON.stringify(event.state))
})