export function getConfiguredLangId(modelService: IModelService, modeService: IModeService, resource: uri): string | null {
	let configuredLangId: string | null = null;
	if (resource) {
		let modeId: string | null = null;

		// Data URI: check for encoded metadata
		if (resource.scheme === Schemas.data) {
			const metadata = DataUri.parseMetaData(resource);
			const mime = metadata.get(DataUri.META_DATA_MIME);

			if (mime) {
				modeId = modeService.getModeId(mime);
			}
		}

		// Any other URI: check for model if existing
		else {
			const model = modelService.getModel(resource);
			if (model) {
				modeId = model.getLanguageIdentifier().language;
			}
		}

		if (modeId && modeId !== PLAINTEXT_MODE_ID) {
			configuredLangId = modeId; // only take if the mode is specific (aka no just plain text)
		}
	}

	return configuredLangId;
}

	constructor(problemMatchers: ProblemMatcher[], protected markerService: IMarkerService, private modelService: IModelService) {
		this.matchers = Object.create(null);
		this.bufferLength = 1;
		problemMatchers.map(elem => createLineMatcher(elem)).forEach((matcher) => {
			let length = matcher.matchLength;
			if (length > this.bufferLength) {
				this.bufferLength = length;
			}
			let value = this.matchers[length];
			if (!value) {
				value = [];
				this.matchers[length] = value;
			}
			value.push(matcher);
		});
		this.buffer = [];
		this.activeMatcher = null;
		this._numberOfMatches = 0;
		this._maxMarkerSeverity = undefined;
		this.openModels = Object.create(null);
		this.modelListeners = [];
		this.applyToByOwner = new Map<string, ApplyToKind>();
		for (let problemMatcher of problemMatchers) {
			let current = this.applyToByOwner.get(problemMatcher.owner);
			if (current === void 0) {
				this.applyToByOwner.set(problemMatcher.owner, problemMatcher.applyTo);
			} else {
				this.applyToByOwner.set(problemMatcher.owner, this.mergeApplyTo(current, problemMatcher.applyTo));
			}
		}
		this.resourcesToClean = new Map<string, Map<string, URI>>();
		this.markers = new Map<string, Map<string, Map<string, IMarkerData>>>();
		this.deliveredMarkers = new Map<string, Map<string, number>>();
		this.modelService.onModelAdded((model) => {
			this.openModels[model.uri.toString()] = true;
		}, this, this.modelListeners);
		this.modelService.onModelRemoved((model) => {
			delete this.openModels[model.uri.toString()];
		}, this, this.modelListeners);
		this.modelService.getModels().forEach(model => this.openModels[model.uri.toString()] = true);

		this._onDidStateChange = new Emitter();
	}

export function getConfiguredLangId(modelService: IModelService, resource: uri): string | null {
	let configuredLangId: string | null = null;
	if (resource) {
		const model = modelService.getModel(resource);
		if (model) {
			const modeId = model.getLanguageIdentifier().language;
			if (modeId && modeId !== PLAINTEXT_MODE_ID) {
				configuredLangId = modeId; // only take if the mode is specific (aka no just plain text)
			}
		}
	}

	return configuredLangId;
}

export function detectModeId(modelService: IModelService, modeService: IModeService, resource: uri): string | null {
	if (!resource) {
		return null; // we need a resource at least
	}

	let modeId: string | null = null;

	// Data URI: check for encoded metadata
	if (resource.scheme === Schemas.data) {
		const metadata = DataUri.parseMetaData(resource);
		const mime = metadata.get(DataUri.META_DATA_MIME);

		if (mime) {
			modeId = modeService.getModeId(mime);
		}
	}

	// Any other URI: check for model if existing
	else {
		const model = modelService.getModel(resource);
		if (model) {
			modeId = model.getModeId();
		}
	}

	// only take if the mode is specific (aka no just plain text)
	if (modeId && modeId !== PLAINTEXT_MODE_ID) {
		return modeId;
	}

	// otherwise fallback to path based detection
	let path: string | undefined;
	if (resource.scheme === Schemas.data) {
		const metadata = DataUri.parseMetaData(resource);
		path = metadata.get(DataUri.META_DATA_LABEL);
	} else {
		path = resource.path.toLowerCase();
	}

	if (path) {
		return modeService.getModeIdByFilepathOrFirstLine(path);
	}

	return null; // finally - we do not know the mode id
}

	private _setIndentConfiguration(newConfiguration: ITextEditorConfigurationUpdate): void {
		if (newConfiguration.tabSize === 'auto' || newConfiguration.insertSpaces === 'auto') {
			// one of the options was set to 'auto' => detect indentation

			let creationOpts = this._modelService.getCreationOptions(this._model.getLanguageIdentifier().language, this._model.uri, this._model.isForSimpleWidget);
			let insertSpaces = creationOpts.insertSpaces;
			let tabSize = creationOpts.tabSize;

			if (newConfiguration.insertSpaces !== 'auto' && typeof newConfiguration.insertSpaces !== 'undefined') {
				insertSpaces = newConfiguration.insertSpaces;
			}

			if (newConfiguration.tabSize !== 'auto' && typeof newConfiguration.tabSize !== 'undefined') {
				tabSize = newConfiguration.tabSize;
			}

			this._model.detectIndentation(insertSpaces, tabSize);
			return;
		}

		let newOpts: ITextModelUpdateOptions = {};
		if (typeof newConfiguration.insertSpaces !== 'undefined') {
			newOpts.insertSpaces = newConfiguration.insertSpaces;
		}
		if (typeof newConfiguration.tabSize !== 'undefined') {
			newOpts.tabSize = newConfiguration.tabSize;
		}
		this._model.updateOptions(newOpts);
	}

				return editorWorkerService.textualSuggest(resource, position).then((textualSuggestions) => {
					let model = modelService.getModel(resource);
					let result = _addSuggestionsAtPosition(model, position, predefined, textualSuggestions);
					return result;
				});