/*=============================================================================#
 # Copyright (c) 2007, 2019 Stephan Wahlbrink and others.
 # 
 # This program and the accompanying materials are made available under the
 # terms of the Eclipse Public License 2.0 which is available at
 # https://www.eclipse.org/legal/epl-2.0, or the Apache License, Version 2.0
 # which is available at https://www.apache.org/licenses/LICENSE-2.0.
 # 
 # SPDX-License-Identifier: EPL-2.0 OR Apache-2.0
 # 
 # Contributors:
 #     Stephan Wahlbrink <sw@wahlbrink.eu> - initial API and implementation
 #=============================================================================*/

package org.eclipse.statet.redocs.wikitext.r.ui.sourceediting;

import org.eclipse.jface.preference.IPreferenceStore;
import org.eclipse.jface.text.ITextDoubleClickStrategy;
import org.eclipse.jface.text.information.IInformationProvider;
import org.eclipse.jface.text.presentation.PresentationReconciler;
import org.eclipse.jface.text.reconciler.IReconciler;
import org.eclipse.jface.text.reconciler.IReconcilingStrategy;
import org.eclipse.jface.text.rules.DefaultDamagerRepairer;
import org.eclipse.jface.text.rules.ITokenScanner;
import org.eclipse.jface.text.source.ISourceViewer;
import org.eclipse.ui.editors.text.EditorsUI;
import org.eclipse.ui.texteditor.spelling.SpellingReconcileStrategy;
import org.eclipse.ui.texteditor.spelling.SpellingService;

import org.eclipse.statet.jcommons.collections.ImCollections;
import org.eclipse.statet.jcommons.text.core.TextRegion;

import org.eclipse.statet.ecommons.templates.TemplateVariableProcessor;
import org.eclipse.statet.ecommons.text.ICharPairMatcher;
import org.eclipse.statet.ecommons.text.core.sections.IDocContentSections;
import org.eclipse.statet.ecommons.text.core.treepartitioner.TreePartition;
import org.eclipse.statet.ecommons.text.core.treepartitioner.TreePartitionUtils;
import org.eclipse.statet.ecommons.text.ui.presentation.SingleTokenScanner;
import org.eclipse.statet.ecommons.text.ui.settings.TextStyleManager;

import org.eclipse.statet.docmlet.tex.ui.sourceediting.LtxSourceViewerConfiguration;
import org.eclipse.statet.docmlet.wikitext.core.WikitextCoreAccess;
import org.eclipse.statet.docmlet.wikitext.core.source.WikitextDocumentConstants;
import org.eclipse.statet.docmlet.wikitext.ui.sourceediting.WikidocSourceViewerConfiguration;
import org.eclipse.statet.internal.redocs.wikitext.r.RedocsWikitextRPlugin;
import org.eclipse.statet.internal.redocs.wikitext.r.ui.sourceediting.DocRQuickOutlineInformationProvider;
import org.eclipse.statet.internal.redocs.wikitext.r.ui.sourceediting.RChunkTemplateCompletionComputer;
import org.eclipse.statet.ltk.ui.LTKUIPreferences;
import org.eclipse.statet.ltk.ui.sourceediting.EcoReconciler2;
import org.eclipse.statet.ltk.ui.sourceediting.ISourceEditor;
import org.eclipse.statet.ltk.ui.sourceediting.MultiContentSectionSourceViewerConfiguration;
import org.eclipse.statet.ltk.ui.sourceediting.SourceEditor1;
import org.eclipse.statet.ltk.ui.sourceediting.SourceEditorViewer;
import org.eclipse.statet.ltk.ui.sourceediting.assist.ContentAssist;
import org.eclipse.statet.ltk.ui.sourceediting.assist.ContentAssistCategory;
import org.eclipse.statet.ltk.ui.sourceediting.assist.ContentAssistProcessor;
import org.eclipse.statet.ltk.ui.sourceediting.assist.IContentAssistComputer;
import org.eclipse.statet.r.core.IRCoreAccess;
import org.eclipse.statet.r.core.source.IRDocumentConstants;
import org.eclipse.statet.r.core.source.RHeuristicTokenScanner;
import org.eclipse.statet.r.core.source.RPartitionNodeType;
import org.eclipse.statet.r.ui.editors.IRSourceEditor;
import org.eclipse.statet.r.ui.sourceediting.RAutoEditStrategy;
import org.eclipse.statet.r.ui.sourceediting.RSourceViewerConfiguration;
import org.eclipse.statet.r.ui.text.r.IRTextTokens;
import org.eclipse.statet.r.ui.text.r.RDoubleClickStrategy;
import org.eclipse.statet.redocs.wikitext.r.core.source.WikidocRweaveBracketPairMatcher;
import org.eclipse.statet.redocs.wikitext.r.core.source.WikidocRweaveDocumentContentInfo;
import org.eclipse.statet.redocs.wikitext.r.core.source.WikitextRweaveDocumentConstants;
import org.eclipse.statet.redocs.wikitext.r.ui.editors.WikidocRweaveEditor;
import org.eclipse.statet.yaml.ui.sourceediting.YamlSourceViewerConfiguration;


