var fs = require('fs')
var entryBuilder = require('./entry/entryBuilder')
var entryEquality = require('./entry/entryEquality')
var stats = require('./statistics/statisticsUpdate')
var pathUtils = require('path')
var fsPromise = require('./fs/fsPromise')
var loopDetector = require('./symlink/loopDetector')
var entryComparator = require('./entry/entryComparator')
var entryType = require('./entry/entryType')

/**
 * Returns the sorted list of entries in a directory.
 */
var getEntries = function (rootEntry, relativePath, loopDetected, options) {
    if (!rootEntry || loopDetected) {
        return Promise.resolve([])
    }
    if (rootEntry.isDirectory) {
        return fsPromise.readdir(rootEntry.absolutePath)
            .then(function (entries) {
                return entryBuilder.buildDirEntries(rootEntry, entries, relativePath, options)
            })
    }
    return Promise.resolve([rootEntry])
}

/**
 * Compares two directories asynchronously.
 */
var compare = function (rootEntry1, rootEntry2, level, relativePath, options, statistics, diffSet, symlinkCache) {
    var loopDetected1 = loopDetector.detectLoop(rootEntry1, symlinkCache.dir1)
    var loopDetected2 = loopDetector.detectLoop(rootEntry2, symlinkCache.dir2)
    loopDetector.updateSymlinkCache(symlinkCache, rootEntry1, rootEntry2, loopDetected1, loopDetected2)

    return Promise.all([getEntries(rootEntry1, relativePath, loopDetected1, options), getEntries(rootEntry2, relativePath, loopDetected2, options)]).then(
        function (entriesResult) {
            var entries1 = entriesResult[0]
            var entries2 = entriesResult[1]
            var i1 = 0, i2 = 0
            var comparePromises = []
            var compareFilePromises = []
            var subDiffSet

            while (i1 < entries1.length || i2 < entries2.length) {
                var entry1 = entries1[i1]
                var entry2 = entries2[i2]
                var type1, type2

                // compare entry name (-1, 0, 1)
                var cmp
                if (i1 < entries1.length && i2 < entries2.length) {
                    cmp = entryComparator.compareEntry(entry1, entry2, options)
                    type1 = entryType.getType(entry1)
                    type2 = entryType.getType(entry2)
                } else if (i1 < entries1.length) {
                    type1 = entryType.getType(entry1)
                    type2 = entryType.getType(undefined)
                    cmp = -1
                } else {
                    type1 = entryType.getType(undefined)
                    type2 = entryType.getType(entry2)
                    cmp = 1
                }

                // process entry
                if (cmp === 0) {
                    // Both left/right exist and have the same name and type
                    var compareAsyncRes = entryEquality.isEntryEqualAsync(entry1, entry2, type1, diffSet, options)
                    var samePromise = compareAsyncRes.samePromise
                    var same = compareAsyncRes.same
                    if (same !== undefined) {
                        options.resultBuilder(entry1, entry2,
                            same ? 'equal' : 'distinct',
                            level, relativePath, options, statistics, diffSet,
                            compareAsyncRes.reason)
                        stats.updateStatisticsBoth(entry1, entry2, compareAsyncRes.same, compareAsyncRes.reason, type1, statistics, options)
                    } else {
                        compareFilePromises.push(samePromise)
                    }

                    i1++
                    i2++
                    if (!options.skipSubdirs && type1 === 'directory') {
                        if (!options.noDiffSet) {
                            subDiffSet = []
                            diffSet.push(subDiffSet)
                        }
                        comparePromises.push(compare(entry1, entry2, level + 1,
                            pathUtils.join(relativePath, entry1.name),
                            options, statistics, subDiffSet, loopDetector.cloneSymlinkCache(symlinkCache)))
                    }
                } else if (cmp < 0) {
                    // Right missing
                    options.resultBuilder(entry1, undefined, 'left', level, relativePath, options, statistics, diffSet)
                    stats.updateStatisticsLeft(entry1, type1, statistics, options)
                    i1++
                    if (type1 === 'directory' && !options.skipSubdirs) {
                        if (!options.noDiffSet) {
                            subDiffSet = []
                            diffSet.push(subDiffSet)
                        }
                        comparePromises.push(compare(entry1, undefined,
                            level + 1,
                            pathUtils.join(relativePath, entry1.name), options, statistics, subDiffSet, loopDetector.cloneSymlinkCache(symlinkCache)))
                    }
                } else {
                    // Left missing
                    options.resultBuilder(undefined, entry2, 'right', level, relativePath, options, statistics, diffSet)
                    stats.updateStatisticsRight(entry2, type2, statistics, options)
                    i2++
                    if (type2 === 'directory' && !options.skipSubdirs) {
                        if (!options.noDiffSet) {
                            subDiffSet = []
                            diffSet.push(subDiffSet)
                        }
                        comparePromises.push(compare(undefined, entry2,
                            level + 1,
                            pathUtils.join(relativePath, entry2.name), options, statistics, subDiffSet, loopDetector.cloneSymlinkCache(symlinkCache)))
                    }
                }
            }
            return Promise.all(comparePromises).then(function () {
                return Promise.all(compareFilePromises).then(function (sameResults) {
                    for (var i = 0; i < sameResults.length; i++) {
                        var sameResult = sameResults[i]
                        if (sameResult.error) {
                            return Promise.reject(sameResult.error)
                        } else {
                            options.resultBuilder(sameResult.entry1, sameResult.entry2,
                                sameResult.same ? 'equal' : 'distinct',
                                level, relativePath, options, statistics, sameResult.diffSet,
                                sameResult.reason)
                            stats.updateStatisticsBoth(sameResult.entries1, sameResult.entries2, sameResult.same, sameResult.reason, sameResult.type1, statistics, options)
                        }
                    }
                })
            })
        })
}

module.exports = compare