import {
    createDatumGenerator,
    createCategoryGenerator,
    createDatumMapGenerator,
    createRandomAlphaLowerCharacterGenerator,
    createRandomAlphaUpperCharacterGenerator,
    createRandomIntegerGenerator,
    createRandomNumberCharacterGenerator,
    createRandomStringGenerator,
    generateMapData
} from "../../src/ts/mmviz-data/generator";

test("Test createDatumGenerator", () => {

    const minNumber = 1, maxNumber = 10,
        datumGeneratorBuilder = createDatumGenerator(createRandomIntegerGenerator(minNumber, maxNumber)),
        datumGenerator = datumGeneratorBuilder(createCategoryGenerator(1), createCategoryGenerator(1));

    const dataArray = [];
    for (let i = 0; i < 10; i++){
        dataArray.push(datumGenerator());
    }

    for (const datum of dataArray){

        expect(datum.value0).toBeGreaterThanOrEqual(minNumber);
        expect(datum.value0).toBeLessThanOrEqual(maxNumber);
        expect(datum.category0).toBeTruthy();
        expect(datum.category1).toBeTruthy();
    }

    // console.log(dataArray);
});

test("Test RandomIntegerGenerator", () => {

    const iterations = 100,
        minValue = 0,
        maxValue = 10,
        randomIntegerGenerator = createRandomIntegerGenerator(minValue, maxValue)
    ;

    let randomInteger;
    for (let i = 0; i < iterations; i++){
        randomInteger = randomIntegerGenerator();
        // console.log(randomInteger);
        expect(randomInteger).toBeGreaterThanOrEqual(minValue);
        expect(randomInteger).toBeLessThanOrEqual(maxValue);
    }
});

test("Test CategoryGenerator", () => {

    const iterations = 100,
        categoryGenerator = createCategoryGenerator()
    ;

    let category;
    for (let i = 0; i < iterations; i++){
        category = categoryGenerator(i);
        expect(category).toBe(`Category ${i} ${i}`);
    }
});

test("Test RandomAlphaLowerCharacterGenerator", () => {

    const iterations = 100,
        randomGenerator = createRandomAlphaLowerCharacterGenerator()
    ;

    let index, character;
    for (let i = 0; i < iterations; i++){
        character = randomGenerator();
        index = "abcdefghijklmnopqrstuvwxyz".indexOf(character);
        expect(index >= 0).toBeTruthy();
    }
});

test("Test RandomAlphaUpperCharacterGenerator", () => {

    const iterations = 100,
        randomGenerator = createRandomAlphaUpperCharacterGenerator()
    ;

    let index, character;
    for (let i = 0; i < iterations; i++){
        character = randomGenerator();
        index = "ABCDEFGHIJKLMNOPQRSTUVWXYZ".indexOf(character);
        expect(index >= 0).toBeTruthy();
    }
});

test("Test RandomNumberCharacterGenerator", () => {

    const iterations = 100,
        randomGenerator = createRandomNumberCharacterGenerator()
    ;

    let index, character;
    for (let i = 0; i < iterations; i++){
        character = randomGenerator();
        index = "0123456789".indexOf(character);
        expect(index >= 0).toBeTruthy();
    }
});

test("Test RandomStringGenerator", () => {

    const iterations = 100,
        generatorList = [
            createRandomNumberCharacterGenerator(),
            createRandomAlphaUpperCharacterGenerator(),
            createRandomAlphaLowerCharacterGenerator()
        ],
        minValue = 5, maxValue = 10,
        randomGenerator = createRandomStringGenerator(minValue, maxValue, generatorList)
    ;

    let randomStr, randomStrLength;
    for (let i = 0; i < iterations; i++){
        randomStr = randomGenerator();
        // console.log(randomStr);
        randomStrLength = randomStr.length;
        expect(randomStrLength).toBeGreaterThanOrEqual(minValue);
        expect(randomStrLength).toBeLessThanOrEqual(maxValue);
    }
});

test("Test DatumMapGenerator", () => {

    const iterations = 100,
        minValue = 0,
        maxValue = 10,
        randomIntegerGenerator = createRandomIntegerGenerator(minValue, maxValue),
        categoryGenerator = createRandomStringGenerator(5, 10),
        generatorMap = {
            category: categoryGenerator,
            numerical: randomIntegerGenerator
        }
    ;

    const datumGenerator = createDatumMapGenerator(generatorMap);

    let datum, hasProperty = false;
    for (let i = 0; i < iterations; i++){
        datum = datumGenerator();
        // console.log(datum);
        for (const generatorKey in generatorMap){
            hasProperty = datum.hasOwnProperty(generatorKey);
            expect(hasProperty).toBeTruthy();
        }
    }
});

test("Test generateMapData", () => {

    const dataLength = 100,
        minValue = 5, maxValue = 10,
        randomIntegerGenerator = createRandomIntegerGenerator(minValue, maxValue),
        categoryGenerator = createRandomStringGenerator(5, 10),
        generatorMap = {
            category: categoryGenerator,
            numerical: randomIntegerGenerator
        }
    ;

    const dataArray = generateMapData(dataLength, generatorMap);
    expect(dataArray.length).toBe(dataLength);

    let hasProperty = false;
    for (const datum of dataArray){

        for (const generatorKey in generatorMap){
            hasProperty = datum.hasOwnProperty(generatorKey);
            expect(hasProperty).toBeTruthy();
        }
    }

});