/**
 * Default Configuration for source viewer of Wikitext-R documents.
 */
public class WikidocRweaveSourceViewerConfiguration extends MultiContentSectionSourceViewerConfiguration {
	
	
	private static final String[] CONTENT_TYPES= WikitextRweaveDocumentConstants.WIKIDOC_R_CONTENT_TYPES.toArray(
			new String[WikitextRweaveDocumentConstants.WIKIDOC_R_CONTENT_TYPES.size()]);
	
	
	private static class WikidocConfiguration extends WikidocSourceViewerConfiguration {
		
		public WikidocConfiguration(final IDocContentSections documentContentInfo, final int flags,
				final ISourceEditor editor,
				final WikitextCoreAccess wikitextCoreAccess,
				final IPreferenceStore preferenceStore) {
			super(documentContentInfo, flags, editor, wikitextCoreAccess, preferenceStore);
		}
		
		@Override
		protected void setCoreAccess(final WikitextCoreAccess access) {
			super.setCoreAccess(access);
		}
		
		@Override
		protected TemplateVariableProcessor getTemplateVariableProcessor() {
			return super.getTemplateVariableProcessor();
		}
		
	}
	
	
	private static class RChunkAutoEditStrategy extends RAutoEditStrategy {
		
		public RChunkAutoEditStrategy(final IRCoreAccess coreAccess, final ISourceEditor sourceEditor) {
			super(coreAccess, sourceEditor);
		}
		
		@Override
		protected TextRegion getValidRange(final int offset, final TreePartition partition, final int c) {
			switch (WikidocRweaveDocumentContentInfo.INSTANCE.getTypeByPartition(partition.getType())) {
			case WikidocRweaveDocumentContentInfo.R:
				return TreePartitionUtils.searchNodeUp(partition.getTreeNode(),
						RPartitionNodeType.DEFAULT_ROOT );
			case WikidocRweaveDocumentContentInfo.R_CHUNK_CONTROL:
				switch (c) {
				case '(':
				case '[':
				case '{':
				case '%':
				case '\"':
				case '\'':
					return TreePartitionUtils.searchPartitionRegion(partition,
							WikitextRweaveDocumentConstants.RCHUNK_PARTITION_CONSTRAINT );
				}
				return null;
			default:
				return null;
			}
		}
		
	}
	
	private static class RChunkConfiguration extends RSourceViewerConfiguration {
		
		public RChunkConfiguration(final IDocContentSections documentContentInfo, final int flags,
				final IRSourceEditor sourceEditor,
				final IRCoreAccess coreAccess, final IPreferenceStore preferenceStore) {
			super(documentContentInfo, flags, sourceEditor, coreAccess, preferenceStore, null);
		}
		
		@Override
		protected void setCoreAccess(final IRCoreAccess access) {
			super.setCoreAccess(access);
		}
		
		@Override
		protected TextStyleManager getTextStyles() {
			return super.getTextStyles();
		}
		
		@Override
		protected ITokenScanner getScanner(final String contentType) {
			return super.getScanner(contentType);
		}
		
		@Override
		protected RAutoEditStrategy createRAutoEditStrategy() {
			return new RChunkAutoEditStrategy(getRCoreAccess(), getSourceEditor());
		}
		
	}
	
	
	private final WikidocConfiguration docConfig;
	private final YamlSourceViewerConfiguration yamlConfig;
	private final LtxSourceViewerConfiguration ltxConfig;
	private final RChunkConfiguration rConfig;
	
