'use strict';

import * as vscode from 'vscode';
import {CodeLensProvider, TextDocument, CancellationToken, CodeLens, SymbolInformation} from 'vscode';
import * as telemetryContracts from '../../common/telemetryContracts';
import {Tests, TestFile, TestsToRun, TestSuite, TestFunction} from '../common/contracts';
import * as constants from '../../common/constants';
import {getDiscoveredTests} from '../common/testUtils';

interface CodeLensData {
    symbolKind: vscode.SymbolKind;
    symbolName: string;
    fileName: string;
}
interface FunctionsAndSuites {
    functions: TestFunction[];
    suites: TestSuite[];
}

export class TestFileCodeLensProvider implements CodeLensProvider {
    public provideCodeLenses(document: TextDocument, token: CancellationToken): Thenable<CodeLens[]> {
        let testItems = getDiscoveredTests();
        if (!testItems || testItems.testFiles.length === 0 || testItems.testFunctions.length === 0) {
            return Promise.resolve([]);
        }

        let cancelTokenSrc = new vscode.CancellationTokenSource();
        token.onCancellationRequested(() => { cancelTokenSrc.cancel(); });

        // Strop trying to build the code lenses if unable to get a list of
        // symbols in this file afrer x time
        setTimeout(() => {
            if (!cancelTokenSrc.token.isCancellationRequested) {
                cancelTokenSrc.cancel();
            }
        }, constants.Delays.MaxUnitTestCodeLensDelay);

        return getCodeLenses(document.uri, token);
    }

    resolveCodeLens(codeLens: CodeLens, token: CancellationToken): CodeLens | Thenable<CodeLens> {
        codeLens.command = { command: 'python.runtests', title: 'Test' };
        return Promise.resolve(codeLens);
    }
}

function getCodeLenses(documentUri: vscode.Uri, token: vscode.CancellationToken): Thenable<CodeLens[]> {
    const tests = getDiscoveredTests();
    if (!tests) {
        return null;
    }
    const file = tests.testFiles.find(file => file.fullPath === documentUri.fsPath);
    if (!file) {
        return Promise.resolve([]);
    }
    const allFuncsAndSuites = getAllTestSuitesAndFunctionsPerFile(file);

    return vscode.commands.executeCommand('vscode.executeDocumentSymbolProvider', documentUri, token)
        .then((symbols: vscode.SymbolInformation[]) => {
            return symbols.filter(symbol => {
                return symbol.kind === vscode.SymbolKind.Function ||
                    symbol.kind === vscode.SymbolKind.Method ||
                    symbol.kind === vscode.SymbolKind.Class;
            }).map(symbol => {
                // This is bloody crucial, if the start and end columns are the same
                // then vscode goes bonkers when ever you edit a line (start scrolling magically)
                const range = new vscode.Range(symbol.location.range.start,
                    new vscode.Position(symbol.location.range.end.line,
                        symbol.location.range.end.character + 1));

                return getCodeLens(documentUri.fsPath, allFuncsAndSuites,
                    range, symbol.name, symbol.kind);
            }).filter(codeLens => codeLens !== null);
        }, reason => {
            if (token.isCancellationRequested) {
                return [];
            }
            return Promise.reject(reason);
        });
}

// Move all of this rubbis into a separate file // too long
const testParametirizedFunction = /.*\[.*\]/g;

function getCodeLens(fileName: string, allFuncsAndSuites: FunctionsAndSuites,
    range: vscode.Range, symbolName: string, symbolKind: vscode.SymbolKind): vscode.CodeLens {

    switch (symbolKind) {
        case vscode.SymbolKind.Function:
        case vscode.SymbolKind.Method: {
            return getFunctionCodeLens(fileName, allFuncsAndSuites, symbolName, range);
        }
        case vscode.SymbolKind.Class: {
            const cls = allFuncsAndSuites.suites.find(cls => cls.name === symbolName);
            if (!cls) {
                return null;
            }
            return new CodeLens(range, {
                title: constants.Text.CodeLensUnitTest,
                command: constants.Commands.Tests_Run,
                arguments: [<TestsToRun>{ testSuite: [cls] }]
            });
        }
    }

    return null;
}

function getFunctionCodeLens(filePath: string, functionsAndSuites: FunctionsAndSuites,
    symbolName: string, range: vscode.Range): vscode.CodeLens {

    const fn = functionsAndSuites.functions.find(fn => fn.name === symbolName);
    if (fn) {
        return new CodeLens(range, {
            title: constants.Text.CodeLensUnitTest,
            command: constants.Commands.Tests_Run,
            arguments: [<TestsToRun>{ testFunction: [fn] }]
        });
    }

    // Ok, possible we're dealing with parameterized unit tests
    // If we have [ in the name, then this is a parameterized function
    let functions = functionsAndSuites.functions.filter(fn => fn.name.startsWith(symbolName + '[') && fn.name.endsWith(']'));
    if (functions.length === 0) {
        return null;
    }
    if (functions.length === 0) {
        return new CodeLens(range, {
            title: constants.Text.CodeLensUnitTest,
            command: constants.Commands.Tests_Run,
            arguments: [<TestsToRun>{ testFunction: functions }]
        });
    }

    // Find all flattened functions
    return new CodeLens(range, {
        title: constants.Text.CodeLensUnitTest + ' (Multiple)',
        command: constants.Commands.Tests_Picker_UI,
        arguments: [filePath, functions]
    });
}

function getAllTestSuitesAndFunctionsPerFile(testFile: TestFile): FunctionsAndSuites {
    const all = { functions: testFile.functions, suites: [] };
    testFile.suites.forEach(suite => {
        all.suites.push(suite);

        const allChildItems = getAllTestSuitesAndFunctions(suite);
        all.functions.push(...allChildItems.functions);
        all.suites.push(...allChildItems.suites);
    });
    return all;
}
function getAllTestSuitesAndFunctions(testSuite: TestSuite): FunctionsAndSuites {
    const all = { functions: [], suites: [] };
    testSuite.functions.forEach(fn => {
        all.functions.push(fn);
    });
    testSuite.suites.forEach(suite => {
        all.suites.push(suite);

        const allChildItems = getAllTestSuitesAndFunctions(suite);
        all.functions.push(...allChildItems.functions);
        all.suites.push(...allChildItems.suites);
    });
    return all;
}