import { expect } from '../../../test-utils';
import { sortObjectKeysInArray, sortObjectKeysToMatchTarget } from '../sort-keys-to-match-target';

describe('sortObjectKeysToMatchTarget ', function () {
  it('should sort object keys, including in nested objects', function () {
    const objectToSort = {
      c: {
        c: 'c',
        b: 'b',
        a: 'a',
      },
      b: 'b',
      a: 'a',
    };
    const targetObject = {
      a: 'a',
      b: 'b',
      c: {
        a: 'a',
        b: 'b',
        c: 'c',
      },
    };
    const sortedObject = sortObjectKeysToMatchTarget({ objectToSort, targetObject });
    expect(sortedObject).to.deep.equal(objectToSort);
    expect(Object.keys(sortedObject)).to.deep.equal(Object.keys(targetObject));
    expect(Object.keys(sortedObject.c)).to.deep.equal(Object.keys(targetObject.c));
  });

  it('should not delete any keys', function () {
    const objectToSort = {
      b: 'b',
      a: 'a',
      c: 'c',
    };
    const targetObject = {
      a: 'a',
      b: 'b',
    };
    const sortedObject = sortObjectKeysToMatchTarget({ objectToSort, targetObject });
    expect(sortedObject).to.deep.equal(objectToSort);
    expect(Object.keys(sortedObject)).to.deep.equal(['a', 'b', 'c']);
  });

  it('should not add any keys', function () {
    const objectToSort = {
      b: 'b',
      a: 'a',
    };
    const targetObject = {
      a: 'a',
      b: 'b',
      c: 'c',
    };
    const sortedObject = sortObjectKeysToMatchTarget({ objectToSort, targetObject });
    expect(objectToSort).to.deep.equal(sortedObject);
    expect(Object.keys(sortedObject)).to.deep.equal(['a', 'b']);
  });

  it('should sort object keys in nested arrays of objects', function () {
    const objectToSort = {
      a: [
        {
          c: 'c',
          b: 'b',
          a: 'a',
        },
      ],
    };
    const targetObject = {
      a: [
        {
          a: 'a',
          b: 'b',
          c: 'c',
        },
      ],
    };
    // Will match on deep equality of array elements
    const sortedObject = sortObjectKeysToMatchTarget({ objectToSort, targetObject });
    expect(Object.keys(sortedObject.a[0])).to.deep.equal(Object.keys(targetObject.a[0]));
  });
});

