'use strict';

require('../common');
const assert = require('assert');

const b = Buffer.allocUnsafe(1024);
const c = Buffer.allocUnsafe(512);

let cntr = 0;

{
  // copy 512 bytes, from 0 to 512.
  b.fill(++cntr);
  c.fill(++cntr);
  const copied = b.copy(c, 0, 0, 512);
  assert.strictEqual(copied, 512);
  for (let i = 0; i < c.length; i++) {
    assert.strictEqual(c[i], b[i]);
  }
}

{
  // Current behavior is to coerce values to integers.
  b.fill(++cntr);
  c.fill(++cntr);
  const copied = b.copy(c, '0', '0', '512');
  assert.strictEqual(copied, 512);
  for (let i = 0; i < c.length; i++) {
    assert.strictEqual(c[i], b[i]);
  }
}

{
  // Floats will be converted to integers via `Math.floor`
  b.fill(++cntr);
  c.fill(++cntr);
  const copied = b.copy(c, 0, 0, 512.5);
  assert.strictEqual(copied, 512);
  for (let i = 0; i < c.length; i++) {
    assert.strictEqual(c[i], b[i]);
  }
}

{
  // Copy c into b, without specifying sourceEnd
  b.fill(++cntr);
  c.fill(++cntr);
  const copied = c.copy(b, 0, 0);
  assert.strictEqual(copied, c.length);
  for (let i = 0; i < c.length; i++) {
    assert.strictEqual(b[i], c[i]);
  }
}

{
  // Copy c into b, without specifying sourceStart
  b.fill(++cntr);
  c.fill(++cntr);
  const copied = c.copy(b, 0);
  assert.strictEqual(copied, c.length);
  for (let i = 0; i < c.length; i++) {
    assert.strictEqual(b[i], c[i]);
  }
}

{
  // Copied source range greater than source length
  b.fill(++cntr);
  c.fill(++cntr);
  const copied = c.copy(b, 0, 0, c.length + 1);
  assert.strictEqual(copied, c.length);
  for (let i = 0; i < c.length; i++) {
    assert.strictEqual(b[i], c[i]);
  }
}

{
  // Copy longer buffer b to shorter c without targetStart
  b.fill(++cntr);
  c.fill(++cntr);
  const copied = b.copy(c);
  assert.strictEqual(copied, c.length);
  for (let i = 0; i < c.length; i++) {
    assert.strictEqual(c[i], b[i]);
  }
}

{
  // Copy starting near end of b to c
  b.fill(++cntr);
  c.fill(++cntr);
  const copied = b.copy(c, 0, b.length - Math.floor(c.length / 2));
  assert.strictEqual(copied, Math.floor(c.length / 2));
  for (let i = 0; i < Math.floor(c.length / 2); i++) {
    assert.strictEqual(c[i], b[b.length - Math.floor(c.length / 2) + i]);
  }
  for (let i = Math.floor(c.length / 2) + 1; i < c.length; i++) {
    assert.strictEqual(c[c.length - 1], c[i]);
  }
}

{
  // Try to copy 513 bytes, and check we don't overrun c
  b.fill(++cntr);
  c.fill(++cntr);
  const copied = b.copy(c, 0, 0, 513);
  assert.strictEqual(copied, c.length);
  for (let i = 0; i < c.length; i++) {
    assert.strictEqual(c[i], b[i]);
  }
}

{
  // copy 768 bytes from b into b
  b.fill(++cntr);
  b.fill(++cntr, 256);
  const copied = b.copy(b, 0, 256, 1024);
  assert.strictEqual(copied, 768);
  for (let i = 0; i < b.length; i++) {
    assert.strictEqual(b[i], cntr);
  }
}

// Copy string longer than buffer length (failure will segfault)
const bb = Buffer.allocUnsafe(10);
bb.fill('hello crazy world');


// Try to copy from before the beginning of b. Should not throw.
b.copy(c, 0, 100, 10);

// Throw with invalid source type
assert.throws(
  () => Buffer.prototype.copy.call(0),
  {
    code: 'ERR_INVALID_ARG_TYPE',
    name: 'TypeError',
  }
);

// Copy throws at negative targetStart
assert.throws(
  () => Buffer.allocUnsafe(5).copy(Buffer.allocUnsafe(5), -1, 0),
  {
    code: 'ERR_OUT_OF_RANGE',
    name: 'RangeError',
    message: 'The value of "targetStart" is out of range. ' +
             'It must be >= 0. Received -1'
  }
);

// Copy throws at negative sourceStart
assert.throws(
  () => Buffer.allocUnsafe(5).copy(Buffer.allocUnsafe(5), 0, -1),
  {
    code: 'ERR_OUT_OF_RANGE',
    name: 'RangeError',
  }
);

// Copy throws if sourceStart is greater than length of source
assert.throws(
  () => Buffer.allocUnsafe(5).copy(Buffer.allocUnsafe(5), 0, 100),
  {
    code: 'ERR_OUT_OF_RANGE',
    name: 'RangeError',
  }
);

{
  // Check sourceEnd resets to targetEnd if former is greater than the latter
  b.fill(++cntr);
  c.fill(++cntr);
  b.copy(c, 0, 0, 1025);
  for (let i = 0; i < c.length; i++) {
    assert.strictEqual(c[i], b[i]);
  }
}

