/**
 * Tests for the 'dicom/dicomParser.js' file.
 */
/** @module tests/dicom */
// Do not warn if these variables were not defined before.
/* global QUnit */
QUnit.module("dicomParser");

// WARNING about PhantomJS 1.9
// ---------------------------
// TypedArray implementation seems incomplete, at least different than observed
// behavior in browsers... 
// For a DICOM dataset, it was giving an: 
// 'RangeError: ArrayBuffer length minus the byteOffset is not a multiple of the element size.'
// Which seem to originate from reading the data of first tag 
// (FileMetaInformationGroupLength, Uint32 -> size=4)
// at offset 140 of a file of size 3070. 3070-140=2930; 2930/4=732.5...
//
// Error which, according to specs, should be thrown when the size of the data
// to read is not specified (see
// https://www.khronos.org/registry/typedarray/specs/latest/#7). But it is specified...
// 
// So I updated the data to be of the correct size (in this case 3072)... 

/**
 * Tests for {@link dwv.dicom.DicomParser} using simple DICOM data.
 * Using remote file for CI integration.
 * @function module:tests/dicom~dicomParser
 */
QUnit.test("Test simple DICOM parsing.", function (assert) {
    var done = assert.async();

    var request = new XMLHttpRequest();
    var urlRoot = "https://raw.githubusercontent.com/ivmartel/dwv/master";
    var url = urlRoot + "/tests/data/dwv-test-simple.dcm";
    request.open('GET', url, true);
    request.responseType = "arraybuffer";
    request.onerror = function (event) {
        console.log(event);
    };
    request.onload = function (/*event*/) {
        assert.ok((this.response.byteLength!==0), "Got a response.");

        // parse DICOM
        var dicomParser = new dwv.dicom.DicomParser();
        dicomParser.parse(this.response);

        var numRows = 32;
        var numCols = 32;

        // raw tags
        var rawTags = dicomParser.getRawDicomElements();
        // check values
        assert.equal(rawTags.x00280010.value[0], numRows, "Number of rows (raw)");
        assert.equal(rawTags.x00280011.value[0], numCols, "Number of columns (raw)");
        // ReferencedImageSequence - ReferencedSOPInstanceUID
        assert.equal(rawTags.x00081140.value[0].x00081155.value[0],
            "1.3.12.2.1107.5.2.32.35162.2012021515511672669154094",
            "ReferencedImageSequence SQ (raw)");

        // wrapped tags
        var tags = dicomParser.getDicomElements();
        // wrong key
        assert.equal(tags.getFromKey("x12345678"), null, "Wrong key");
        assert.notOk(tags.getFromKey("x12345678"), "Wrong key fails if test" );
        // empty key
        assert.equal(tags.getFromKey("x00081050"), "", "Empty key");
        assert.notOk(tags.getFromKey("x00081050"), "Empty key fails if test" );
        // good key
        assert.equal(tags.getFromKey("x00280010"), numRows, "Good key");
        assert.ok(tags.getFromKey("x00280010"), "Good key passes if test" );
        // zero value (passes test since it is a string)
        assert.equal(tags.getFromKey("x00181318"), 0, "Good key, zero value");
        assert.ok(tags.getFromKey("x00181318"), "Good key, zero value passes if test" );

        // check values
        assert.equal(tags.getFromName("Rows"), numRows, "Number of rows");
        assert.equal(tags.getFromName("Columns"), numCols, "Number of columns");
        // ReferencedImageSequence - ReferencedSOPInstanceUID
        // only one item value -> returns the object directly
        // (no need for tags.getFromName("ReferencedImageSequence")[0])
        assert.equal(tags.getFromName("ReferencedImageSequence").x00081155.value[0],
            "1.3.12.2.1107.5.2.32.35162.2012021515511672669154094",
            "ReferencedImageSequence SQ");

        // finish async test
        done();
    };
    request.send(null);
});

/**
 * Tests for {@link dwv.dicom.DicomParser} using sequence test DICOM data.
 * Using remote file for CI integration.
 * @function module:tests/dicom~dicomParser
 */