	private ITextDoubleClickStrategy rDoubleClickStrategy;
	
	
	public WikidocRweaveSourceViewerConfiguration(final int flags) {
		this(flags, null, null, null, null);
	}
	
	public WikidocRweaveSourceViewerConfiguration(final int flags,
			final WikidocRweaveEditor sourceEditor,
			final WikitextCoreAccess wikitextCoreAccess, final IRCoreAccess rCoreAccess,
			final IPreferenceStore preferenceStore) {
		super(WikidocRweaveDocumentContentInfo.INSTANCE, flags, sourceEditor);
		
		this.docConfig= new WikidocConfiguration(WikidocRweaveDocumentContentInfo.INSTANCE, flags,
				sourceEditor,
				wikitextCoreAccess, preferenceStore );
		this.yamlConfig= new YamlSourceViewerConfiguration(WikidocRweaveDocumentContentInfo.INSTANCE, (flags & 0xFF),
				sourceEditor, null, null, null );
		this.ltxConfig= new LtxSourceViewerConfiguration(WikidocRweaveDocumentContentInfo.INSTANCE, (flags & 0xFF),
				sourceEditor, null, null, null );
		this.rConfig= new RChunkConfiguration(WikidocRweaveDocumentContentInfo.INSTANCE, (flags & 0xFF),
				sourceEditor,
				rCoreAccess, preferenceStore );
		
		registerConfig(WikidocRweaveDocumentContentInfo.WIKITEXT, this.docConfig);
		registerConfig(WikidocRweaveDocumentContentInfo.YAML, this.yamlConfig);
		registerConfig(WikidocRweaveDocumentContentInfo.LTX, this.ltxConfig);
		registerConfig(WikidocRweaveDocumentContentInfo.R, this.rConfig);
		
		setup((preferenceStore != null) ? preferenceStore : RedocsWikitextRPlugin.getInstance().getEditorPreferenceStore(),
				LTKUIPreferences.getEditorDecorationPreferences(),
				LTKUIPreferences.getAssistPreferences() );
	}
	
	
	@Override
	protected void initScanners() {
		final TextStyleManager textStyles= this.rConfig.getTextStyles();
		
		addScanner(WikitextRweaveDocumentConstants.RCHUNK_BASE_CONTENT_TYPE,
				new SingleTokenScanner(textStyles, IRTextTokens.UNDEFINED_KEY ));
	}
	
	@Override
	protected ITokenScanner getScanner(final String contentType) {
		if (contentType == WikitextRweaveDocumentConstants.RCHUNK_CONTROL_CONTENT_TYPE) {
			return this.rConfig.getScanner(IRDocumentConstants.R_DEFAULT_CONTENT_TYPE);
		}
		if (contentType == WikitextRweaveDocumentConstants.RCHUNK_COMMENT_CONTENT_TYPE) {
			return this.rConfig.getScanner(IRDocumentConstants.R_COMMENT_CONTENT_TYPE);
		}
		return super.getScanner(contentType);
	}
	
	protected void setCoreAccess(final WikitextCoreAccess wikitextCoreAccess, final IRCoreAccess rCoreAccess) {
		this.docConfig.setCoreAccess(wikitextCoreAccess);
		this.rConfig.setCoreAccess(rCoreAccess);
	}
	
	
	@Override
	public String[] getConfiguredContentTypes(final ISourceViewer sourceViewer) {
		return CONTENT_TYPES;
	}
	
	@Override
	protected void initPresentationReconciler(final PresentationReconciler reconciler) {
		super.initPresentationReconciler(reconciler);
		
		for (final String contentType : WikitextRweaveDocumentConstants.RCHUNK_CONTENT_TYPES) {
			final ITokenScanner scanner= getScanner(contentType);
			if (scanner != null) {
				final DefaultDamagerRepairer dr= new DefaultDamagerRepairer(scanner);
				reconciler.setDamager(dr, contentType);
				reconciler.setRepairer(dr, contentType);
			}
		}
	}
	
	
	@Override
	public ICharPairMatcher createPairMatcher() {
		return new WikidocRweaveBracketPairMatcher();
	}
	
