export function coalesce(records: ProtoRecord[]): ProtoRecord[] {
  var res: List<ProtoRecord> = [];
  var indexMap: Map<number, number> = new Map<number, number>();

  for (var i = 0; i < records.length; ++i) {
    var r = records[i];
    var record = _replaceIndices(r, res.length + 1, indexMap);
    var matchingRecord = _findMatching(record, res);

    if (isPresent(matchingRecord) && record.lastInBinding) {
      res.push(_selfRecord(record, matchingRecord.selfIndex, res.length + 1));
      indexMap.set(r.selfIndex, matchingRecord.selfIndex);
      matchingRecord.referencedBySelf = true;

    } else if (isPresent(matchingRecord) && !record.lastInBinding) {
      if (record.argumentToPureFunction) {
        matchingRecord.argumentToPureFunction = true;
      }

      indexMap.set(r.selfIndex, matchingRecord.selfIndex);

    } else {
      res.push(record);
      indexMap.set(r.selfIndex, record.selfIndex);
    }
  }

  return res;
}

function ifChangedGuardTemplate(changeNames: List<any>, body: string): string {
  var cond = changeNames.join(" || ");
  return `
if (${cond}) {
  ${body}
}
`;
}

 getLocalNames(records: List<ProtoRecord>): List<string> {
   var index = 0;
   var names = records.map((r) => {
     var sanitizedName = r.name.replace(new RegExp("\\W", "g"), '');
     return `${sanitizedName}${index++}`
   });
   return ["context"].concat(names);
 }

 _getNonNullPipeNames(): List<string> {
   var pipes = [];
   this.records.forEach((r) => {
     if (r.isPipeRecord()) {
       pipes.push(this._pipeNames[r.selfIndex]);
     }
   });
   return pipes;
 }

 getNonNullPipeNames(): List<string> {
   var pipes = [];
   this.records.forEach((r) => {
     if (r.mode === RECORD_TYPE_PIPE || r.mode === RECORD_TYPE_BINDING_PIPE) {
       pipes.push(this.pipeNames[r.selfIndex]);
     }
   });
   return pipes;
 }

 _addRecord(type, name, funcOrValue, args, fixedArgs, context) {
   var selfIndex = this._records.length + 1;
   if (context instanceof DirectiveIndex) {
     this._records.push(new ProtoRecord(type, name, funcOrValue, args, fixedArgs, -1, context,
                                        selfIndex, this._bindingRecord, this._expressionAsString,
                                        false, false));
   } else {
     this._records.push(new ProtoRecord(type, name, funcOrValue, args, fixedArgs, context, null,
                                        selfIndex, this._bindingRecord, this._expressionAsString,
                                        false, false));
   }
   return selfIndex;
 }

 _printDescription(sampleDescription) {
   this._print(`BENCHMARK ${sampleDescription.id}`);
   this._print('Description:');
   var props = ConsoleReporter._sortedProps(sampleDescription.description);
   props.forEach((prop) => { this._print(`- ${prop}: ${sampleDescription.description[prop]}`); });
   this._print('Metrics:');
   this._metricNames.forEach((metricName) => {
     this._print(`- ${metricName}: ${sampleDescription.metrics[metricName]}`);
   });
   this._print('');
   this._printStringRow(this._metricNames);
   this._printStringRow(this._metricNames.map((_) => ''), '-');
 }

 go(url: string) {
   url = this.normalizeAbsolutely(url);
   if (this._path == url) {
     return;
   }
   this._path = url;
   this.urlChanges.push(url);
 }

  whenStable(callback: Function) {
    this._callbacks.push(callback);

    if (this._pendingCount === 0) {
      this._runCallbacks();
    }
    // TODO(juliemr) - hook into the zone api.
  }

  generate(): Function {
    var classDefinition = `
      var ${this.typeName} = function ${this.typeName}(dispatcher, pipeRegistry, protos, directiveRecords) {
        ${ABSTRACT_CHANGE_DETECTOR}.call(this);
        ${DISPATCHER_ACCESSOR} = dispatcher;
        ${PIPE_REGISTRY_ACCESSOR} = pipeRegistry;
        ${PROTOS_ACCESSOR} = protos;
        ${DIRECTIVES_ACCESSOR} = directiveRecords;
        ${LOCALS_ACCESSOR} = null;
        ${this._genFieldDefinitions()}
      }

      ${this.typeName}.prototype = Object.create(${ABSTRACT_CHANGE_DETECTOR}.prototype);

      ${this.typeName}.prototype.detectChangesInRecords = function(throwOnChange) {
        ${this._genLocalDefinitions()}
        ${this._genChangeDefinitions()}
        var ${IS_CHANGED_LOCAL} = false;
        var ${CURRENT_PROTO};
        var ${CHANGES_LOCAL} = null;

        context = ${CONTEXT_ACCESSOR};

        ${this.records.map((r) => this._genRecord(r)).join("\n")}
      }

      ${this.typeName}.prototype.callOnAllChangesDone = function() {
        ${this._genCallOnAllChangesDoneBody()}
      }

      ${this.typeName}.prototype.hydrate = function(context, locals, directives) {
        ${MODE_ACCESSOR} = "${ChangeDetectionUtil.changeDetectionMode(this.changeDetectionStrategy)}";
        ${CONTEXT_ACCESSOR} = context;
        ${LOCALS_ACCESSOR} = locals;
        ${this._genHydrateDirectives()}
        ${this._genHydrateDetectors()}
      }

      ${this.typeName}.prototype.dehydrate = function() {
        ${this._genPipeOnDestroy()}
        ${this._genFieldDefinitions()}
        ${LOCALS_ACCESSOR} = null;
      }

      ${this.typeName}.prototype.hydrated = function() {
        return ${CONTEXT_ACCESSOR} !== ${UTIL}.uninitialized();
      }

      return function(dispatcher, pipeRegistry) {
        return new ${this.typeName}(dispatcher, pipeRegistry, protos, directiveRecords);
      }
    `;

    return new Function('AbstractChangeDetector', 'ChangeDetectionUtil', 'protos',
                        'directiveRecords', classDefinition)(
        AbstractChangeDetector, ChangeDetectionUtil, this.records, this.directiveRecords);
  }