'use strict';
const fs = require('fs');
const arrayUnion = require('array-union');
const merge2 = require('merge2');
const fastGlob = require('fast-glob');
const dirGlob = require('dir-glob');
const gitignore = require('./gitignore');
const {FilterStream, UniqueStream} = require('./stream-utils');

const DEFAULT_FILTER = () => false;

const isNegative = pattern => pattern[0] === '!';

const assertPatternsInput = patterns => {
    if (!patterns.every(pattern => typeof pattern === 'string')) {
        throw new TypeError('Patterns must be a string or an array of strings');
    }
};

const checkCwdOption = (options = {}) => {
    if (!options.cwd) {
        return;
    }

    let stat;
    try {
        stat = fs.statSync(options.cwd);
    } catch {
        return;
    }

    if (!stat.isDirectory()) {
        throw new Error('The `cwd` option must be a path to a directory');
    }
};

const getPathString = p => p.stats instanceof fs.Stats ? p.path : p;

const generateGlobTasks = (patterns, taskOptions) => {
    patterns = arrayUnion([].concat(patterns));
    assertPatternsInput(patterns);
    checkCwdOption(taskOptions);

    const globTasks = [];

    taskOptions = {
        ignore: [],
        expandDirectories: true,
        ...taskOptions
    };

    for (const [index, pattern] of patterns.entries()) {
        if (isNegative(pattern)) {
            continue;
        }

        const ignore = patterns
            .slice(index)
            .filter(pattern => isNegative(pattern))
            .map(pattern => pattern.slice(1));

        const options = {
            ...taskOptions,
            ignore: taskOptions.ignore.concat(ignore)
        };

        globTasks.push({pattern, options});
    }

    return globTasks;
};

const globDirs = (task, fn) => {
    let options = {};
    if (task.options.cwd) {
        options.cwd = task.options.cwd;
    }

    if (Array.isArray(task.options.expandDirectories)) {
        options = {
            ...options,
            files: task.options.expandDirectories
        };
    } else if (typeof task.options.expandDirectories === 'object') {
        options = {
            ...options,
            ...task.options.expandDirectories
        };
    }

    return fn(task.pattern, options);
};

const getPattern = (task, fn) => task.options.expandDirectories ? globDirs(task, fn) : [task.pattern];

const getFilterSync = options => {
    return options && options.gitignore ?
        gitignore.sync({cwd: options.cwd, ignore: options.ignore}) :
        DEFAULT_FILTER;
};

const globToTask = task => glob => {
    const {options} = task;
    if (options.ignore && Array.isArray(options.ignore) && options.expandDirectories) {
        options.ignore = dirGlob.sync(options.ignore);
    }

    return {
        pattern: glob,
        options
    };
};

module.exports = async (patterns, options) => {
    const globTasks = generateGlobTasks(patterns, options);

    const getFilter = async () => {
        return options && options.gitignore ?
            gitignore({cwd: options.cwd, ignore: options.ignore}) :
            DEFAULT_FILTER;
    };

    const getTasks = async () => {
        const tasks = await Promise.all(globTasks.map(async task => {
            const globs = await getPattern(task, dirGlob);
            return Promise.all(globs.map(globToTask(task)));
        }));

        return arrayUnion(...tasks);
    };

    const [filter, tasks] = await Promise.all([getFilter(), getTasks()]);
    const paths = await Promise.all(tasks.map(task => fastGlob(task.pattern, task.options)));

    return arrayUnion(...paths).filter(path_ => !filter(getPathString(path_)));
};

module.exports.sync = (patterns, options) => {
    const globTasks = generateGlobTasks(patterns, options);

    const tasks = [];
    for (const task of globTasks) {
        const newTask = getPattern(task, dirGlob.sync).map(globToTask(task));
        tasks.push(...newTask);
    }

    const filter = getFilterSync(options);

    let matches = [];
    for (const task of tasks) {
        matches = arrayUnion(matches, fastGlob.sync(task.pattern, task.options));
    }

    return matches.filter(path_ => !filter(path_));
};

module.exports.stream = (patterns, options) => {
    const globTasks = generateGlobTasks(patterns, options);

    const tasks = [];
    for (const task of globTasks) {
        const newTask = getPattern(task, dirGlob.sync).map(globToTask(task));
        tasks.push(...newTask);
    }

    const filter = getFilterSync(options);
    const filterStream = new FilterStream(p => !filter(p));
    const uniqueStream = new UniqueStream();

    return merge2(tasks.map(task => fastGlob.stream(task.pattern, task.options)))
        .pipe(filterStream)
        .pipe(uniqueStream);
};

module.exports.generateGlobTasks = generateGlobTasks;

module.exports.hasMagic = (patterns, options) => []
    .concat(patterns)
    .some(pattern => fastGlob.isDynamicPattern(pattern, options));

module.exports.gitignore = gitignore;