QUnit.module('BindingTestSync', (hooks) =>
{
    hooks.before(async () =>
    {
        await CefSharp.BindObjectAsync("bound");
    });

    QUnit.test("BindObjectAsync Second call with Bound param", async (assert) =>
    {
        const res = await CefSharp.BindObjectAsync("bound");

        assert.equal(res.Success, false, "Second call to BindObjectAsync with already bound objects as params returned false.");
    });

    QUnit.test("bound.repeat('hi ', 5)", function (assert)
    {
        const expectedResult = "hi hi hi hi hi "
        let actualResult = bound.repeat("hi ", 5);
        assert.equal(actualResult, expectedResult, "We expect value to be " + actualResult);
    });

    QUnit.test("bound.myProperty", function (assert)
    {
        const expectedResult = 42;
        let actualResult = bound.myProperty;

        assert.equal(actualResult, expectedResult, "We expect value to be " + expectedResult);
    });

    QUnit.test("bound.subObject.simpleProperty", function (assert)
    {
        const expectedResult = "This is a very simple property.";
        let actualResult = bound.subObject.simpleProperty;

        assert.equal(actualResult, expectedResult, "We expect value to be " + expectedResult);

        bound.subObject.simpleProperty = expectedResult + "1";

        actualResult = bound.subObject.simpleProperty;

        assert.equal(actualResult, (expectedResult + "1"), "We expect value to be " + (expectedResult + 1));

        //Reset to default value
        bound.subObject.simpleProperty = expectedResult;
    });

    QUnit.test("Function delegate to c# method", function (assert)
    {
        function myFunction(functionParam)
        {
            return functionParam();
        }

        const expectedResult = "42"
        let actualResult = myFunction(bound.echoMyProperty);
        assert.equal(actualResult, expectedResult, "We expect value to be " + actualResult);
    });

    QUnit.test("Function returning complex type", function (assert)
    {
        function myFunction(functionParam)
        {
            return functionParam();
        }

        const expectedResult = "This is a very simple property."
        let actualResult = bound.getSubObject().simpleProperty;
        assert.equal(actualResult, expectedResult, "Call to bound.getSubObject().simpleProperty resulted in : " + actualResult);
    });

    QUnit.test("Call (echoDateTime): now", (assert) =>
    {
        const now = new Date();
        const res = bound.echoDateTime(now);

        assert.deepEqual(res, now, "Expected echo datetime");
    });

    QUnit.test("Call (echoDateTime): unixTimeZero", (assert) =>
    {
        const unixTimeZero = new Date(Date.parse('01 Jan 1970 00:00:00 GMT'));
        const res = bound.echoDateTime(unixTimeZero);

        assert.deepEqual(res, unixTimeZero, "Expected echo unixTimeZero");
    });

    QUnit.test("Call (echoNullableDateTime):", (assert) =>
    {
        const now = new Date();
        const res = bound.echoNullableDateTime(now);

        assert.deepEqual(res, now, "Expected echo datetime");
    });

    QUnit.test("Call (echoNullableDateTime) null param:", (assert) =>
    {
        const res = bound.echoNullableDateTime(null);

        assert.equal(res, null, "Expected null");
    });

    QUnit.test("Stress Test", function (assert)
    {
        let stressTestCallCount = 1000;
        for (var i = 1; i <= stressTestCallCount; i++)
        {
            assert.ok(true, bound.repeat("hi ", 5));
        }

        assert.ok(true, "Stress Test done with : " + stressTestCallCount + " call to bound.repeat(\"hi \", 5)");
    });

    QUnit.test("JSON Serializer Test", function (assert)
    {
        var json = bound.returnJsonEmployeeList();
        var jsonObj = JSON.parse(json);

        assert.ok(jsonObj.employees.length > 0, "Employee Count : " + jsonObj.employees.length);

        var employees = jsonObj.employees;

        assert.equal("John Doe", employees[0].firstName + " " + employees[0].lastName, "Employee : " + employees[0].firstName + " " + employees[0].lastName);
        assert.equal("Anna Smith", employees[1].firstName + " " + employees[1].lastName, "Employee : " + employees[1].firstName + " " + employees[1].lastName);
        assert.equal("Peter Jones", employees[2].firstName + " " + employees[2].lastName, "Employee : " + employees[2].firstName + " " + employees[2].lastName);
    });

    QUnit.test("Javascript function sending variable number of parameters to Bound Object. (ParamArray Test)", function (assert)
    {
        assert.equal(bound.methodWithParams('With 1 Params', 'hello-world'), "Name:With 1 Params;Args:hello-world", "Method with paramArray with one param");
        assert.equal(bound.methodWithParams('With 2 Params', 'hello-world', 'chris was here'), "Name:With 2 Params;Args:hello-world, chris was here", "Method with paramArray with two params");
        assert.equal(bound.methodWithParams('With no Params'), "Name:With no Params;Args:", "Method with paramArary no params passed");
        assert.equal(bound.methodWithoutParams('Normal Method', 'hello'), "Normal Method, hello", "Method with one param (not param array)");
        assert.equal(bound.methodWithoutAnything(), "Method without anything called and returned successfully.", "Method without params");

        assert.equal(bound.methodWithThreeParamsOneOptionalOneArray(null), "MethodWithThreeParamsOneOptionalOneArray:No Name Specified - No Optional Param Specified;Args:", "bound.methodWithThreeParamsOneOptionalOneArray(null)");
        assert.equal(bound.methodWithThreeParamsOneOptionalOneArray(null, null), "MethodWithThreeParamsOneOptionalOneArray:No Name Specified - No Optional Param Specified;Args:", "bound.methodWithThreeParamsOneOptionalOneArray(null, null)");
        assert.equal(bound.methodWithThreeParamsOneOptionalOneArray("Test", null), "MethodWithThreeParamsOneOptionalOneArray:Test - No Optional Param Specified;Args:", "bound.methodWithThreeParamsOneOptionalOneArray('Test', null)");
        assert.equal(bound.methodWithThreeParamsOneOptionalOneArray(null, null, "Arg1", "Arg2"), "MethodWithThreeParamsOneOptionalOneArray:No Name Specified - No Optional Param Specified;Args:Arg1, Arg2", "bound.methodWithThreeParamsOneOptionalOneArray(null, null, 'Arg1', 'Arg2')");
    });

    QUnit.test("Methods and Properties on bound object 'bound':", function (assert)
    {
        for (var name in bound)
        {
            if (bound[name].constructor.name != 'Function') continue;

            assert.ok(true, "Property: " + name);
        }

        for (var name in bound)
        {
            if (bound[name].constructor.name === 'Function') continue;


            assert.ok(true, "Function: " + name);
        }

        for (var name in bound)
        {
            if (typeof bound[name] == "object" && bound[name] !== null)
            {
                for (var sub in bound[name])
                {
                    var type = bound[name][sub].constructor.name === 'Function' ? "Function" : "Property";
                    assert.ok(true, name + "." + sub + "(" + type + ")");
                }
            }
        }
    });

    QUnit.test("Javascript Callback Test using object as parameter", function (assert)
    {
        var asyncCallback = assert.async();

        function objectCallback(s)
        {
            assert.ok(true, s);

            asyncCallback();
        }

        bound.testCallbackFromObject(
            {
                Callback: objectCallback, TestString: "Hello", SubClasses:
                    [
                        { PropertyOne: "Test Property One", Numbers: [1, 2, 3] },
                        { PropertyOne: "Test Property Two", Numbers: [4, 5, 6] }
                    ]
            });
    });

    QUnit.test("Javascript Callback Test with DateTime", function (assert)
    {
        var asyncCallback = assert.async();

        function callback(dateTimeFirst, dateTimeSecondAsArray)
        {
            var arr = dateTimeSecondAsArray;
            var dateTimeSecond = new Date(arr[0], arr[1] - 1, arr[2], arr[3], arr[4], arr[5]);
            assert.equal(dateTimeFirst - dateTimeSecond, 0);

            asyncCallback();
        }

        bound.testCallbackWithDateTime(callback);
    });

    QUnit.test("Javascript Callback Test with 1900 DateTime", function (assert)
    {
        var asyncCallback = assert.async();

        function callback(dateTimeFirst, dateTimeSecondAsArray)
        {
            var arr = dateTimeSecondAsArray;
            var dateTimeSecond = new Date(arr[0], arr[1] - 1, arr[2], arr[3], arr[4], arr[5]);
            assert.equal(dateTimeFirst - dateTimeSecond, 0);

            asyncCallback();
        }

        bound.testCallbackWithDateTime1900(callback);
    });

    QUnit.test("Javascript Callback Test with 1970 DateTime", function (assert)
    {
        var asyncCallback = assert.async();

        function callback(dateTimeFirst, dateTimeSecondAsArray)
        {
            var arr = dateTimeSecondAsArray;
            var dateTimeSecond = new Date(arr[0], arr[1] - 1, arr[2], arr[3], arr[4], arr[5]);
            assert.equal(dateTimeFirst - dateTimeSecond, 0);

            asyncCallback();
        }

        bound.testCallbackWithDateTime1970(callback);
    });

    QUnit.test("Javascript Callback Test with 1985 DateTime", function (assert)
    {
        var asyncCallback = assert.async();

        function callback(dateTimeFirst, dateTimeSecondAsArray)
        {
            var arr = dateTimeSecondAsArray;
            var dateTimeSecond = new Date(arr[0], arr[1] - 1, arr[2], arr[3], arr[4], arr[5]);
            assert.equal(dateTimeFirst - dateTimeSecond, 0);

            asyncCallback();
        }

        bound.testCallbackWithDateTime1985(callback);
    });

    QUnit.test("Javascript Callback Test", function (assert)
    {
        var asyncCallback = assert.async();

        function callback(s)
        {
            assert.equal(s.Response, "This callback from C# was delayed 1500ms", s.Response);

            asyncCallback();
        }

        bound.testCallback(callback);
    });
});