describe('sortObjectKeysInArray', function () {
  it('should match objects based on `path` parameter correctly', function () {
    const blocks = [
      {
        block: {
          key: 'block_1',
          type: 'markdown',
          markdown: '**MAR**_k_`d o w n`',
        },
      },
      {
        block: {
          key: 'checkbox_block',
          type: 'checkbox',
          title: 'Add custom payout amount',
          default_value: false,
        },
      },
    ];
    const targetBlocks: Record<string, any>[] = [
      {
        block: {
          type: 'checkbox',
          title: 'Add custom payout amount',
          default_value: false,
          key: 'checkbox_block',
        },
      },
      {
        block: {
          markdown: '**MAR**_k_`d o w n`',
          type: 'markdown',
          key: 'block_1',
        },
      },
    ];
    const sortedBlocks = sortObjectKeysInArray({ arrayToSort: blocks, targetArray: targetBlocks });
    expect(sortedBlocks).to.have.deep.members(blocks);

    const sortedCheckboxBlock = sortedBlocks.find((b) => b.block.key === 'checkbox_block');
    const targetCheckboxBlock = targetBlocks.find((b) => b.block.key === 'checkbox_block');
    expect(Object.keys(sortedCheckboxBlock?.block)).to.deep.equal(Object.keys(targetCheckboxBlock?.block));

    const sortedMarkdownBlock = sortedBlocks.find((b) => b.block.key === 'block_1');
    const targetMarkdownBlock = targetBlocks.find((b) => b.block.key === 'block_1');
    expect(Object.keys(sortedMarkdownBlock?.block)).to.deep.equal(Object.keys(targetMarkdownBlock?.block));
  });

  it('should match objects based on deep equality correctly', function () {
    const arrayToSort = [
      {
        b: 'b',
        a: 'a',
      },
      {
        d: 'd',
        c: 'c',
      },
    ];
    const targetArray = [
      {
        a: 'a',
        b: 'b',
      },
      {
        c: 'c',
        d: 'd',
      },
    ];
    const sortedArray = sortObjectKeysInArray({ arrayToSort, targetArray });
    expect(Object.keys(sortedArray[0])).to.deep.equal(Object.keys(targetArray[0]));
    expect(Object.keys(sortedArray[1])).to.deep.equal(Object.keys(targetArray[1]));
  });

  it('should not delete any array elements', function () {
    const arrayToSort = [
      {
        b: 'b',
        a: 'a',
      },
      {
        d: 'd',
        c: 'c',
      },
    ];
    const targetArray = [
      {
        a: 'a',
        b: 'b',
      },
    ];
    const sortedArray = sortObjectKeysInArray({ arrayToSort, targetArray });
    expect(Object.keys(sortedArray[0])).to.deep.equal(Object.keys(targetArray[0]));
    expect(sortedArray).to.have.deep.members(arrayToSort);
  });

  it('should not add any array elements', function () {
    const arrayToSort = [
      {
        b: 'b',
        a: 'a',
      },
    ];
    const targetArray = [
      {
        a: 'a',
        b: 'b',
      },
      {
        c: 'c',
        d: 'd',
      },
    ];
    const sortedArray = sortObjectKeysInArray({ arrayToSort, targetArray });
    expect(Object.keys(sortedArray[0])).to.deep.equal(Object.keys(targetArray[0]));
    expect(sortedArray).to.have.deep.members(arrayToSort);
  });

  it('should handle duplicates in arrayToSort correctly', function () {
    const arrayToSort = [
      {
        b: 'b',
        a: 'a',
      },
      {
        b: 'b',
        a: 'a',
      },
    ];
    const targetArray = [
      {
        a: 'a',
        b: 'b',
      },
    ];
    const sortedArray = sortObjectKeysInArray({ arrayToSort, targetArray });

    expect(sortedArray).to.have.deep.members(arrayToSort);
    expect(Object.keys(sortedArray[0])).to.deep.equal(Object.keys(targetArray[0]));
    // The second element should not be sorted
    expect(Object.keys(sortedArray[1])).to.deep.equal(Object.keys(arrayToSort[1]));
  });

  it('should handle duplicates in targetArray correctly', function () {
    const arrayToSort = [
      {
        b: 'b',
        a: 'a',
        key: 'test',
      },
    ];
    const targetArray = [
      {
        key: 'test',
        a: 'a',
        b: 'b',
      },
      {
        b: 'b',
        key: 'test',
        a: 'a',
      },
    ];
    const sortedArray = sortObjectKeysInArray({ arrayToSort, targetArray });
    expect(sortedArray).to.have.deep.members(arrayToSort);
    // Should  match on first duplicate, not the second
    expect(Object.keys(sortedArray[0])).to.deep.equal(Object.keys(targetArray[0]));
  });

  it('should handle duplicates in both arrays correctly', function () {
    const arrayToSort = [
      {
        a: 'a',
        key: 'test_a',
        b: 'b',
      },
      {
        key: 'test_b',
        x: 's',
      },
      {
        a: 'a',
        key: 'test_a',
        b: 'b',
      },
    ];
    const targetArray = [
      {
        key: 'test_a',
        a: 'a',
        b: 'b',
      },
      {
        b: 'b',
        a: 'a',
        key: 'test_a',
      },
      {
        key: 'test_b',
        x: 's',
      },
    ];

    const sortedArray = sortObjectKeysInArray({ arrayToSort, targetArray });
    expect(sortedArray).to.have.deep.members(arrayToSort);
    // arrayToSort[0] should match targetArray[0]
    expect(Object.keys(sortedArray[0])).to.deep.equal(Object.keys(targetArray[0]));
    // arrayToSort[2] should match targetArray[1]
    expect(Object.keys(sortedArray[2])).to.deep.equal(Object.keys(targetArray[1]));
  });
});