import {
  describe,
  test,
  expect,
  Result
} from './tests.uts'

export class TFloat32Array {
  test() {
    // #ifndef APP-IOS
    this.testfloat32();
    this.testConstructor();
    this.testSet();
    this.testCopyWith();
    this.testEvery();
    this.testFill();
    this.testFilter();
    this.find();
    this.findIndex();
    this.foreach();
    this.iterator();
    this.includes();
    this.indexOf();
    this.join();
    this.keys();
    this.map();
    this.reduce();
    this.reduceRight();
    this.reverse();
    this.slice();
    this.sort();
    this.subarray();
    this.values();
    this.arrayBufferSlice();
    // #endif
  }
  // #ifndef APP-IOS
  from() {
    var float32Array = Float32Array.from([1, 2, 3], (v : number, _ : number) : number => v + v);
    expect(float32Array.toString()).toEqual('2,4,6');
  }

  testfloat32() {
    let float32 = new Float32Array(2);
    float32[0] = 42;
    expect(float32[0]).toEqual(42);
    expect(float32.length).toEqual(2);
    expect(Float32Array.BYTES_PER_ELEMENT).toEqual(4);

    let x = new Float32Array([21, 31, 3]);
    expect(x[1]).toEqual(31);

    let y = new Float32Array(x);
    expect(y[0]).toEqual(21);

    let buffer = new ArrayBuffer(16);
    let z = new Float32Array(buffer, 2, 4);
    expect(z.byteOffset).toEqual(2);
    expect(z.length).toEqual(4);

    var k = Float32Array.of(1, 2, 3)
    expect(k.toString()).toEqual("1,2,3");
  }

  testConstructor() {

    let buffer = new ArrayBuffer(16);
    let float32 = new Float32Array(buffer);
    float32[1] = 42;
    expect(float32.toString()).toEqual("0,42,0,0");
  }

  testSet() {
    // #TEST Float32Array.set
    let float32 = new Float32Array(8);
    var array = [1, 2, 3]
    float32.set(array, 1);
    expect(float32.toString()).toEqual("0,1,2,3,0,0,0,0");
 
    let src = [1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4];
    let typed_dest = new Float32Array(16);
    typed_dest.set(src);
    expect(typed_dest.toString()).toEqual("1,2,3,4,1,2,3,4,1,2,3,4,1,2,3,4");
    
    let typed_src = new Float32Array(src);
    typed_dest = new Float32Array(16);
    typed_dest.set(typed_src);
    expect(typed_dest.toString()).toEqual("1,2,3,4,1,2,3,4,1,2,3,4,1,2,3,4");
    // #END
  }

  testCopyWith() {
    // #TEST Float32Array.copyWithin
    let float32 = new Float32Array(8);
    float32.set([1, 2, 3], 1);
    float32.copyWithin(3, 0, 3);
    expect(float32.toString()).toEqual("0,1,2,0,1,2,0,0");
    // #END
  }


  testEvery() {
    // #TEST Float32Array.every
    let result = new Float32Array([12, 5, 8, 130, 44]).every((value : number, _ : number, _a : Float32Array) : boolean => value < 40);
    expect(result).toEqual(false);
    // #END
  }

  testFill() {
    // #TEST Float32Array.fill
    let float32 = new Float32Array([1, 2, 3]).fill(4);
    expect(float32.toString()).toEqual("4,4,4");

    float32 = new Float32Array([1, 2, 3]).fill(4, 1);
    expect(float32.toString()).toEqual("1,4,4");

    float32 = new Float32Array([1, 2, 3]).fill(4, 1, 2);
    expect(float32.toString()).toEqual("1,4,3");

    float32 = new Float32Array([1, 2, 3]).fill(4, 1, 1);
    expect(float32.toString()).toEqual("1,2,3");

    float32 = new Float32Array([1, 2, 3]).fill(4, -3, -2);
    expect(float32.toString()).toEqual("4,2,3");
    // #END
  }

  testFilter() {
    // #TEST Float32Array.filter
    let float32 = new Float32Array([12, 5, 8, 44]).filter((value : number, _ : number, _a : Float32Array) : boolean => value >= 10);
    expect(float32.toString()).toEqual("12,44");
    // #END
  }

  find() {
    // #TEST Float32Array.find
    let float32 = new Float32Array([4, 5, 8, 12]);
    let res = float32.find((value : number, _ : number, _a : Float32Array) : boolean => value > 5);
    expect(res).toEqual(8);
    // #END
  }

  findIndex() {
    // #TEST Float32Array.findIndex
    let float32 = new Float32Array([4, 6, 8, 12]);
    let res = float32.findIndex((value : number, _ : number, _a : Float32Array) : boolean => value > 100);
    expect(res).toEqual(-1);

    let ufloat32 = new Float32Array([4, 6, 7, 120]);
    res = ufloat32.findIndex((value : number, _ : number, _a : Float32Array) : boolean => value > 100);
    expect(res).toEqual(3);
    // #END
  }

  foreach() {
    // #TEST Float32Array.forEach
    new Float32Array([0, 1, 2, 3]).forEach((value : number, index : number, _ : Float32Array) => {
      console.log(`a[${index}] = ${value}`);
    });
    // #END
  }

  iterator() {
    // #TEST Float32Array.entries
    let arr = new Float32Array([10, 20, 30, 40, 50]);
    let entries = arr.entries();
    expect(entries.next().value[1]).toEqual(10);
    expect(entries.next().value[1]).toEqual(20);
    // #END
  }

