import {idFromSynchronized, synchronizedFromId} from './registry';

import {SynchronizedCreatePacket} from './synchronized-create.packet';
import {SynchronizedDestroyPacket} from './synchronized-destroy.packet';

export class ServerSynchronizer {

  constructor() {
    this._added = [];
    this._removed = [];
    this._synchronized = {};
    this._synchronizedFlat = [];
  }

  addSynchronized(synchronized) {
    if (this.hasSynchronized(synchronized)) {
      return;
    }
    else {
      this._added.push(synchronized);
    }
    const type = idFromSynchronized(synchronized.constructor);
    if (!(type in this._synchronized)) {
      this._synchronized[type] = new Map();
    }
    this._synchronizedFlat.push(synchronized);
    const synchronizationId = synchronized.synchronizationId();
    this._synchronized[type].set(synchronizationId, synchronized);
  }

  destroy() {}

  hasSynchronized(synchronized) {
    return -1 !== this._synchronizedFlat.indexOf(synchronized);
  }

  removeSynchronized(synchronized) {
    if (!this.hasSynchronized(synchronized)) {
      return;
    }
    else {
      this._removed.push(synchronized);
    }
    const index = this._synchronizedFlat.indexOf(synchronized);
    this._synchronizedFlat.splice(index, 1);
    const type = idFromSynchronized(synchronized.constructor);
    const synchronizationId = synchronized.synchronizationId();
    this._synchronized[type].delete(synchronizationId);
  }

  packetsFor(informed) {
    const payload = [];
    for (let i = 0; i < this._synchronizedFlat.length; i++) {
      const synchronized = this._synchronizedFlat[i];
      const id = synchronized.synchronizationId();
      const type = idFromSynchronized(synchronized.constructor);
      if (-1 !== this._added.indexOf(synchronized)) {
        const packet = new SynchronizedCreatePacket({
          synchronized: {
            id,
            type,
          },
          spec: synchronized.toNetwork(informed),
        });
        payload.push(packet);
      }
      else if (-1 !== this._removed.indexOf(synchronized)) {
        const packet = new SynchronizedDestroyPacket({
          synchronized: {
            id,
            type,
          },
        });
        payload.push(packet);
      }
      else {
        const packets = synchronized.packetsFor(informed);
        for (let j = 0; j < packets.length; j++) {
          const packet = packets[j];
          packet.data.synchronized = {
            id,
            type,
          };
          payload.push(packet);
        }
      }
    }
    this._added = [];
    this._removed = [];
    return payload;
  }

}