const hakuVastaus = function(vastaus) {
     $scope.perusteet = vastaus;
     $scope.nykyinenSivu = $scope.perusteet.sivu + 1;
     $scope.hakuparametrit.sivukoko = $scope.perusteet.sivukoko;
     $scope.sivuja = $scope.perusteet.sivuja;
     $scope.kokonaismaara = $scope.perusteet.kokonaismäärä;
     $scope.sivut = _.range(0, $scope.perusteet.sivuja);
     pat = new RegExp("(" + $scope.hakuparametrit.nimi + ")", "i");
 };

 public toString() : string {
     let res = '' // 'Goal ' + this.goalId + '\n\n'
     this.goalHyp.forEach(h => {
         res += h + '\n'
     })
     _.range(80).forEach(() => { res += '-' })
     res += '\n' + this.goalCcl
     return res
 }

function withIndex(callCluster: sinon.SinonStub, opts: any = {}) {
  const defaultIndex = {
    '.kibana_1': {
      aliases: { '.kibana': {} },
      mappings: {
        doc: {
          dynamic: 'strict',
          properties: {
            migrationVersion: { dynamic: 'true', type: 'object' },
          },
        },
      },
    },
  };
  const defaultAlias = {
    '.kibana_1': {},
  };
  const { numOutOfDate = 0 } = opts;
  const { alias = defaultAlias } = opts;
  const { index = defaultIndex } = opts;
  const { docs = [] } = opts;
  const searchResult = (i: number) =>
    Promise.resolve({
      _scroll_id: i,
      _shards: {
        successful: 1,
        total: 1,
      },
      hits: {
        hits: docs[i] || [],
      },
    });
  callCluster.withArgs('indices.get').returns(Promise.resolve(index));
  callCluster.withArgs('indices.getAlias').returns(Promise.resolve(alias));
  callCluster
    .withArgs('reindex')
    .returns(Promise.resolve({ task: 'zeid', _shards: { successful: 1, total: 1 } }));
  callCluster.withArgs('tasks.get').returns(Promise.resolve({ completed: true }));
  callCluster.withArgs('search').returns(searchResult(0));

  _.range(1, docs.length).forEach(i => {
    callCluster
      .withArgs('scroll')
      .onCall(i - 1)
      .returns(searchResult(i));
  });

  callCluster
    .withArgs('scroll')
    .onCall(docs.length - 1)
    .returns(searchResult(docs.length));

  callCluster.withArgs('bulk').returns(Promise.resolve({ items: [] }));
  callCluster
    .withArgs('count')
    .returns(Promise.resolve({ count: numOutOfDate, _shards: { successful: 1, total: 1 } }));
}

  test('it should assign colors deterministically', () => {
    const lessons: Lesson[] = [];
    range(NUM_DIFFERENT_COLORS).forEach((i) => {
      // Add 2 lessons for this ith venue
      const newLesson = { ...bareLesson, venue: `LT${i}` };
      lessons.push(newLesson);
      lessons.push(newLesson);
    });

    const coloredLessons = colorLessonsByKey(lessons, 'venue');

    range(NUM_DIFFERENT_COLORS * 2).forEach((i) => {
      const coloredLesson = coloredLessons[i];
      const index = Math.floor(i / 2);
      expect(coloredLesson).toMatchObject(bareLesson); // Ensure that existing lesson info wasn't modified
      expect(coloredLesson).toHaveProperty('venue', `LT${index}`);
      expect(coloredLesson).toHaveProperty('colorIndex', index % NUM_DIFFERENT_COLORS);
    });
  });

