const normalizeEntryData = (wordData: WordData) => (entryData: EntryData) => {
    const cards = flattenDeep(
        R.map(normalizeSenseData(wordData))(entryData.senses)
    )

    return cards
}

const precommitRunner: TaskRunner<PrecommitOptions> = async () => {
  const status = await simpleGit.status();
  const sassFiles = status.files.filter(
    file => (file.path as string).match(/^[a-zA-Z0-9\_\-\/]+(\.scss)$/g) || file.path.indexOf('.sass-lint.yml') > -1
  );

  const tsFiles = status.files.filter(file => (file.path as string).match(/^[a-zA-Z0-9\_\-\/]+(\.(ts|tsx))$/g));
  const testFiles = status.files.filter(file => (file.path as string).match(/^[a-zA-Z0-9\_\-\/]+(\.test.(ts|tsx))$/g));
  const goTestFiles = status.files.filter(file => (file.path as string).match(/^[a-zA-Z0-9\_\-\/]+(\_test.go)$/g));
  const grafanaUiFiles = tsFiles.filter(file => (file.path as string).indexOf('grafana-ui') > -1);

  const grafanaUIFilesChangedOnly = tsFiles.length > 0 && tsFiles.length - grafanaUiFiles.length === 0;
  const coreFilesChangedOnly = tsFiles.length > 0 && grafanaUiFiles.length === 0;

  const taskPaths = [];

  if (sassFiles.length > 0) {
    taskPaths.push('lint.sass');
  }

  if (testFiles.length) {
    taskPaths.push('test.lint.ts');
  }

  if (goTestFiles.length) {
    taskPaths.push('test.lint.go');
  }

  if (tsFiles.length > 0) {
    if (grafanaUIFilesChangedOnly) {
      taskPaths.push('lint.gui', 'typecheck.core', 'typecheck.gui');
    } else if (coreFilesChangedOnly) {
      taskPaths.push('lint.core', 'typecheck.core');
    } else {
      taskPaths.push('lint.core', 'lint.gui', 'typecheck.core', 'typecheck.gui');
    }
  }

  const gruntTasks = flatten(taskPaths.map(path => get(tasks, path)));
  if (gruntTasks.length > 0) {
    console.log(chalk.yellow(`Precommit checks: ${taskPaths.join(', ')}`));
    const task = execa('grunt', gruntTasks);
    // @ts-ignore
    const stream = task.stdout;
    stream.pipe(process.stdout);
    return task;
  }
  console.log(chalk.yellow('Skipping precommit checks, not front-end changes detected'));
  return;
};

const normalizeSenseData = (wordData: WordData) => (
    senseData: SenseData
): CardData[] => {
    const { headword, pronunciation, frequency } = wordData

    const {
        definition,
        situation,
        geography,
        synonym,
        antonym,
        examples,
        exampleGroups,
        subsenses
    } = senseData

    const commonData = {
        headword,
        pronunciation,
        frequency,
        definition,
        situation,
        geography,
        synonym,
        antonym
    }

    // normalize... functions

    const normalizeExample = (form: string) => (example: string) => ({
        ...commonData,
        example,
        form
    })

    const normalizeExampleGroup = (exampleGroup: ExampleGroup) => {
        const { form, examples: exampleGroupExamples } = exampleGroup
        const cards = exampleGroupExamples.map(normalizeExample(form))
        return cards
    }

    // cards from different sources

    const cardsFromExamples = R.map(normalizeExample(headword))(examples)

    const cardsFromExampleGroups = R.map(normalizeExampleGroup)(exampleGroups)

    const cardsFromSubsenses = R.map(normalizeSenseData(wordData))(subsenses)

    const cardsFromDefinition =
        R.all(R.isEmpty, [examples, exampleGroups, subsenses]) && definition
            ? [{ ...commonData, form: headword, example: '' }]
            : []

    // all cards

    // TODO:  find out why single top-level flattenDeep is not enough
    const cards = flattenDeep([
        cardsFromExamples,
        flattenDeep(cardsFromExampleGroups),
        flattenDeep(cardsFromSubsenses),
        cardsFromDefinition
    ])

    return cards
}

				'Hashed file of "' +
					fileName +
					'" ' +
					'not found when searching with "' +
					searchPath +
					'"',
			)
		}

		files[fileName] = path.basename(hashedFilename)
	})
}

const locations = flatten([
	Constants.APIPages.map((group: any) => group.pages),
	Constants.ExamplePages.map((group: any) => group.pages),
	Constants.Pages,
]).reduce((paths: string[], pages: { [key: string]: any }) => {
	return paths.concat(Object.keys(pages).map(key => pages[key].location))
}, [])

locations.forEach((fileName: string) => {
	const props = {
		location: fileName,
		devMode: process.env.NODE_ENV !== 'production',
		files,
	}

	renderPath(fileName, props, (content: string) => {
		fs.writeFileSync(path.join(sitePath, fileName), content)
	})

export const getColorByName = (colorName: string) => {
  const definition = flatten(Array.from(getNamedColorPalette().values())).filter(
    definition => definition.name === colorName
  );
  return definition.length > 0 ? definition[0] : undefined;
};