QUnit.test("Test sequence DICOM parsing.", function (assert) {
    var done = assert.async();

    var request = new XMLHttpRequest();
    var urlRoot = "https://raw.githubusercontent.com/ivmartel/dwv/master";
    var url = urlRoot + "/tests/data/dwv-test-sequence.dcm";
    request.open('GET', url, true);
    request.responseType = "arraybuffer";
    request.onload = function (/*event*/) {
        assert.ok((this.response.byteLength!==0), "Got a response.");

        // parse DICOM
        var dicomParser = new dwv.dicom.DicomParser();
        dicomParser.parse(this.response);
        // raw tags
        var rawTags = dicomParser.getRawDicomElements();
        assert.ok((Object.keys(rawTags).length!==0), "Got raw tags.");
        // wrapped tags
        var tags = dicomParser.getDicomElements();
        assert.ok((tags.dumpToTable().length!==0), "Got wrapped tags.");

        // ReferencedImageSequence: explicit sequence
        var seq00 = tags.getFromName("ReferencedImageSequence");
        assert.equal(seq00.length, 3, "ReferencedImageSequence length");
        assert.equal(seq00[0].x00081155.value[0],
                "1.3.12.2.1107.5.2.32.35162.2012021515511672669154094",
                "ReferencedImageSequence - item0 - ReferencedSOPInstanceUID");
        assert.equal(seq00[1].x00081155.value[0],
                "1.3.12.2.1107.5.2.32.35162.2012021515511286933854090",
                "ReferencedImageSequence - item1 - ReferencedSOPInstanceUID");

        // SourceImageSequence: implicit sequence
        var seq01 = tags.getFromName("SourceImageSequence");
        assert.equal(seq01.length, 3, "SourceImageSequence length");
        assert.equal(seq01[0].x00081155.value[0],
                "1.3.12.2.1107.5.2.32.35162.2012021515511672669154094",
                "SourceImageSequence - item0 - ReferencedSOPInstanceUID");
        assert.equal(seq01[1].x00081155.value[0],
                "1.3.12.2.1107.5.2.32.35162.2012021515511286933854090",
                "SourceImageSequence - item1 - ReferencedSOPInstanceUID");

        // ReferencedPatientSequence: explicit empty sequence
        var seq10 = tags.getFromName("ReferencedPatientSequence");
        assert.equal(seq10.length, 0, "ReferencedPatientSequence length");

        // ReferencedOverlaySequence: implicit empty sequence
        var seq11 = tags.getFromName("ReferencedOverlaySequence");
        assert.equal(seq11.length, 0, "ReferencedOverlaySequence length");

        // ReferringPhysicianIdentificationSequence: explicit empty item
        var seq12 = tags.getFromName("ReferringPhysicianIdentificationSequence");
        assert.equal(seq12.xFFFEE000.value.length, 0, 
                "ReferringPhysicianIdentificationSequence item length");
        
        // ConsultingPhysicianIdentificationSequence: implicit empty item
        var seq13 = tags.getFromName("ConsultingPhysicianIdentificationSequence");
        assert.equal(seq13.xFFFEE000.value.length, 0, 
            "ConsultingPhysicianIdentificationSequence item length");
        
        // ReferencedStudySequence: explicit sequence of sequence
        var seq20 = tags.getFromName("ReferencedStudySequence");
        // just one element
        //assert.equal(seq20.length, 2, "ReferencedStudySequence length");
        assert.equal(seq20.x0040A170.value[0].x00080100.value[0],
                "123456",
                "ReferencedStudySequence - seq - item0 - CodeValue");

        // ReferencedSeriesSequence: implicit sequence of sequence
        var seq21 = tags.getFromName("ReferencedSeriesSequence");
        // just one element
        //assert.equal(seq21.length, 2, "ReferencedSeriesSequence length");
        assert.equal(seq21.x0040A170.value[0].x00080100.value[0],
                "789101",
                "ReferencedSeriesSequence - seq - item0 - CodeValue");

        // ReferencedInstanceSequence: explicit empty sequence of sequence
        var seq30 = tags.getFromName("ReferencedInstanceSequence");
        assert.equal(seq30.x0040A170.value.length, 0,
                "ReferencedInstanceSequence - seq - length");

        // ReferencedVisitSequence: implicit empty sequence of sequence
        var seq31 = tags.getFromName("ReferencedVisitSequence");
        assert.equal(seq31.x0040A170.value.length, 0,
                "ReferencedVisitSequence - seq - length");

        // finish async test
        done();
    };
    request.send(null);
});

/**
 * Tests for {@link dwv.dicom.cleanString}.
 * @function module:tests/dicom~cleanString
 */
QUnit.test("Test cleanString.", function (assert) {
    // undefined
    assert.equal(dwv.dicom.cleanString(), null, "Clean undefined");
    // null
    assert.equal(dwv.dicom.cleanString(null), null, "Clean null");
    // empty
    assert.equal(dwv.dicom.cleanString(""), "", "Clean empty");
    // short
    assert.equal(dwv.dicom.cleanString("a"), "a", "Clean short");
    // special
    var special = String.fromCharCode("u200B");
    assert.equal(dwv.dicom.cleanString(special), "", "Clean just special");
    // regular
    var str = " El cielo azul ";
    var refStr = "El cielo azul";
    assert.equal(dwv.dicom.cleanString(str), refStr, "Clean regular");
    // regular with special
    str = " El cielo azul" + special;
    refStr = "El cielo azul";
    assert.equal(dwv.dicom.cleanString(str), refStr, "Clean regular with special");
    // regular with special and ending space (not trimmed)
    str = " El cielo azul " + special;
    refStr = "El cielo azul ";
    assert.equal(dwv.dicom.cleanString(str), refStr, "Clean regular with special 2");
});