async function getTrainingSet() {
    const peopleArray = await of(...range(5, 10), 2)
        .pipe(map(x => `https://swapi.co/api/people/?format=json&page=${x}`))
        .pipe(flatMap(x => Axios.get(x).catch(console.error)))
        .pipe(map((x: AxiosResponse) => x.data))
        .pipe(reduce((acc: any[], x: any) => [x, ...acc], []))
        .toPromise();

    console.log(JSON.stringify(peopleArray, null, 2));
}

  it('should merge snippets if necessary', () => {
    const lines = keyBy(
      range(4, 23)
        .concat(range(38, 43))
        .map(line => mockSourceLine({ line })),
      'line'
    );
    const snippets = [
      [lines[4], lines[5], lines[6], lines[7], lines[8]],
      [lines[38], lines[39], lines[40], lines[41], lines[42]],
      [lines[17], lines[18], lines[19], lines[20], lines[21]]
    ];

    const result = expandSnippet({ direction: 'down', lines, snippetIndex: 0, snippets });

    expect(result).toHaveLength(2);
    expect(result[0].map(l => l.line)).toEqual(range(4, 22));
    expect(result[1].map(l => l.line)).toEqual(range(38, 43));
  });

function appData(state: any = { list: [] }, action) {
    switch(action.type) {
        case GET_LIST:
            return {
                list: _.range(20)
            };
    }

    return state;
}

  uploadMulti() {
    let files = this.selectedFiles
    if (_.isEmpty(files)) return;

    let filesIndex = _.range(files.length)
    _.each(filesIndex, (idx) => {
      this.currentUpload = new Upload(files[idx]);
      this.upSvc.pushUpload(this.currentUpload)}
    )
  }

export function weekRangeToArray(weekRange: WeekRange) {
    return _.range(weekRange.startWeek, weekRange.endWeek + 1).filter(w => {
        return weekRange.oddEven === 0
             ? true
             : weekRange.oddEven === 1
             ? w % 2 === 1
             : weekRange.oddEven === 2
             ? w % 2 === 0
             : false;
    });
}

function makeList(values: Array<string>, power: number, start = 0) {
    return _.map(
        _.range(start, values.length + start),
        function(i) {
            return {
                label: values[i - start],
                value: Math.pow(power, i)
            };
        }
    );
}

 _.each(_.range(height), col => {
     let blankCount = 0;
     _.each(_.range(1, height - row), adder => {
         if (orbs[row + adder][col] === '\u241a') {
             blankCount += 1;
         };
     });
     if (blankCount > 0) {
         blanksBelow[`${row}, ${col}`] = blankCount;
     };
 });

 () => {
   async.each(
     _.range(3),
     (i: number, callback: Function) => {
       let item = new testModel({ name: 'item' + (5 - i), index: (5 - i) });
       item.save(() => {
         callback();
       });
     },
     done);
 });

function sameBodyAndType(hyp1 : HTMLElement, hyp2 : HTMLElement) : boolean {
  const children1 = $(hyp1).children().slice(1)
  const children2 = $(hyp2).children().slice(1)
  if (children1.length !== children2.length) { return false }
  for (const i in _.range(children1.length)) {
    if ($(children1[i]).html() !== $(children2[i]).html()) {
      return false
    }
  }
  return true
}

    it('should setTimeslot', function () {
        const schedule = new Schedule();
        assert.throw(() => { schedule.setTimeslots([false]); }, 'timeslot should be 24 in length');

        const timeslots: boolean[] = Array<boolean>(24);
        _.forEach(_.range(24), (i) => timeslots[i] = false);

        timeslots[0] = true;
        schedule.setTimeslots(timeslots);
        assert.equal(schedule.toJSON(), 1, 'should allow setting timeslot in array of boolean');
    });

/**
 * Convert cartesian coordinates to spherical coordinates
 *
 * @param x - array of x coordinates
 * @param y - array of y coordinates
 * @param z - arrya of z coordinates
 */
function cart2sph(x: number[], y: number[], z: number[]) {
    var range = _.range(x.length)
    var r = range.map(i => Math.sqrt(x[i] * x[i] + y[i] * y[i] + z[i] * z[i]))
    var elev = range.map(i => Math.atan2(z[i], Math.sqrt(x[i] * x[i] + y[i] * y[i])))
    var az = range.map(i => Math.atan2(y[i], x[i]))
    return {
        r: r,
        elev: elev,
        az: az
    }
}

