export function getMigrationStates(
  migrations: Migration[], journalEntries: JournalEntry[]
): MigrationState[] {
  let migrationIDSet: { [id: string]: boolean } = {};
  let states: { [id: string]: MigrationState } = {};

  R.forEach(function(migration) {
    migrationIDSet[migration.id] = true;
    states[migration.id] = {
      migrationID: migration.id,
      migrationName: migration.name,
      state: State.pending
    };
  }, migrations);

  R.forEach(function(entry) {
    if (!migrationIDSet[entry.migrationID]) {
      states[entry.migrationID] = {
        migrationID: entry.migrationID,
        migrationName: entry.migrationName,
        state: State.missing
      };
    } else if (entry.operation === Operation.apply) {
      states[entry.migrationID].state = State.applied;
    } else if (entry.operation === Operation.revert) {
      states[entry.migrationID].state = State.reverted;
    } else {
      throw new InvalidJournalOperationError(entry.operation);
    }
  }, journalEntries);

  return R.sortBy(s => s.migrationID, R.values(states));
}

  /**
   * Return a audit log object for assigning to the model
   *
   * Example:
   *
   * ```
   * const auditLog = RecordHelper.getAuditLog(this.$isNewRecord, username);
   * const writeAuditLog = R.pipe(R.keys,
   *    R.forEach(n => this[n] = auditLog[n]))(auditLog);
   * ```
   */
  static getAuditLog(isNewRecord, username) {
    let model = { }
    if (isNewRecord) {
      const createLog = this.getCreateLog(username);
      const writeCreateLog = R.pipe(R.keys,
        R.forEach(n => model[n] = createLog[n]))(createLog);
    }

    const updateLog = this.getUpdateLog(username);
    const writeUpdateLog = R.pipe(R.keys,
      R.forEach(n => model[n] = updateLog[n]))(updateLog);
    return model;
  }

  const convertResponse = curry((startedAt: number, axiosResult: AxiosResponse | AxiosError) => {
    const end: number = toNumber(new Date())
    const duration: number = end - startedAt

    // new in Axios 0.13 -- some data could be buried 1 level now
    const isError = axiosResult instanceof Error || axios.isCancel(axiosResult)
    const axiosResponse = axiosResult as AxiosResponse
    const axiosError = axiosResult as AxiosError
    const response = isError ? axiosError.response : axiosResponse
    const status = (response && response.status) || null
    const problem = isError ? getProblemFromError(axiosResult) : getProblemFromStatus(status)
    const originalError = isError ? axiosError : null
    const ok = in200s(status)
    const config = axiosResult.config || null
    const headers = (response && response.headers) || null
    let data = (response && response.data) || null

    // give an opportunity for anything to the response transforms to change stuff along the way
    let transformedResponse = {
      duration,
      problem,
      originalError,
      ok,
      status,
      headers,
      config,
      data,
    }
    if (responseTransforms.length > 0) {
      forEach(transform => transform(transformedResponse), responseTransforms)
    }

    return transformedResponse
  })

