export function readClusion(config: ClusionConfig): Tried<RegExp, string>[] {
    if (br.isString(config)) {
        return [insteadFuck(toRegexp(config), messageOf)];
    } else if (br.isArray(config)) {
        return ba.insteadEach(
            ba.insteadEach(
                config,
                config => br.isString(config)
                    ? insteadFuck(toRegexp(config), messageOf)
                    : readRegexp(config)
            ),
            (tried, index) => insteadFuck(tried, fuck => 'At #' + index + ': ' + fuck)
        );
    } else {
        return [readRegexp(config)]
    }
}

export function readClusions(config: ClusionsConfig): Crooked<Clusions, string[]> {
    const include = config.include === undefined
        ? [fuckFrom('The \'include\' property of a file filter is unspecified.')]
        : readClusion(config.include);
    const exclude = config.exclude === undefined
        ? []
        : readClusion(config.exclude);

    const [included, notIncluded] = partitionAsOfTried(include);
    const [excluded, notExcluded] = partitionAsOfTried(exclude);
    return crookedFrom(
        clusionsFrom(included, excluded),
        ba.concat(
            ba.insteadEach(notIncluded, problem => 'Invalid include. ' + problem),
            ba.insteadEach(notExcluded, problem => 'Invalid exclude. ' + problem)
        )
    );
}

function writeResults(entries: Entry[], filename: string): void {
    const lines = ba.insteadEach(
        ba.sortAsOf(entries, same, entry => entry.name, compareStrings, 1),
        ({ count, name }) => name + '\t' + count
    );
    fs.writeFile(
        filename,
        lines.join('\r\n')
    );
}

export default function toBadComment(node: ts.Node, _: ts.TypeChecker, _config: Config): Issue | void {
    const identifier = nameIdentifierOutOf(node);
    if (identifier !== undefined && identifier.parent !== undefined) {
        const fragments = ba.insteadEach(leadingCommentsStrippedOutOf(identifier.parent), normalize);
        const name = normalize(identifier.text);
        const found = ba.firstThatOutOf(fragments, fragment => fragment === name);
        if (found !== undefined) {
            return issueFrom(node, 'useless comment', 'useless-comment');
        }
    }
}

function instructionsOutOfComments(comments: string[]): string[] {
    const mapped = ba.insteadEach(comments, comment => {
        const matched = /SKIP: (((\w|-)+)(\s*,\s*(\w|-)+)*)/.exec(comment);
        if (matched != null) {
            const found = matched[1]!;
            const instructions = found.split(',').map(x => x.trim());
            return instructions;
        } else {
            return undefined;
        }
    });
    const filtered = ba.onlyThoseAs(mapped, bb.isDefined);
    return ba.concatAll(filtered);
}

function toState(configs: Config[]): State {

    const checks = ba.insteadEach(
        configs,
        config => checkFrom(
            new RegExp(config.pattern, config.flags),
            config.message,
            toTarget(config.target)
        )
    );

    return {
        checks,
        issues: bl.empty
    };
}

    function lint(
        projectFile: string,
        shared: Shared,
        configuration: Configs
    ): OneOfThree<Issue[], ts.Diagnostic[], Line<Severity>[]> {

        const runners = toRunners(configuration);
        if (bt.isLuck(runners)) {
            const [configured, unconfigured] = partition<bm.Some<Runner<Shared>>, bm.None>(runners.luck, bm.isSome);
            if (configured.length > 0) {
                const linted = run(
                    projectFile,
                    shared,
                    insteadEach(configured, bm.someOf)
                );
                if (bt.isLuck(linted)) {
                    return firstFrom(linted.luck);
                } else {
                    return secondFrom(linted.fuck);
                }
            } else {
                return thirdFrom(
                    fold(
                        unconfigured,
                        [lineFrom(Severity.Info, 'There are no available rules.')],
                        (result, unconfigured) => append(result, lineFrom(Severity.Info, unconfigured.none))
                    )
                );
            }
        } else {
            return thirdFrom(
                fold(
                    runners.fuck,
                    [lineFrom(Severity.Error, 'Unable to get runners ready.')],
                    (result, failure) => append(result, lineFrom(Severity.Error, failure))
                )
            );
        }
    }

 return withState(text, defaultCompilerOptions, rule, options, someRandomRuleKey, shared, state => {
     expect(insteadEach(rule.toIssues(state, options, shared), simplifyIssue))
         .toEqual(insteadEach(drafts, simplifyIssue), 'Specific issues expected.');
 })

 issues => insteadEach(
     issues,
     issue => beingLintingFormatting.formatIssue(issue)
 )

 problems => ba.insteadEach(
     problems,
     problem => 'Rule \'' + ruleKey + '\' has invalid configuration. ' + problem
 )