//
// testing $sort aggregation pipeline for heterogeneity (SERVER-6125)
// method:
// Create an array with all the different types. (Array is created with correct sort order)
// Randomise it (to prevent $sort returning types in same order).
// Save the array members to the db.
// aggregate($sort)
// iterate through the array ensuring the _ids are in the correct order

// to make results array nested (problem 2)
function nestArray(nstArray) {
    for (x = 0; x < nstArray.length; x++) {
        nstArray[x].a = {b: nstArray[x].a};
    }
}

// sort and run the tests
function runSort(chkDoc, nest, problem) {
    var chkArray = setupArray();
    if (nest) {
        nestArray(chkArray);
    }
    Array.shuffle(chkArray);
    var t = db.s6125;
    t.drop();
    t.insert(chkArray);

    runAsserts(t.aggregate({$sort: chkDoc}).toArray(), problem);
}

// actually run the tests
function runAsserts(chkArray, problem) {
    // check the _id at [0] to determine which way around this has been sorted
    // then check for gt / lt.  Done rather than neq to preclude a < b > c issues
    if (chkArray[0]._id == 0) {
        for (var x = 0; x < chkArray.length - 1; x++) {
            assert.lt(chkArray[x]._id, chkArray[x + 1]._id);
        }
    } else if (chkArray[chkArray.length - 1]._id == 0) {
        for (var x = 0; x < chkArray.length - 1; x++) {
            assert.gt(chkArray[x]._id, chkArray[x + 1]._id);
        }
    } else {
        assert.eq(true, chkArray[0]._id == 0 || chkArray[chkArray.length - 1]._id == 0);
    }
}

// set up data
function setupArray() {
    return [
        {_id: 0, a: MinKey, ty: "MinKey"},
        {_id: 1, a: null, ty: "null"},
        {_id: 2, a: 1, ty: "Number"},
        {_id: 3, a: NumberLong(2), ty: "NumberLong"},
        {_id: 4, a: "3", ty: "String"},
        // Symbol not implemented in JS
        {_id: 5, a: {}, ty: "Object"},
        {_id: 6, a: new DBRef("test.s6125", ObjectId("0102030405060708090A0B0C")), ty: "DBRef"},
        {_id: 7, a: [], ty: "Empty Array"},
        {_id: 8, a: [1, 2, "a", "B"], ty: "Array"},
        {_id: 9, a: BinData(0, "77+9"), ty: "BinData"},
        {_id: 10, a: new ObjectId("0102030405060708090A0B0C"), ty: "ObjectId"},
        {_id: 11, a: true, ty: "Boolean"},
        {_id: 12, a: new Date(2), ty: "Date"},
        {_id: 13, a: new Timestamp(1 / 1000, 1), ty: "Timestamp"},
        {_id: 14, a: /regex/, ty: "RegExp"},
        {
          _id: 15,
          a: new DBPointer("test.s6125", new ObjectId("0102030405060708090A0B0C")),
          ty: "DBPointer"
        },
        {_id: 16, a: function() {}, ty: "Code"},
        // Code with Scope not implemented in JS
        {_id: 17, a: MaxKey, ty: "MaxKey"}
    ];
}

//***
// Begin testing for SERVER-6125
//***
Random.setRandomSeed();

// problem 1, does aggregate $sort work with all types
runSort({a: 1}, false, "p1");

// problem 2, does aggregate $sort work with all types nested
runSort({"a": 1}, true, "p2a");
runSort({"a.b": 1}, true, "p2b");

// problem 3, check reverse order sort
runSort({a: -1}, false, "p3");

// problem 4, reverse order sort with nested array
runSort({"a": -1}, true, "p4a");
runSort({"a.b": -1}, true, "p4b");