import {IRecordHeader} from './record-header';
import _ from 'lodash';
import {ISerializable} from '../cache/serializeable.interface';

export class SearchResult implements ISerializable {
  name: string;
  docType: string;
  columns: IRecordHeader[];
  data: string[][];
  private nameIndexCache: {name: string, index: number}[];

  constructor(data: any = {}, name: string = 'New Result') {
    this.initialize(name, data);
  }

  private initialize(name: string, data: any) {
    this.name = name;
    this.docType = name;
    this.columns = data.columns || [];
    this.data = data.data || [];
  }

  get labels(): any[] {
    return _.map(this.columns, 'label');
  }

  get names(): any[] {
    return _.map(this.columns, 'name');
  }

  get nameIndexes() {
    if (!this.nameIndexCache) {
      return _.reduce(
        this.names,
        (nameIndexes, name) => {
          const index = _.indexOf(this.names, name);
          const nameIndex: {name: string, index: number} = {name, index};
          nameIndexes.push(nameIndex);
          return nameIndexes;
        },
        []);
    } else {
      return this.nameIndexCache;
    }
  }

  getProperties(...names: string[]): any[] {
    const nameIndexes = _.filter(
      this.nameIndexes,
      nameIndex => _.some(names, name => name === nameIndex.name)
    );

    return _.map(this.data, (record) => {
      return _.reduce(
        nameIndexes,
        (condensedRecord, nameIndex) => {
          condensedRecord[nameIndex.name] = _.at(record, nameIndex.index)[0];
          return condensedRecord;
        },
        {});
    });
  }

  serialize(): string {
    return JSON.stringify(
      {
        name: this.name,
        data: {
          columns: this.columns,
          data: this.data
        }
      });
  }

  deserialize(from: string): SearchResult {
    try {
      const parsedJson = JSON.parse(from);
      this.initialize(parsedJson.name, parsedJson.data);
    } catch (e) {
      console.warn(`Search Result deserialization error: ${e}`);
      this.initialize(
        'Error',
        {
          data: {
            columns: [],
            data: []
          }
        }
      );
    }

    return this;
  }
}