//var a = require('assertions')
var consistent = require('./consistent')
var es = require('event-stream')
var MuxDemux = require('../')
var test = require('tape')

/*
  socket.io behaves like two linked EventEmitters.
  calling emit on one, triggers listeners on the other.

  (see RemoteEventEmitter)

  test that two streams match.

  create a master stream and slave streams,
  assert that every chunk written to the master
  is eventually written to the slave.

  OKAY, my disconnection error is in HERE
  somewhere in here, things are breaking after reconnecting.
  what is it?

  
*/


function pair(f) {
  var a = MuxDemux()
  var b = MuxDemux()
  a.pipe(b).pipe(a)
  return [a, b]
}

function randomNumberStream (max, count) {
  count = count || 20
  max   = max   || 10
  return es.readable(function (i, cb) {
    this.emit('data', Math.random() * max)
    if(i > count)
    this.emit('end')
    cb()
  })
}

test('simple test', function simple (a) {

  var p = pair()
  var server = p.pop()
  var client = p.pop()

  var master = consistent(a)
  var slave  = master.createSlave()

  server.on('connection', function (stream) {
    a.equal(stream.meta, 'simple')
    stream
      .pipe(slave)
  })

  randomNumberStream()
    .on('end', onEnd)
    .pipe(master)
    .pipe(client.createWriteStream('simple'))

  function onEnd() {
    process.nextTick(function () {
      slave.validate()
      a.end()
    })
  }

});

//return
test('through', function (a) {

  var p = pair()
  var server = p.shift()
  var client = p.shift()

  var master = consistent(a)
  var slave1  = master.createSlave()
  var slave2  = master.createSlave()

  server.on('connection', function (stream) {
    a.equal(stream.meta, 'through')
    stream.pipe(slave1).pipe(stream) //ECHO
  })

  randomNumberStream()
    .pipe(master)
    .pipe(client.createStream('through'))
    .pipe(slave2)
    .on('end', function () {
      slave1.validate()
      slave2.validate()
      console.log('slave 1,2 valid')
      a.end()
    })

});


//  names do not have to be unique.
//  should create two seperate streams.


test('double', function (a) {
  var p = pair()
  var server = p.shift()
  var client = p.shift()

  var master1 = consistent(a)
  var slave1  = master1.createSlave()
  var master2 = consistent(a)
  var slave2  = master2.createSlave()

  server.on('connection', function (stream) {
    a.equal(stream.meta, 'through')
    stream.pipe(stream) //ECHO
  })

  randomNumberStream()
    .pipe(master1)
    .pipe(client.createStream('through'))
    .pipe(slave1)
    .on('end', function () {
      slave1.validate()
      console.log('slave1 valid')
    })

  //okay! this is breaking
  randomNumberStream()
    .pipe(master2)
    .pipe(client.createStream('through'))
    .pipe(slave2)
    .on('end', function () {
      slave2.validate()
      console.log('slave2 valid')
      a.end()
    })
});

/*
  since I'm here, I may as well implement pausing
  etc.

  pass through pause, so that it can be used
  to control stuff like scrolling.
*/

/*
if a function respects pause, that means that on pause(),
the next write should return false.

then, on resume() the next write should return true

this case is pretty simple.
*/


test('passes pause through2', function passesPauseThrough(a) {
  var p = pair()
  var server = p.pop()
  var client = p.pop()

  server.on('connection', function (stream) {
    a.equal(stream.meta, 'paused')
    stream
    var i = 0
    stream.on('data', function () {
      if(i++ % 2)
        stream.pause()
      else //if (stream.paused)
        stream.resume()
    })
  })

  master = (client.createWriteStream('paused'))

  process.nextTick(function () {

    a.equal(master.write('hello'), true, 'should be free')
    a.equal(master.write('paused now'), false, 'should be paused')
    a.equal(master.write('hello'), true, 'should be free2')
    a.equal(master.write('paused now'), false, 'should be paused')

    master.end() 
    console.log('pause is correct')

    process.nextTick(function () {
      a.end()
    })

  })
});