'use strict';

import { lattice_update, lattice_valid, lattice_apply } from './lattice.js';


test("growth update rule", () => {
  const lattice = [[ 
    { type: 'empty', flags: {} }, 
    { type: 'empty', flags: {} }, 
    { type: 'plant', flags: {} },
  ]];
  const update_rules = {
    plant: () => {},
    empty: (lattice, x, y) => {
      if (lattice[y][x+1].type === 'plant') {
        return { world_updates: [{ x, y, from: 'empty', to: 'plant' }] };
      }
    },
  };

  expect(lattice_update(lattice, update_rules)).toEqual([
    { world_updates: [{ x: 1, y: 0, from: 'empty', to: 'plant' }] },
  ]);

  lattice[0][1] = { type: 'plant' };

  expect(lattice_update(lattice, update_rules)).toEqual([
    { world_updates: [{ x: 0, y: 0, from: 'empty', to: 'plant' }] },
  ]);

  lattice[0][0] = { type: 'plant' };

  expect(lattice_update(lattice, update_rules)).toEqual([]);
});


test("growth update rule applied", () => {
  const lattice = [[ 
    { type: 'empty', flags: {} }, 
    { type: 'empty', flags: {} }, 
    { type: 'plant', flags: {} },
  ]];
  expect(lattice_apply(lattice, [{ world_updates:[{ x: 1, y: 0, from: 'empty', to: 'plant' }]}])).toEqual([[
    { type: 'empty', flags: {} }, 
    { type: 'plant', flags: {} }, 
    { type: 'plant', flags: {} },
  ]]);

  expect(lattice_apply(lattice, [
    { world_updates: [{ x: 2, y: 0, from: 'plant', to: 'empty' } ]},
    { world_updates: [{ x: 1, y: 0, from: 'empty', to: 'plant' } ]},
    { world_updates: [{ x: 0, y: 0, from: 'empty', to: 'plant' } ]},
  ])).toEqual([[
    { type: 'plant', flags: {} }, 
    { type: 'plant', flags: {} }, 
    { type: 'empty', flags: {} },
  ]]);
});


test("check proposals agains lattice for validity", () => {
  const lattice = [[ { type: 'empty' }, { type: 'empty' }, { type: 'plant' } ]];
  expect(lattice_valid(lattice, { world_updates: [{ x: -1, y: 0, from: 'blah', to: 'blah' }] })).toBe(false);
  expect(lattice_valid(lattice, { world_updates: [{ x: 0, y: 0, from: 'blah', to: 'blah' }] })).toBe(false);
  expect(lattice_valid(lattice, { world_updates: [{ x: 0, y: 0, from: 'empty', to: 'blah' }] })).toBe(true);
  expect(lattice_valid(lattice, { world_updates: [{ x: 2, y: 0, from: 'empty', to: 'blah' }] })).toBe(false);
  expect(lattice_valid(lattice, { world_updates: [{ x: 2, y: 1, from: 'empty', to: 'blah' }] })).toBe(false);
});


test("proposals update cell flags appropriately", () => {
  const lattice = [
    [ 
      { type: 'empty', flags: { step: 1} }, 
      { type: 'empty', flags: {} }, 
      { type: 'plant', flags: { foo: 'bar' } },
    ]
  ];

  // flags are reset each time step
  expect(lattice_apply(lattice, [{ world_updates:[{ x: 1, y: 0, from: 'empty', to: 'plant' }]}])).toEqual([[
    { type: 'empty', flags: {} }, 
    { type: 'plant', flags: {} }, 
    { type: 'plant', flags: {} },
  ]]);

  // flags are combined when updating
  expect(lattice_apply(lattice, [
    { world_updates: [{ x: 1, y: 0, flags: { foo: 'bar' } } ]},
    { world_updates: [{ x: 1, y: 0, from: 'empty', to: 'plant', flags: { baz: 'baz' } } ]},
    { world_updates: [{ x: 0, y: 0, from: 'empty', to: 'plant', flags: { foo: 'foo' } } ]},
    { world_updates: [{ x: 0, y: 0, flags: { beep: 'boop' } } ]},
  ])).toEqual([[
    { type: 'plant', flags: { foo: 'foo', beep: 'boop' } }, 
    { type: 'plant', flags: { foo: 'bar', baz: 'baz' } }, 
    { type: 'plant', flags: {} },
  ]]);

});