/* --------------------------------------------------------------------------------------------
 * Copyright (c) Microsoft Corporation. All rights reserved.
 * Licensed under the MIT License. See License.txt in the project root for license information.
 * ------------------------------------------------------------------------------------------ */
'use strict';

import {
IPCMessageReader, IPCMessageWriter,
createConnection, IConnection, TextDocumentSyncKind,
TextDocuments, ITextDocument, Diagnostic, DiagnosticSeverity,
InitializeParams, InitializeResult, TextDocumentIdentifier,
CompletionItem, CompletionItemKind, PublishDiagnosticsParams
} from 'vscode-languageserver';
import * as vscodeLanguageServer from 'vscode-languageserver';
import * as pylinter from './linters/pylint';

// Create a connection for the server. The connection uses 
// stdin / stdout for message passing
let connection: IConnection = createConnection(new IPCMessageReader(process), new IPCMessageWriter(process));
var itHappened = "";
// Create a simple text document manager. The text document manager
// supports full document sync only
let documents: TextDocuments = new TextDocuments();
// Make the text document manager listen on the connection
// for open, change and close text document events
documents.listen(connection);

// After the server has started the client sends an initilize request. The server receives
// in the passed params the rootPath of the workspace plus the client capabilites. 
let workspaceRoot: string;
connection.onInitialize((params): InitializeResult => {
    workspaceRoot = params.rootPath;
    return {
        capabilities: {
            // Tell the client that the server works in FULL text document sync mode
            textDocumentSync: documents.syncKind,
            // Tell the client that the server support code complete
            completionProvider: {
                resolveProvider: true
            }
        }
    }
});
 
// The content of a text document has changed. This event is emitted
// when the text document first opened or when its content has changed.
documents.onDidChangeContent((change) => {
    validateTextDocument(change.document);
});

// The settings interface describe the server relevant settings part
interface Settings {
    python: PythonSettings;
}

// These are the example settings we defined in the client's package.json
// file
interface PythonSettings {
    maxNumberOfProblems: number;
}
var pythonSettings: any = {};
// The settings have changed. Is send on server activation
// as well.
connection.onDidChangeConfiguration((change) => {
    let settings = <Settings>change.settings;
    pythonSettings = settings.python;
    // Revalidate any open text documents
    documents.all().forEach(validateTextDocument);

});

function validateTextDocument(textDocument: ITextDocument): void {
    let diagnostics: Diagnostic[] = [];
    var isWin = /^win/.test(process.platform);
    if (!isWin) {
        return;
    }
    if (!pythonSettings.linting.enabled || (!pythonSettings.linting.pylintEnabled && !pythonSettings.linting.pep8Enabled)) {
        return;
    }

    var pep8Messages = [];
    var pylintMessages = [];
    var pep8Done = false;
    var pylintDone = false;
    if (pythonSettings.linting.pylintEnabled) {
        new pylinter.Linter().run(textDocument, pythonSettings, false).then((d) => {
            pylintDone = true;
            if (pythonSettings.linting.pep8Enabled) {
                d.forEach(d=> d.message = d.message + " (pylint)");
                if (pep8Done) {
                    d.forEach(d=> pep8Messages.push(d));
                    connection.sendDiagnostics({ uri: textDocument.uri, diagnostics: pep8Messages });
                }
                else {
                    pylintMessages = d;
                }
            }
            else {
                connection.sendDiagnostics({ uri: textDocument.uri, diagnostics: d });
            }
        });
    }
    if (pythonSettings.linting.pep8Enabled) {
        new pylinter.Linter().run(textDocument, pythonSettings, false).then((d) => {
            pylintDone = true;
            if (pythonSettings.linting.pylintEnabled) {
                d.forEach(d=> d.message = d.message + " (pep8)");
                if (pylintDone) {
                    d.forEach(d=> pylintMessages.push(d));
                    connection.sendDiagnostics({ uri: textDocument.uri, diagnostics: pylintMessages });
                }
                else {
                    pep8Messages = d;
                }
            }
            else {
                connection.sendDiagnostics({ uri: textDocument.uri, diagnostics: d });
            }
        });
    }
}
// 

connection.onDidChangeWatchedFiles((change) => {
    // Monitored files have change in VSCode
    // connection.console.log('We recevied an file change event');
});

// 
// // This handler provides the initial list of the completion items.
// connection.onCompletion((textDocumentPosition: TextDocumentIdentifier): CompletionItem[] => {
//     // The pass parameter contains the position of the text document in 
//     // which code complete got requested. For the example we ignore this
//     // info and always provide the same completion items.
//     return [];
//     //     {
//     //         label: 'TypeScript',
//     //         kind: CompletionItemKind.Text,
//     //         data: 1
//     //     },
//     //     {
//     //         label: 'JavaScript',
//     //         kind: CompletionItemKind.Text,
//     //         data: 2
//     //     }
//     // ]
// });
// 
// // This handler resolve additional information for the item selected in
// // the completion list.
// connection.onCompletionResolve((item: CompletionItem): CompletionItem => {
//     // if (item.data === 1) {
//     //     item.detail = 'TypeScript details',
//     //         item.documentation = 'TypeScript documentation'
//     // } else if (item.data === 2) {
//     //     item.detail = 'JavaScript details',
//     //         item.documentation = 'JavaScript documentation'
//     // }
//     // return item;
//     return item;
// });

/*
connection.onDidOpenTextDocument((params) => {
	// A text document got opened in VSCode.
	// params.uri uniquely identifies the document. For documents store on disk this is a file URI.
	// params.text the initial full content of the document.
	connection.console.log(`${params.uri} opened.`);
});

connection.onDidChangeTextDocument((params) => {
	// The content of a text document did change in VSCode.
	// params.uri uniquely identifies the document.
	// params.contentChanges describe the content changes to the document.
	connection.console.log(`${params.uri} changed: ${JSON.stringify(params.contentChanges)}`);
});

connection.onDidCloseTextDocument((params) => {
	// A text document got closed in VSCode.
	// params.uri uniquely identifies the document.
	connection.console.log(`${params.uri} closed.`);
});
*/

// Listen on the connection
connection.listen();