  includes() {
    // #TEST Float32Array.includes
    let float32 = new Float32Array([1, 2, 3]);
    let res = float32.includes(2.0);
    expect(res).toEqual(true);

    res = float32.includes(4.0);
    expect(res).toEqual(false);

    res = float32.includes(3.0, 3);
    expect(res).toEqual(false);
    // #END
  }

  indexOf() {
    // #TEST Float32Array.indexOf
    let float32 = new Float32Array([2, 5, 9]);
    let res = float32.indexOf(2);
    expect(res).toEqual(0);

    res = float32.indexOf(7);
    expect(res).toEqual(-1);

    res = float32.indexOf(9, 2);
    expect(res).toEqual(2);

    res = float32.indexOf(2, -1);
    expect(res).toEqual(-1);

    res = float32.indexOf(2, -3);
    expect(res).toEqual(0);
    // #END
  }

  join() {
    // #TEST Float32Array.join
    let float32 = new Float32Array([1, 2, 3]);
    let res = float32.join();
    expect(res).toEqual("1,2,3");

    res = float32.join(" / ");
    expect(res).toEqual("1 / 2 / 3");

    res = float32.join("");
    expect(res).toEqual("123");
    // #END
  }

  keys() {
    // #TEST Float32Array.keys
    let arr = new Float32Array([10, 20, 30, 40, 50]);
    let keys = arr.keys();
    expect(keys.next().value).toEqual(0);
    expect(keys.next().value).toEqual(1);
    expect(keys.next().value).toEqual(2);
    expect(keys.next().value).toEqual(3);
    expect(keys.next().value).toEqual(4);
    // #END
  }

  map() {
    // #TEST Float32Array.map
    let numbers = new Float32Array([1, 4, 9]);
    let doubles = numbers.map((value : number, _ : number, _a : Float32Array) : number => value * 2);
    expect(numbers.toString()).toEqual("1,4,9");
    expect(doubles.toString()).toEqual("2,8,18");
    // #END
  }

  reduce() {
    // #TEST Float32Array.reduce
    let total = new Float32Array([0, 1, 2, 3]);
    let res = total.reduce((accumulator : number, currentValue : number, _ : number, _a : Float32Array) : number => accumulator + currentValue);
    expect(res).toEqual(6);

    total = new Float32Array([0, 1, 2, 3]);
    res = total.reduce((accumulator : number, currentValue : number, _ : number, _a : Float32Array) : number => accumulator + currentValue, 8);
    expect(res).toEqual(14);
    // #END
  }


  reduceRight() {
    // #TEST Float32Array.reduceRight
    let total = new Float32Array([0, 1, 2, 3]);
    let res = total.reduceRight((accumulator : number, currentValue : number, _ : number, _a : Float32Array) : number => accumulator + currentValue);
    expect(res).toEqual(6);

    total = new Float32Array([0, 1, 2, 3]);
    res = total.reduceRight((accumulator : number, currentValue : number, _ : number, _a : Float32Array) : number => accumulator + currentValue, 8);
    expect(res).toEqual(14);
    // #END
  }

  reverse() {
    // #TEST Float32Array.reverse
    let float32 = new Float32Array([1, 2, 3]);
    float32.reverse();
    expect(float32.toString()).toEqual("3,2,1");
    // #END
  }

  slice() {
    // #TEST Float32Array.slice
    let float32 = new Float32Array([1, 2, 3]);
    let res = float32.slice(1);
    expect(res.toString()).toEqual("2,3");

    res = float32.slice(2);
    expect(res.toString()).toEqual("3");

    res = float32.slice(-2);
    expect(res.toString()).toEqual("2,3");

    res = float32.slice(0, 1);
    expect(res.toString()).toEqual("1");
    // #END
  }

  sort() {
    // #TEST Float32Array.sort
    let numbers = new Float32Array([40, 1, 5]);
    numbers.sort();
    expect(numbers.toString()).toEqual("1,5,40");

    numbers.sort((a, b) : number => a - b);
    expect(numbers.toString()).toEqual("1,5,40");
    // #END
  }

  subarray() {
    // #TEST Float32Array.subarray
    let buffer = new ArrayBuffer(16);
    let float32 = new Float32Array(buffer);
    float32.set([1, 2, 3]);
    expect(float32.toString()).toEqual("1,2,3,0");

    let sub = float32.subarray(0, 4);
    expect(sub.toString()).toEqual("1,2,3,0");
    // #END
  }

  values() {
    // #TEST Float32Array.values
    let arr = new Float32Array([1, 2, 3]);
    let values = arr.values();
    expect(values.next().value).toEqual(1);
    expect(values.next().value).toEqual(2);
    expect(values.next().value).toEqual(3);
    // #END
  }

  arrayBufferSlice() {
    // #TEST ArrayBuffer.slice
    let buffer = new ArrayBuffer(16);
    let float32 = new Float32Array(buffer);
    float32[3] = 42;
    expect(float32.toString()).toEqual("0,0,0,42");

    let res = buffer.slice(8);
    let sliced = new Float32Array(res);
    expect(sliced[1]).toEqual(42);
    // #END
  }

  testSome() {
    // #TEST Float32Array.some
    const float32 = new Float32Array([-10, 20, -30, 40, -50]);
    const positives = new Float32Array([10, 20, 30, 40, 50]);

    expect(float32.some((element : number, index : number, array : Float32Array) : boolean =>
      element < 0
    )).toEqual(true);


    expect(positives.some((element : number, index : number, array : Float32Array) : boolean =>
      element < 0
    )).toEqual(false);
    // #END
  }
  // #endif
}