export function getKeySet(customKeys: Array<string>) {
    let lowerCharacters: Array<string> = [];
    let upperCharacters: Array<string> = [];

    if (!customKeys.length) {
        lowerCharacters = _.range('a'.charCodeAt(0), 'z'.charCodeAt(0) + 1 /* for inclusive*/)
            .map(c => String.fromCharCode(c));
        upperCharacters = _.range('A'.charCodeAt(0), 'Z'.charCodeAt(0) + 1 /* for inclusive*/)
            .map(c => String.fromCharCode(c));
    } else {
        for (let key of customKeys) {
            lowerCharacters.push(key.toLowerCase());
            upperCharacters.push(key.toUpperCase());
        }
    }

    const keys: Array<string> = [];

    // A little ugly.
    // I used itertools.permutation in python.
    // Couldn't find a good one in npm.  Don't worry this takes < 1ms once.
    // TODO: try a zip? and or make a func
    for (let c1 of lowerCharacters) {
        for (let c2 of lowerCharacters) {
            keys.push(c1 + c2);
        }
    }
    for (let c1 of upperCharacters) {
        for (let c2 of lowerCharacters) {
            keys.push(c1 + c2);
        }
    }
    for (let c1 of lowerCharacters) {
        for (let c2 of upperCharacters) {
            keys.push(c1 + c2);
        }
    }

    // TODO: use TS's ReadonlyArray?
    return keys;
}

async function main() {
  const writer = fs.createWriteStream(path.join(__dirname, 'address.json'))
  const api_url = 'http://maps.ottawa.ca/arcgis/rest/services/Property_Parcels/MapServer/0/query'
  let count = 0
  let first = false
  const max = 250
  const features: Array<GeoJSON.Feature<GeoJSON.Point>> = []

  // Write Feature Collection Header
  writer.write(`{
  "type": "FeatureCollection",
  "features": [
`)

  while (true) {
    const params = {
      objectIds: range(count, count + max).join(','),
      geometryType: 'esriGeometryEnvelope',
      spatialRel: 'esriSpatialRelIntersects',
      outFields: '*',
      returnGeometry: 'true',
      returnTrueCurves: 'false',
      returnIdsOnly: 'false',
      returnCountOnly: 'false',
      returnDistinctValues: 'false',
      outSR: 4326,
      f: 'pjson',
    }
    const url = `${ api_url }?${ encodeData(params)}`
    const r:InterfaceESRIResults = await rp.get(url)
      .then(data => JSON.parse(data))
    r.features.map(feature => {
      const attributes = {
        source: 'City of Ottawa'
      }
      const point = turf.point([feature.geometry.x, feature.geometry.y], feature.attributes)
      if (!first) {
        writer.write(`    ${ JSON.stringify(point)}`)
        first = true
      } else writer.write(`,\n    ${ JSON.stringify(point)}`)
    })

    // Stop or Start over
    if (!r.features.length) break
    console.log(count)
    count += max

    // if (count > 1000) break
  }
  writer.write(`
  ]
}`)
}

 .then((responses: Execution.IExecutionResponses) => {
     expect(responses).toEqual({
         executionResponse: getExecutionResponse(1),
         executionResult: {
             headerItems: [
                 [
                     [
                         ...range(DEFAULT_TEST_LIMIT + 1)
                             .map((i: number) => createMeasureHeaderItem(`m${i + 1}`, i + 1))
                     ]
                 ]
             ],
             data: range(1, DEFAULT_TEST_LIMIT + 2),
             paging: {
                 count: [DEFAULT_TEST_LIMIT + 1],
                 offset: [0],
                 total: [DEFAULT_TEST_LIMIT + 1]
             }
         }
     });
 });

 constructor (width: number = 8, height: number = 8, types: Orb[] = _.range(7), needsAttic: boolean = true) {
     this.width = width;
     this.height = height;
     this.types = types;
     this.generateOrbs();
     if (this.hasMatch() || this.needsShuffle()) {
         this.shuffle();
     };
     if (needsAttic) {
         this.attic = new Board(this.width, this.height, this.types, false);
     };
 }

 before((done: MochaDone) => {
   async.each(
     _.range(3),
     (i: number, callback: Function) => {
       let item = new testModel({ name: 'item' + i });
       item.save(() => {
         idList.push(item._id.toString());
         callback();
       });
     },
     done);
 });