	@Override
	public ITextDoubleClickStrategy getDoubleClickStrategy(final ISourceViewer sourceViewer, final String contentType) {
		switch (WikidocRweaveDocumentContentInfo.INSTANCE.getTypeByPartition(contentType)) {
		case WikidocRweaveDocumentContentInfo.WIKITEXT:
			return this.docConfig.getDoubleClickStrategy(sourceViewer, contentType);
		case WikidocRweaveDocumentContentInfo.R_CHUNK_CONTROL:
		case WikidocRweaveDocumentContentInfo.R:
			if (this.rDoubleClickStrategy == null) {
				final RHeuristicTokenScanner scanner= RHeuristicTokenScanner.create(getDocumentContentInfo());
				this.rDoubleClickStrategy= new RDoubleClickStrategy(scanner,
						WikidocRweaveBracketPairMatcher.createRChunkPairMatcher(scanner) );
			}
			return this.rDoubleClickStrategy;
		default:
			return null;
		}
	}
	
	
	protected IReconcilingStrategy getSpellingStrategy(final ISourceViewer sourceViewer) {
		if (!(this.rConfig.getRCoreAccess().getPrefs().getPreferenceValue(WikitextRweaveEditingSettings.WIKIDOC_SPELLCHECK_ENABLED_PREF)
				&& this.fPreferenceStore.getBoolean(SpellingService.PREFERENCE_SPELLING_ENABLED)) ) {
			return null;
		}
		final SpellingService spellingService= EditorsUI.getSpellingService();
		if (spellingService.getActiveSpellingEngineDescriptor(this.fPreferenceStore) == null) {
			return null;
		}
		return new SpellingReconcileStrategy(sourceViewer, spellingService);
	}
	
	
	@Override
	protected void initContentAssist(final ContentAssist assistant) {
		super.initContentAssist(assistant);
		
		final IContentAssistComputer chunkComputer= new RChunkTemplateCompletionComputer();
		
		final ContentAssistProcessor wikitextProcessor= (ContentAssistProcessor) assistant.getContentAssistProcessor(
				WikitextDocumentConstants.WIKIDOC_DEFAULT_CONTENT_TYPE );
		wikitextProcessor.addCategory(new ContentAssistCategory(
				WikitextDocumentConstants.WIKIDOC_DEFAULT_CONTENT_TYPE,
				ImCollections.newList(chunkComputer) ));
//		wikitextProcessor.setCompletionProposalAutoActivationCharacters(new char[] { '\\', '<' });
		
		final ContentAssistProcessor controlProcessor= new ContentAssistProcessor(assistant,
				WikitextRweaveDocumentConstants.RCHUNK_BASE_CONTENT_TYPE,
				RedocsWikitextRPlugin.getInstance().getWikidocRweaveEditorContentAssistRegistry(),
				getSourceEditor() );
		controlProcessor.addCategory(new ContentAssistCategory(WikitextRweaveDocumentConstants.RCHUNK_BASE_CONTENT_TYPE,
				ImCollections.newList(chunkComputer) ));
		assistant.setContentAssistProcessor(controlProcessor, WikitextRweaveDocumentConstants.RCHUNK_BASE_CONTENT_TYPE);
		assistant.setContentAssistProcessor(controlProcessor, WikitextRweaveDocumentConstants.RCHUNK_CONTROL_CONTENT_TYPE);
	}
	
	
	@Override
	public IReconciler getReconciler(final ISourceViewer sourceViewer) {
		final ISourceEditor editor= getSourceEditor();
		if (!(editor instanceof SourceEditor1)) {
			return null;
		}
		final EcoReconciler2 reconciler= (EcoReconciler2) this.docConfig.getReconciler(sourceViewer);
		if (reconciler != null) {
			final IReconcilingStrategy spellingStrategy= getSpellingStrategy(sourceViewer);
			if (spellingStrategy != null) {
				reconciler.addReconcilingStrategy(spellingStrategy);
			}
		}
		return reconciler;
	}
	
	
	@Override
	protected IInformationProvider getQuickInformationProvider(final ISourceViewer sourceViewer,
			final int operation) {
		final ISourceEditor editor= getSourceEditor();
		if (editor == null) {
			return null;
		}
		switch (operation) {
		case SourceEditorViewer.SHOW_SOURCE_OUTLINE:
			return new DocRQuickOutlineInformationProvider(editor, operation);
		default:
			return null;
		}
	}
	
}