// Throw with negative sourceEnd
assert.throws(
  () => b.copy(c, 0, 0, -1),
  {
    code: 'ERR_OUT_OF_RANGE',
    name: 'RangeError',
    message: 'The value of "sourceEnd" is out of range. ' +
             'It must be >= 0. Received -1'
  }
);

// When sourceStart is greater than sourceEnd, zero copied
assert.strictEqual(b.copy(c, 0, 100, 10), 0);

// When targetStart > targetLength, zero copied
assert.strictEqual(b.copy(c, 512, 0, 10), 0);

// Test that the `target` can be a Uint8Array.
{
  const d = new Uint8Array(c);
  // copy 512 bytes, from 0 to 512.
  b.fill(++cntr);
  d.fill(++cntr);
  const copied = b.copy(d, 0, 0, 512);
  assert.strictEqual(copied, 512);
  for (let i = 0; i < d.length; i++) {
    assert.strictEqual(d[i], b[i]);
  }
}

// Test that the source can be a Uint8Array, too.
{
  const e = new Uint8Array(b);
  // copy 512 bytes, from 0 to 512.
  e.fill(++cntr);
  c.fill(++cntr);
  const copied = Buffer.prototype.copy.call(e, c, 0, 0, 512);
  assert.strictEqual(copied, 512);
  for (let i = 0; i < c.length; i++) {
    assert.strictEqual(c[i], e[i]);
  }
}

// https://github.com/nodejs/node/issues/23668: Do not crash for invalid input.
c.fill('c');
b.copy(c, 'not a valid offset');
// Make sure this acted like a regular copy with `0` offset.
assert.deepStrictEqual(c, b.slice(0, c.length));

// Copy into a Uint16Array target; bytes are packed into 16-bit elements.
{
  const x = new Uint16Array(4);
  const buf = Buffer.of(1, 2, 3, 4);
  const copied = buf.copy(x);
  assert.strictEqual(copied, 4);
  assert.ok(x instanceof Uint16Array);
  const bytes = new Uint8Array(x.buffer, x.byteOffset, 4);
  assert.deepStrictEqual(Array.from(bytes), [1, 2, 3, 4]);
  const remaining = new Uint8Array(
    x.buffer,
    x.byteOffset + 4,
    x.byteLength - 4
  );
  assert.ok(remaining.every((b) => b === 0));
}

{
  c.fill('C');
  assert.throws(() => {
    b.copy(c, { [Symbol.toPrimitive]() { throw new Error('foo'); } });
  }, /foo/);
  // No copying took place:
  assert.deepStrictEqual(c.toString(), 'C'.repeat(c.length));
}

// Copying to/from SharedArrayBuffer-backed buffers. The relaxed-atomic copy
// path is used only when both sides are backed by a SharedArrayBuffer; mixed
// copies (one shared, one not) go through the regular non-atomic overload.
{
  // SharedArrayBuffer -> SharedArrayBuffer.
  const src = Buffer.from(new SharedArrayBuffer(512)).fill(0x61);
  const dst = Buffer.from(new SharedArrayBuffer(512)).fill(0x62);
  const copied = src.copy(dst, 0, 0, 512);
  assert.strictEqual(copied, 512);
  assert.deepStrictEqual(Buffer.from(dst), Buffer.from(src));
}

{
  // SharedArrayBuffer source -> regular Buffer target (mixed).
  const src = Buffer.from(new SharedArrayBuffer(256)).fill(0x63);
  const dst = Buffer.allocUnsafe(256).fill(0x64);
  assert.strictEqual(src.copy(dst), 256);
  assert.deepStrictEqual(dst, Buffer.from(src));
}

{
  // Regular Buffer source -> SharedArrayBuffer target (mixed).
  const src = Buffer.allocUnsafe(256).fill(0x65);
  const dst = Buffer.from(new SharedArrayBuffer(256)).fill(0x66);
  assert.strictEqual(src.copy(dst), 256);
  assert.deepStrictEqual(Buffer.from(dst), src);
}

{
  // Views with a non-zero byteOffset over a SharedArrayBuffer. The native copy
  // is relative to the underlying ArrayBuffer, so the view's byteOffset must be
  // accounted for.
  const sab = new SharedArrayBuffer(16);
  const whole = Buffer.from(sab);
  for (let i = 0; i < 16; i++) whole[i] = i;
  const src = Buffer.from(sab, 4, 8);   // sab bytes 4..11
  const dst = Buffer.from(sab, 12, 4);  // sab bytes 12..15
  assert.strictEqual(src.copy(dst, 0, 0, 4), 4);
  assert.deepStrictEqual(
    [...whole],
    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 4, 5, 6, 7]);
}

{
  // Overlapping copy within a single SharedArrayBuffer uses memmove semantics.
  const buf = Buffer.from(new SharedArrayBuffer(8));
  for (let i = 0; i < 8; i++) buf[i] = i + 1; // [1,2,3,4,5,6,7,8]
  assert.strictEqual(buf.copy(buf, 2, 0, 6), 6);
  assert.deepStrictEqual([...buf], [1, 2, 1, 2, 3, 4, 5, 6]);
}