R.map(rawCourse => {
  const course = createCourse(rawCourse);
  const words = getVocabularyRecursive(course);

  R.forEach(word => {
    const id = word
      .toLowerCase()
      .replace(/\s/g, '_')
      .replace(/ß/g, 'sz')
      .replace(/ä/g, 'ae')
      .replace(/ü/g, 'ue')
      .replace(/ö/g, 'oe')
      .replace(/é/g, 'e');

    if (typeof wordsDb[id] === 'undefined') {
      console.log(`[ERR] Word does not exist:`, id);
      return;
    }

    if (typeof loadWordImage[id] === 'undefined') {
      console.log(`[ERR] Image does not exist:`, id);
      return;
    }

    if (typeof loadWordSound[`${id}_short`] === 'undefined') {
      console.log(`[ERR] Sound does not exist:`, id);
      return;
    }

    // if (typeof loadWordSound[`${id}_long`] === 'undefined') {
    //   console.log(`[WARN] Long sound does not exist:`, id)
    //   return;
    // }
  }, words);
}, courses);

 /**
  * Return a immutable model
  * @param model An object with key value pair
  */
 static getImmutableModel(model) {
   let newModel: any = { };
   const getFields = R.keys();
   const assignFields = field => newModel[field] = model[field];
   const prepareModel = R.pipe(getFields, R.forEach(assignFields));
   prepareModel(model);
   return newModel;
 }

  .then(files => {
    // Loaders for React Native app
    let str = `import { AssetTypes } from '../../../packages/entities';

    const images: { [id: string]: () => AssetTypes.ImageAsset } = {`;

    R.forEach(file => {
      str += `
  ${getFilename(file)}: () => require('./images/${file}'),`;
    }, files);

    str += `
};

export default images;`;

    // Process files
    return Promise.all([
      writeFile(path.join(assetsPath, 'images.ts'), str),
      Promise.all(
        R.map(file => {
          const source = path.join(imagesPath, file);

          // Create three output files
          const targets = R.map(
            suffix =>
              path.join(
                outputPath,
                `${getFilename(file)}${suffix}${getExtname(file)}`
              ),
            suffixes
          );

          return Promise.all(
            R.zipWith(
              (target, size) =>
                new Promise((resolve, reject) => {
                  gm(source)
                    .resize(size, size, '!')
                    .quality(0.8)
                    .write(target, err => {
                      if (err) {
                        reject(err);
                        return;
                      }

                      resolve();
                    });
                }),
              targets,
              sizes
            )
          );
        }, files)
      )
    ]);
  });

 before(function() {
   R.forEach(method => spies[method] = sinon.spy(dummy, method), [
     'connect', 'ensureJournal', 'readJournal', 'beginTransaction',
     'runMigrationSQL', 'appendJournal', 'rollbackTransaction',
     'commitTransaction', 'disconnect'
   ]);
   spies.readUpSQL = sinon.spy(files, 'readUpSQL');
   spies.readDownSQL = sinon.spy(files, 'readDownSQL');
 });

  public resetChildrenProgress(id: string) {
    const entity = this.course.findEntity(id);

    if (entity && isInternalNode(entity)) {
      forEach(child => {
        this.progress[child.getId()] = { progress: Progress.Unseen };
        this.resetChildrenProgress(child.getId());
      }, entity.getChildren());
    }
  }

const runTests = <S, F>(
  assert: (
    fixture: ExerciseFixture<S, F>,
    /* tslint:disable-next-line:no-any */
    exercise: AbstractExercise<any, S, F>
  ) => void
) => {
  const resolver = new MockAssetResolver();
  const factory = new EntityFactory(resolver);

  const cases = values(
    mapObjIndexed(
      (
        E: {
          fixtures: Array<ExerciseFixture<S, F>>;
          /* tslint:disable-next-line:no-any */
          new (p: any): AbstractExercise<any, S, F>;
        },
        type
      ) => () => {
        forEach(fixture => {
          try {
            const exercise = factory.createExercise(
              type as ExerciseTypes,
              fixture.props
            );

            // Catch test failures so that we can pass a custom message
            assert(fixture, exercise);
          } catch (e) {
            throw new Error(`${type} › ${fixture.name}:\n${e.message}`);
          }
        }, E.fixtures);
      },
      Exercises
    )
  );

  // Execute the test runners
  forEach(runTestCases => runTestCases(), cases);

  // Check that each test case was run
  const numberOfAssertions = sum(
    values(
      map<
        { [type: string]: { fixtures: Array<ExerciseFixture<S, F>> } },
        { [type: string]: number }
      >(
        (E: { fixtures: Array<ExerciseFixture<S, F>> }) => E.fixtures.length,
        Exercises
      )
    )
  );
  expect.assertions(numberOfAssertions);
};

 it('resets progress correctly', () => {
   const root = '09438926-b170-4005-a6e8-5dd8fba83cde';
   const children = [
     '01f23c2a-b681-43db-9d27-5d8d59f62aed',
     '23e20d5b-ad8e-41be-9891-5ca7b12675c4',
     'e194f80b-7312-43a2-995e-060f64631782',
     '84fdc1a1-e3bf-4a87-8360-0c3b7beec179'
   ];
   forEach(
     id => {
       interactor.markAsCorrect(id);
     },
     [root, ...children]
   );
   interactor.resetChildrenProgress(root);
   expect(interactor.getProgress(root).progress).toBe(Progress.Correct);
   forEach(id => {
     expect(interactor.getProgress(id).progress).toBe(Progress.Unseen);
   }, children);
 });