// Copyright (c) Microsoft Corporation. All rights reserved.

// Licensed under the MIT License.

'use strict';

// tslint:disable:no-any

import * as assert from 'assert';

import { expect, use } from 'chai';

import * as chaiAsPromised from 'chai-as-promised';

import * as path from 'path';

import { anything, instance, mock, verify, when } from 'ts-mockito';

import { CancellationTokenSource, Uri } from 'vscode';

import { CommandManager } from '../../client/common/application/commandManager';

import { ICommandManager } from '../../client/common/application/types';

import { Commands } from '../../client/common/constants';

import { FileSystem } from '../../client/common/platform/fileSystem';

import { IFileSystem } from '../../client/common/platform/types';

import { Generator } from '../../client/workspaceSymbols/generator';

import { WorkspaceSymbolProvider } from '../../client/workspaceSymbols/provider';

use(chaiAsPromised);

const workspaceUri = Uri.file(path.join(__dirname, '..', '..', '..', 'src', 'test'));

// tslint:disable-next-line:max-func-body-length

suite('Workspace Symbols Provider', () => {

let generator: Generator;

let fs: IFileSystem;

let commandManager: ICommandManager;

setup(() => {

fs = mock(FileSystem);

commandManager = mock(CommandManager);

generator = mock(Generator);

});

test('Returns 0 tags without any generators', async () => {

const provider = new WorkspaceSymbolProvider(instance(fs), instance(commandManager), []);

const tags = await provider.provideWorkspaceSymbols('', new CancellationTokenSource().token);

expect(tags).to.be.lengthOf(0);

});

test("Builds tags when a tag file doesn't exist", async () => {

const provider = new WorkspaceSymbolProvider(instance(fs), instance(commandManager), [instance(generator)]);

const tagFilePath = 'No existing tagFilePath';

when(generator.tagFilePath).thenReturn(tagFilePath);

when(fs.fileExists(tagFilePath)).thenResolve(false);

when(commandManager.executeCommand(Commands.Build_Workspace_Symbols, true, anything())).thenResolve();

const tags = await provider.provideWorkspaceSymbols('', new CancellationTokenSource().token);

expect(tags).to.be.lengthOf(0);

verify(commandManager.executeCommand(Commands.Build_Workspace_Symbols, true, anything())).once();

});

test("Builds tags when a tag file doesn't exist", async () => {

const provider = new WorkspaceSymbolProvider(instance(fs), instance(commandManager), [instance(generator)]);

const tagFilePath = 'No existing tagFilePath';

when(generator.tagFilePath).thenReturn(tagFilePath);

when(fs.fileExists(tagFilePath)).thenResolve(false);

when(commandManager.executeCommand(Commands.Build_Workspace_Symbols, true, anything())).thenResolve();

const tags = await provider.provideWorkspaceSymbols('', new CancellationTokenSource().token);

expect(tags).to.be.lengthOf(0);

verify(commandManager.executeCommand(Commands.Build_Workspace_Symbols, true, anything())).once();

});

test('Symbols should not be returned when disabled', async () => {

const provider = new WorkspaceSymbolProvider(instance(fs), instance(commandManager), [instance(generator)]);

const tagFilePath = 'existing tagFilePath';

when(generator.tagFilePath).thenReturn(tagFilePath);

when(generator.enabled).thenReturn(false);

when(fs.fileExists(tagFilePath)).thenResolve(true);

when(commandManager.executeCommand(Commands.Build_Workspace_Symbols, true, anything())).thenResolve();

const tags = await provider.provideWorkspaceSymbols('', new CancellationTokenSource().token);

expect(tags).to.be.lengthOf(0);

verify(commandManager.executeCommand(Commands.Build_Workspace_Symbols, true, anything())).never();

});

test('symbols should be returned when enabeld and vice versa', async () => {

const provider = new WorkspaceSymbolProvider(instance(fs), instance(commandManager), [instance(generator)]);

const tagFilePath = path.join(workspaceUri.fsPath, '.vscode', 'tags');

when(generator.tagFilePath).thenReturn(tagFilePath);

when(generator.workspaceFolder).thenReturn(workspaceUri);

when(generator.enabled).thenReturn(true);

when(fs.fileExists(tagFilePath)).thenResolve(true);

when(commandManager.executeCommand(Commands.Build_Workspace_Symbols, true, anything())).thenResolve();

const tags = await provider.provideWorkspaceSymbols('', new CancellationTokenSource().token);

expect(tags).to.be.lengthOf(100);

verify(commandManager.executeCommand(Commands.Build_Workspace_Symbols, true, anything())).never();

});

test('symbols should be filtered correctly', async () => {

const provider = new WorkspaceSymbolProvider(instance(fs), instance(commandManager), [instance(generator)]);

const tagFilePath = path.join(workspaceUri.fsPath, '.vscode', 'tags');

when(generator.tagFilePath).thenReturn(tagFilePath);

when(generator.workspaceFolder).thenReturn(workspaceUri);

when(generator.enabled).thenReturn(true);

when(fs.fileExists(tagFilePath)).thenResolve(true);

when(commandManager.executeCommand(Commands.Build_Workspace_Symbols, true, anything())).thenResolve();

const symbols = await provider.provideWorkspaceSymbols('meth1Of', new CancellationTokenSource().token);

expect(symbols).to.be.length.greaterThan(0);

verify(commandManager.executeCommand(Commands.Build_Workspace_Symbols, true, anything())).never();

assert.equal(symbols.length >= 2, true, 'Incorrect number of symbols returned');

assert.notEqual(

symbols.findIndex((sym) => sym.location.uri.fsPath.endsWith('childFile.py')),

-1,

'File with symbol not found in child workspace folder'

);

assert.notEqual(

symbols.findIndex((sym) => sym.location.uri.fsPath.endsWith('workspace2File.py')),

-1,

'File with symbol not found in child workspace folder'

);

const symbolsForMeth = await provider.provideWorkspaceSymbols('meth', new CancellationTokenSource().token);

assert.equal(symbolsForMeth.length >= 10, true, 'Incorrect number of symbols returned');

assert.notEqual(

symbolsForMeth.findIndex((sym) => sym.location.uri.fsPath.endsWith('childFile.py')),

-1,

'Symbols not returned for childFile.py'

);

assert.notEqual(

symbolsForMeth.findIndex((sym) => sym.location.uri.fsPath.endsWith('workspace2File.py')),

-1,

'Symbols not returned for workspace2File.py'

);

assert.notEqual(

symbolsForMeth.findIndex((sym) => sym.location.uri.fsPath.endsWith('file.py')),

-1,

'Symbols not returned for file.py'

);

});

});