var Roach = require('roachjs')

var client = new Roach({
    uri: 'http://127.0.0.1:8080'
})

module.exports = client

client.get("sample_key", function(err, value, meta) {
    if(err) throw err

    client.put("other_key", value, function(err) {
        if(err) {
            // Failed
        }
        else {
            // Sucess
        }
    })
})

// You should prepare your queries and send them in a single batch
// For optimal performance
// This actually returns you a new client
var c = client.prepare()

// This callback will be the first to be executed
c.get("sample_key", function(err, value, meta) {
    if(err) throw err

    // Do something...
})

c.get("sample_key2", function(err, value, meta) {
    if(err) throw err

    // Do something...
})

c.put("some_key", "some_value", function(err) {
    if(err) throw err

    // Do something
})

// The flush callback is the last one to be called
c.flush(function(err, meta) {
    if(err) throw err

    console.log('Sucessfuly flushed %d queries.', meta.flushed)
})

var c = client.prepare()

// This objects (references) will be sent in place of the callback
// This pattern is a great pattern to keep your sanity :)
var dogsResp    = c.Response()
var kittensResp = c.Response()

c.get("dogs", dogsResp)
c.get("kittens", kittensResp)

c.flush(function(err) {
    if(err) throw err

    if(dogsResp.err) {
        throw new Error('failed to get dogs')
    }

    if(kittensResp.err) {
        throw new Error('failed to get kittens')
    }

    c.put("other_dogs", dogsResp.value, function(err) {
        if(err) throw err
    })

    c.put("other_kittens", kittensResp.value, function(err) {
        if(err) throw err
    })

    c.flush()
})

var opts = {
    name: "transaction example",
}

var errNoApples = new Error('Insufficient apples!')

var transaction = function(txn, commit, abort) {
    var applesInStock = txn.Response()

    txn.get("applesInStock", applesInStock)

    txn.flush(function(err) {
        if(err || applesInStock.err) {
            return abort(err)
        }

        var dispatch = 5
        var inStock = ParseInt(applesInStock.value)

        if(inStock < dispatch) {
            return abort(errNoApples)
        }

        txn.increment("applesInStock", -dispatch)
        txn.increment("applesInRoute", +dispatch)

        // Commit automatically flushes
        commit()
    })
}

client.runTransaction(opts, transaction, function(err, meta) {
    if(err === errNoApples) {
        // Alert user there are no more apples...
    }
    else if(err) {
        // Transaction failed...
    }
    else {
        // Transaction commited...
    }
})

client.get("key", function(err, value, meta) {})

client.put("key", "value", function(err, meta) {})

client.conditionalPut("status", "running", "stopped", function(err, meta) {})
client.conditionalPut("status", "new", null, function(err, meta) {})

client.contains("john", function(err, exists, meta) {
    if(exists === true) {
        // john exists in the datastore
    }
})

client.increment("counter", 5, function(err, newValue, meta) {
    console.log('counter current value is', newValue)
})

client.scan("a", "Z", 100, function(err, results, meta) {
    for(value as results) {
        console.log(value)
    }
})

client.delete("key", function(err, meta) {})

client.deleteRange("a", "Z", 100, function(err, deleted, meta) {
    console.log('deleted %d entries', deleted)
})

var c = client.prepare()

c.get("key", function(err, value, meta) {
    // Do something...
})

c.get("key2", function(err, value, meta) {
    // Do something...
})

c.put("key3", "value", function(err, meta) {
    // Do something...
})

c.flush()

client.flush(function(err, meta) {
    if(err) {
        // Flush failed..
    }
    else {
        console.log('flushed %d queries.', meta.flushed)
    }
})

var transaction = function(txn, commit, abort) {
    for(var i = 0; i < 100; i++) {
        var key = i.toString()

        // Provide an txn.Response()
        // just so it won't trow an error
        txn.put(key, "hello", txn.Response())
    }

    // Commit automatically flushes
    // the prepared transaction.
    commit()
}