/* @internal */
namespace ts.NavigateTo {
    interface RawNavigateToItem {
        name: string;
        fileName: string;
        matchKind: PatternMatchKind;
        isCaseSensitive: boolean;
        declaration: Declaration;
    }

    export function getNavigateToItems(sourceFiles: ReadonlyArray<SourceFile>, checker: TypeChecker, cancellationToken: CancellationToken, searchValue: string, maxResultCount: number, excludeDtsFiles: boolean): NavigateToItem[] {
        const patternMatcher = createPatternMatcher(searchValue);
        let rawItems: RawNavigateToItem[] = [];

        // Search the declarations in all files and output matched NavigateToItem into array of NavigateToItem[]
        for (const sourceFile of sourceFiles) {
            cancellationToken.throwIfCancellationRequested();

            if (excludeDtsFiles && fileExtensionIs(sourceFile.fileName, Extension.Dts)) {
                continue;
            }

            forEachEntry(sourceFile.getNamedDeclarations(), (declarations, name) => {
                getItemsFromNamedDeclaration(patternMatcher, name, declarations, checker, sourceFile.fileName, rawItems);
            });
        }

        rawItems.sort(compareNavigateToItems);
        if (maxResultCount !== undefined) {
            rawItems = rawItems.slice(0, maxResultCount);
        }
        return rawItems.map(createNavigateToItem);
    }

    function getItemsFromNamedDeclaration(patternMatcher: PatternMatcher, name: string, declarations: ReadonlyArray<Declaration>, checker: TypeChecker, fileName: string, rawItems: Push<RawNavigateToItem>): void {
        // First do a quick check to see if the name of the declaration matches the
        // last portion of the (possibly) dotted name they're searching for.
        const matches = patternMatcher.getMatchesForLastSegmentOfPattern(name);

        if (!matches) {
            return; // continue to next named declarations
        }

        for (const declaration of declarations) {
            if (!shouldKeepItem(declaration, checker)) {
                continue;
            }

            // It was a match! If the pattern has dots in it, then also see if the
            // declaration container matches as well.
            let containerMatches = matches;
            if (patternMatcher.patternContainsDots) {
                containerMatches = patternMatcher.getMatches(getContainers(declaration), name);
                if (!containerMatches) {
                    continue;
                }
            }

            const matchKind = bestMatchKind(containerMatches);
            const isCaseSensitive = allMatchesAreCaseSensitive(containerMatches);
            rawItems.push({ name, fileName, matchKind, isCaseSensitive, declaration });
        }
    }

    function shouldKeepItem(declaration: Declaration, checker: ts.TypeChecker): boolean {
        switch (declaration.kind) {
            case SyntaxKind.ImportClause:
            case SyntaxKind.ImportSpecifier:
            case SyntaxKind.ImportEqualsDeclaration:
                const importer = checker.getSymbolAtLocation((declaration as ImportClause | ImportSpecifier | ImportEqualsDeclaration).name);
                const imported = checker.getAliasedSymbol(importer);
                return importer.escapedName !== imported.escapedName;
            default:
                return true;
        }
    }

    function allMatchesAreCaseSensitive(matches: ReadonlyArray<PatternMatch>): boolean {
        Debug.assert(matches.length > 0);

        // This is a case sensitive match, only if all the submatches were case sensitive.
        for (const match of matches) {
            if (!match.isCaseSensitive) {
                return false;
            }
        }

        return true;
    }

    function tryAddSingleDeclarationName(declaration: Declaration, containers: string[]): boolean {
        if (declaration) {
            const name = getNameOfDeclaration(declaration);
            if (name) {
                const text = getTextOfIdentifierOrLiteral(name as (Identifier | LiteralExpression));
                if (text !== undefined) {
                    containers.unshift(text);
                }
                else if (name.kind === SyntaxKind.ComputedPropertyName) {
                    return tryAddComputedPropertyName((<ComputedPropertyName>name).expression, containers, /*includeLastPortion*/ true);
                }
                else {
                    // Don't know how to add this.
                    return false;
                }
            }
        }

        return true;
    }

    // Only added the names of computed properties if they're simple dotted expressions, like:
    //
    //      [X.Y.Z]() { }
    function tryAddComputedPropertyName(expression: Expression, containers: string[], includeLastPortion: boolean): boolean {
        const text = getTextOfIdentifierOrLiteral(expression as LiteralExpression);
        if (text !== undefined) {
            if (includeLastPortion) {
                containers.unshift(text);
            }
            return true;
        }

        if (expression.kind === SyntaxKind.PropertyAccessExpression) {
            const propertyAccess = <PropertyAccessExpression>expression;
            if (includeLastPortion) {
                containers.unshift(propertyAccess.name.text);
            }

            return tryAddComputedPropertyName(propertyAccess.expression, containers, /*includeLastPortion*/ true);
        }

        return false;
    }

    function getContainers(declaration: Declaration): string[] {
        const containers: string[] = [];

        // First, if we started with a computed property name, then add all but the last
        // portion into the container array.
        const name = getNameOfDeclaration(declaration);
        if (name.kind === SyntaxKind.ComputedPropertyName) {
            if (!tryAddComputedPropertyName((<ComputedPropertyName>name).expression, containers, /*includeLastPortion*/ false)) {
                return undefined;
            }
        }

        // Now, walk up our containers, adding all their names to the container array.
        declaration = getContainerNode(declaration);

        while (declaration) {
            if (!tryAddSingleDeclarationName(declaration, containers)) {
                return undefined;
            }

            declaration = getContainerNode(declaration);
        }

        return containers;
    }

    function bestMatchKind(matches: ReadonlyArray<PatternMatch>): PatternMatchKind {
        Debug.assert(matches.length > 0);
        let bestMatchKind = PatternMatchKind.camelCase;

        for (const match of matches) {
            const kind = match.kind;
            if (kind < bestMatchKind) {
                bestMatchKind = kind;
            }
        }

        return bestMatchKind;
    }

    function compareNavigateToItems(i1: RawNavigateToItem, i2: RawNavigateToItem) {
        // TODO(cyrusn): get the gamut of comparisons that VS already uses here.
        return compareValues(i1.matchKind, i2.matchKind)
            || compareStringsCaseSensitiveUI(i1.name, i2.name);
    }

    function createNavigateToItem(rawItem: RawNavigateToItem): NavigateToItem {
        const declaration = rawItem.declaration;
        const container = <Declaration>getContainerNode(declaration);
        const containerName = container && getNameOfDeclaration(container);
        return {
            name: rawItem.name,
            kind: getNodeKind(declaration),
            kindModifiers: getNodeModifiers(declaration),
            matchKind: PatternMatchKind[rawItem.matchKind],
            isCaseSensitive: rawItem.isCaseSensitive,
            fileName: rawItem.fileName,
            textSpan: createTextSpanFromNode(declaration),
            // TODO(jfreeman): What should be the containerName when the container has a computed name?
            containerName: containerName ? (<Identifier>containerName).text : "",
            containerKind: containerName ? getNodeKind(container) : ScriptElementKind.unknown
        };
    }
}