(async function main(){
// If MODULARIZE is used, `TheModule` is a promise.
if (TheModule instanceof Promise) {
  TheModule = await TheModule;
}

// Part 1

var sme = new TheModule.Parent(42);
sme.mulVal(2);
console.log('*')
console.log(sme.getVal());
sme.parentFunc(90);
console.log(typeof sme.getAsConst());
console.log(typeof sme.voidStar(sme));
console.log(sme.get_immutableAttr());
console.log(sme.immutableAttr);

try {
  sme.immutableAttr = 1;
} catch(e) {}
console.log(sme.immutableAttr); // Should be unchanged
console.log(sme.attr);
console.log(sme.get_attr());
sme.attr = 9;
console.log(sme.attr);
sme.set_attr(10);
console.log(sme.attr);
console.log(sme.get_attr());

console.log(typeof sme.getBoolean());
console.log(sme.getBoolean());

console.log('c1');

var c1 = new TheModule.Child1();
console.log(c1.getVal());
c1.mulVal(2);
console.log(c1.getVal());
console.log(c1.getValSqr());
console.log(c1.getValSqr(3));
console.log(c1.getValTimes()); // default argument should be 1
console.log(c1.getValTimes(2));
console.log(sme.getBoolean());
c1.parentFunc(90);

console.log('c1 v2');

c1 = new TheModule.Child1(8); // now with a parameter, we should handle the overloading automatically and properly and use constructor #2
console.log(c1.getVal());
c1.mulVal(2);
console.log(c1.getVal());
console.log(c1.getValSqr());
console.log(c1.getValSqr(3));
console.log(sme.getBoolean());

console.log('c2')

var c2 = new TheModule.Child2();
console.log(c2.getVal());
c2.mulVal(2);
console.log(c2.getVal());
console.log(c2.getValCube());
var succeeded;
try {
  succeeded = 0;
  console.log(c2.doSomethingSecret()); // should fail since private
  succeeded = 1;
} catch(e) {}
console.log(succeeded);
try {
  succeeded = 0;
  console.log(c2.getValSqr()); // function from the other class
  succeeded = 1;
} catch(e) {}
console.log(succeeded);
try {
  succeeded = 0;
  c2.getValCube(); // sanity
  succeeded = 1;
} catch(e) {}
console.log(succeeded);

TheModule.Child2.prototype.printStatic(); // static calls go through the prototype

// virtual function
c2.virtualFunc();
TheModule.Child2.prototype.runVirtualFunc(c2);
c2.virtualFunc2();

// extend a class from JS
var c3 = new TheModule.Child2JS;

c3.virtualFunc = function() {
  console.log('*js virtualf replacement*');
};
c3.virtualFunc2 = function() {
  console.log('*js virtualf2 replacement*');
};
c3.virtualFunc3 = function(x) {
  console.log('*js virtualf3 replacement ' + x + '*');
};

c3.virtualFunc();
TheModule.Child2.prototype.runVirtualFunc(c3);
c3.virtualFunc2();
c3.virtualFunc3(123); // this one is not replaced!
try {
  c3.virtualFunc4(123);
} catch(e) {
  console.log('caught: ' + e);
}

// Test virtual method dispatch from c++
TheModule.Child2.prototype.runVirtualFunc3(c3, 43);

c2.virtualFunc(); // original should remain the same
TheModule.Child2.prototype.runVirtualFunc(c2);
c2.virtualFunc2();
console.log('*ok*');

// Part 2

var suser = new TheModule.StringUser("hello", 43);
suser.Print(41, "world");
suser.PrintFloat(12.3456);
console.log(suser.returnAString());

var bv = new TheModule.RefUser(10);
var bv2 = new TheModule.RefUser(11);
console.log(bv2.getValue(bv));

console.log(typeof bv2.getMe());
console.log(bv2.getMe().getValue(bv));
console.log(bv2.getMe().getValue(bv2));

console.log(typeof bv2.getCopy());
console.log(bv2.getCopy().getValue(bv));
console.log(bv2.getCopy().getValue(bv2));

bv2.getAnother().PrintFloat(21.12);

console.log(new TheModule.Inner().get());
console.log('getAsArray: ' + new TheModule.Inner().getAsArray(12));
new TheModule.Inner().mul(2);
new TheModule.Inner().incInPlace(new TheModule.Inner());

console.log(TheModule.enum_value1);
console.log(TheModule.enum_value2);

// Enums from classes are accessed via the class.
enumClassInstance = new TheModule.EnumClass();
console.log([enumClassInstance.GetEnum(), TheModule.EnumClass.e_val].join(','));

// Enums from namespaces are accessed via the top-level module, as with classes defined
// in namespaces, see `Inner` above.
console.log(TheModule.e_namespace_val);

typeTester = new TheModule.TypeTestClass();

console.log('return char ' + (typeTester.ReturnCharMethod() & 255));
typeTester.AcceptCharMethod((2<<6)-1);
typeTester.AcceptCharMethod(-1);

console.log('return unsigned char ' + (typeTester.ReturnUnsignedCharMethod() & 255));
typeTester.AcceptUnsignedCharMethod((2<<7)-1);

console.log('return unsigned short ' + (typeTester.ReturnUnsignedShortMethod() & 65535));
typeTester.AcceptUnsignedShortMethod((2<<15)-1);

console.log('return unsigned long ' + (typeTester.ReturnUnsignedLongMethod() | 0));
typeTester.AcceptUnsignedLongMethod((2<<31)-1);
var voidPointerUser = new TheModule.VoidPointerUser();

voidPointerUser.SetVoidPointer(3);
console.log('void * ' + voidPointerUser.GetVoidPointer());

// Array tests

var arrayClass = new TheModule.ArrayClass();
console.log('int_array[0] == ' + arrayClass.get_int_array(0));
console.log('int_array[7] == ' + arrayClass.get_int_array(7));
arrayClass.set_int_array(0, 42);
arrayClass.set_int_array(7, 43);
console.log('int_array[0] == ' + arrayClass.get_int_array(0));
console.log('int_array[7] == ' + arrayClass.get_int_array(7));

try {
  arrayClass.set_int_array(-1, struct);
} catch (e) {
  console.log('idx -1: ' + e);
}

try {
  arrayClass.set_int_array(8, struct);
} catch (e) {
  console.log('idx 8: ' + e);
}

console.log('struct_array[0].attr1 == ' + arrayClass.get_struct_array(0).get_attr1());
console.log('struct_array[0].attr2 == ' + arrayClass.get_struct_array(0).get_attr2());
console.log('struct_array[7].attr1 == ' + arrayClass.get_struct_array(7).get_attr1());
console.log('struct_array[7].attr2 == ' + arrayClass.get_struct_array(7).get_attr2());

// Verify that bounds checking is *not* enabled when not asked for.
// This actually causes an illegal memory access, but as it's only a read, and the return
// value is not used, it shouldn't cause any problems in practice.
arrayClass.get_struct_array(8);

var struct = new TheModule.StructInArray(13, 17);
arrayClass.set_struct_array(0, struct);
struct = new TheModule.StructInArray(14, 18);
arrayClass.set_struct_array(7, struct);

console.log('struct_array[0].attr1 == ' + arrayClass.get_struct_array(0).get_attr1());
console.log('struct_array[0].attr2 == ' + arrayClass.get_struct_array(0).get_attr2());
console.log('struct_array[7].attr1 == ' + arrayClass.get_struct_array(7).get_attr1());
console.log('struct_array[7].attr2 == ' + arrayClass.get_struct_array(7).get_attr2());

struct = new TheModule.StructInArray(100, 101);
arrayClass.set_struct_ptr_array(0, struct);
console.log('struct_ptr_array[0]->attr1 == ' + arrayClass.get_struct_ptr_array(0).get_attr1());
console.log('struct_ptr_array[0]->attr2 == ' + arrayClass.get_struct_ptr_array(0).get_attr2());

// receiving arrays

var receiver = new TheModule.ReceiveArrays();
receiver.giveMeArrays([0.5, 0.25, 0.01, -20.42], [1, 4, 9, 10], 4);

// Test IDL_CHECKS=ALL

try {
  p = new TheModule.Parent(NaN); // Expects an integer
} catch (e) {}

try {
  p = new TheModule.Parent(42);
  p.voidStar(1234) // Expects a wrapped pointer
} catch (e) {}

try {
  s = new TheModule.StringUser('abc', 1);
  s.Print(123, null); // Expects a string or a wrapped pointer
} catch (e) {}

// Check for overflowing the stack

var before = Date.now();

for (var i = 0; i < 1000000; i++) {
  var temp = new TheModule.StringUser('abc', 1);
  TheModule.destroy(temp);
  if (Date.now() - before >= 1000) break;
}

if (isMemoryGrowthAllowed) {
  // Check for HEAP reallocation when using large arrays
  var numArrayEntries = 100000;
  var intArray = new Array(numArrayEntries);
  for (var i = 0; i < numArrayEntries; i++) {
    intArray[i] = i;
  }

  var startHeapLength = TheModule['HEAP8'].length;
  var offset;
  var storeArray = new TheModule.StoreArray();
  storeArray.setArray(intArray);
  // Add more data until the heap is reallocated
  while (TheModule['HEAP8'].length === startHeapLength) {
    intArray = intArray.concat(intArray);
    storeArray.setArray(intArray);
  }
  
  // Make sure the array was copied to the newly allocated HEAP
  var numCopiedEntries = 0;
  for (var i = 0; i < intArray.length; i++) {
    if (storeArray.getArrayValue(i) !== intArray[i]) {
      break;
    }
    numCopiedEntries += 1;
  }

  if (intArray.length !== numCopiedEntries) {
    console.log('ERROR: An array was not copied to HEAP32 after memory reallocation');
  }
}

//

console.log('\ndone.')
})();