/*******************************************************************************
 * Copyright (c) 2015 RCP Vision (http://www.rcp-vision.com) and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 * 
 * Contributors:
 * Lorenzo Bettini - initial API and implementation
 *******************************************************************************/
package org.eclipse.emf.parsley.dsl.tests

import com.google.inject.Inject
import org.eclipse.xtext.testing.InjectWith
import org.eclipse.xtext.testing.XtextRunner
import org.eclipse.xtext.testing.formatter.FormatterTestHelper
import org.junit.Test
import org.junit.runner.RunWith

@RunWith(XtextRunner)
@InjectWith(EmfParsleyDslInjectorProvider)
class EmfParsleyDslFormatterTest extends EmfParsleyDslAbstractTest {

	@Inject extension FormatterTestHelper

	@Test def void testFormatPartSpecification() {
		assertFormatted[
			expectation = '''
				module Foo {
					parts {
						viewpart my.view.tree.part {
							viewname "My Tree View"
							viewclass AbstractSaveableTreeView
							viewcategory My.Category
						}
						viewpart my.view.tree.part2 {
							viewname "My Tree View"
							viewclass AbstractSaveableTreeView
						}
					}
				}
			'''
			toBeFormatted = '''
				module Foo { parts { viewpart 
					my.view.tree.part { viewname  "My Tree View" viewclass  AbstractSaveableTreeView 	viewcategory  My.Category}
					viewpart my.view.tree.part2 { viewname  "My Tree View" viewclass  AbstractSaveableTreeView 	}
					}
				}
			'''
		]
	}

	@Test def void testFieldSpecifications() {
		assertFormatted[
			expectation = '''
import org.eclipse.emf.ecore.resource.Resource
import com.google.inject.Inject

module my.empty {
	tableViewerContentProvider {
		val field = "a field";
		@Inject
		val field2 = "a field";
		var f1 = 0;
		var extension int f2 = 0;
	}
}
			'''
			toBeFormatted = '''
import org.eclipse.emf.ecore.resource.Resource
import com.google.inject.Inject

module my.empty {
	tableViewerContentProvider { 		val field  =  "a field"; @Inject
		val field2 = "a field";  var  f1  =  0 ; var  extension  int  f2  =  0 ;
	}
}
			'''
		]
	}

	@Test def void testExtends() {
		assertFormatted[
			expectation = '''
module my.empty {
	tableViewerContentProvider extends Foo {
	}
}
			'''
			toBeFormatted = '''
module my.empty {
	tableViewerContentProvider  extends  Foo {
	}
}
			'''
		]
	}

	@Test def void testResourceManager() {
		assertFormatted[
			expectation = '''
				import org.eclipse.emf.parsley.examples.library.EXTLibraryFactory

				module my.empty {
					resourceManager {
						val EXTLibraryFactory libraryFactory = EXTLibraryFactory.eINSTANCE;

						initializeResource {
							getContents() += libraryFactory.createLibrary
						}
						saveResource {
							it.save(null)
							return true
						}
					}
				}
			'''
			toBeFormatted = '''
import org.eclipse.emf.parsley.examples.library.EXTLibraryFactory

				module my.empty {
					resourceManager {
						val EXTLibraryFactory libraryFactory = EXTLibraryFactory.eINSTANCE;
						
						initializeResource { 				getContents() += libraryFactory.createLibrary
						}
						saveResource {
							it.save(null)
							return true
						}
					}
				}
			'''
		]
	}

	@Test def void testResourceManagerWithoutSaveResource() {
		assertFormatted[
			expectation = '''
				import org.eclipse.emf.parsley.examples.library.EXTLibraryFactory

				module my.empty {
					resourceManager {
						val EXTLibraryFactory libraryFactory = EXTLibraryFactory.eINSTANCE;

						initializeResource {
							getContents() += libraryFactory.createLibrary
						}
					}
				}
			'''
			toBeFormatted = '''
import org.eclipse.emf.parsley.examples.library.EXTLibraryFactory

				module my.empty {
					resourceManager {
						val EXTLibraryFactory libraryFactory = EXTLibraryFactory.eINSTANCE;
						
						initializeResource { 				getContents() += libraryFactory.createLibrary
						}
					}
				}
			'''
		]
	}

	@Test def void testTableViewerContentProvider() {
		assertFormatted[
			expectation = '''
import org.eclipse.emf.ecore.resource.Resource

module my.empty {
	tableViewerContentProvider {
		val field = "a field";
		elements {
			Resource -> {
				getContents()
			}
		}
	}
}
			'''
			toBeFormatted = '''
import org.eclipse.emf.ecore.resource.Resource

module my.empty {
	tableViewerContentProvider { 		val field  =  "a field";
	elements { 			Resource  ->  { 				getContents()
			}
		}
	}
}
			'''
		]
	}

	@Test def void testTableViewerContentProviderWithoutElements() {
		assertFormatted[
			expectation = '''
import org.eclipse.emf.ecore.resource.Resource

module my.empty {
	tableViewerContentProvider {
		val field = "a field";
	}
}
			'''
			toBeFormatted = '''
import org.eclipse.emf.ecore.resource.Resource

module my.empty {
	tableViewerContentProvider { 		val field  =  "a field";
	}
}
			'''
		]
	}

	@Test def void testViewerContentProvider() {
		assertFormatted[
			expectation = '''
import org.eclipse.emf.ecore.resource.Resource
import org.eclipse.emf.ecore.EObject

module my.empty {
	viewerContentProvider {
		val field = "a field";
		elements {
			Resource -> {
				getContents()
			}
		}
		children {
			Resource -> {
				getContents()
			}
			EObject -> {
				emptyList
			}
		}
	}
}
			'''
			toBeFormatted = '''
import org.eclipse.emf.ecore.resource.Resource
import org.eclipse.emf.ecore.EObject

module my.empty {
	viewerContentProvider { 		val field  =  "a field";
	elements { 			Resource  ->  { 				getContents()
			}
		}
		children { 			Resource  ->  { 				getContents()
			} EObject  ->  { 				emptyList
			}
		}
	}
}
			'''
		]
	}

	@Test def void testConfigurator() {
		assertFormatted[
			expectation = '''
import org.eclipse.emf.parsley.examples.library.EXTLibraryPackage
import org.eclipse.emf.parsley.examples.library.Library
import org.eclipse.emf.parsley.examples.library.Writer
import org.eclipse.emf.common.util.URI

module my.empty {
	configurator {
		val EXTLibraryPackage libraryPackage = EXTLibraryPackage.eINSTANCE;

		resourceURI {
			Library lib -> URI.createFileURI("file:/foo")
			Writer -> null
		}
		eClass {
			Library lib -> libraryPackage.library
			Writer -> libraryPackage.writer
		}
	}
}
			'''
			toBeFormatted = '''
import org.eclipse.emf.parsley.examples.library.EXTLibraryPackage
import org.eclipse.emf.parsley.examples.library.Library
import org.eclipse.emf.parsley.examples.library.Writer
import org.eclipse.emf.common.util.URI

module my.empty {
	
	configurator { 		val EXTLibraryPackage libraryPackage = EXTLibraryPackage.eINSTANCE;
		
		resourceURI { 			Library lib -> URI.createFileURI("file:/foo") 			Writer -> null
		}
	eClass { 			Library lib -> libraryPackage.library 			Writer -> libraryPackage.writer
		}
	}
}
			'''
		]
	}

	@Test def void testMenuBuilder() {
		assertFormatted[
			expectation = '''
import org.eclipse.emf.parsley.examples.library.EXTLibraryFactory
import org.eclipse.emf.parsley.examples.library.Library
import org.eclipse.emf.parsley.examples.library.Writer

module my.empty {
	menuBuilder {
		val EXTLibraryFactory libraryFactory = EXTLibraryFactory.eINSTANCE;

		menus {
			Object -> #[
				actionRedo,
				actionUndo,
				separator,
				actionCopy,
				actionPaste
			]

			Writer -> {
				#[
					actionUndo,
					separator,
					submenu("Submenu1", #[
						actionCopy,
						submenu("Submenu2", #[
							actionCut
						])
					]),
					actionPaste
				]
			}
		}

		emfMenus {
			Library lib -> newArrayList(
				actionAdd(
					"New Writer",
					lib.writers,
					libraryFactory.createWriter => [
						name = "This is a new writer"
					]
				)
			)
			Writer -> #[
				actionAdd(
					"New book",
					books,
					libraryFactory.createBook => [
						title = "New book"
					]
				)
			]
		}
	}
}
			'''
			toBeFormatted = '''
import org.eclipse.emf.parsley.examples.library.EXTLibraryFactory
import org.eclipse.emf.parsley.examples.library.Library
import org.eclipse.emf.parsley.examples.library.Writer

module my.empty {
	
	menuBuilder {
		val EXTLibraryFactory libraryFactory = EXTLibraryFactory.eINSTANCE;
		
		menus {
			Object  ->  #[
				actionRedo,
				actionUndo,
				separator,
				actionCopy,
				actionPaste
			]
			
			Writer -> {
				#[
					actionUndo,
					separator,
					submenu("Submenu1", #[
						actionCopy,
						submenu("Submenu2", #[
							actionCut
						])
					]),
					actionPaste
				]
			}
		}
		
		emfMenus {
			Library lib  ->  newArrayList(
				actionAdd("New Writer", lib.writers, 
					libraryFactory.createWriter => [
						name = "This is a new writer"
					]
				)
			)
			Writer -> #[
				actionAdd("New book", books,
					libraryFactory.createBook => [
						title = "New book"
					]
				)
			]
		}
	}
}
			'''
		]
	}

	@Test def void testControlFactory() {
		assertFormatted[
			expectation = '''
import org.eclipse.emf.parsley.examples.library.Borrower
import org.eclipse.emf.parsley.examples.library.Library
import org.eclipse.emf.parsley.examples.library.Writer

module my.empty {
	formControlFactory {
		control {
			Library : name -> {
			}
			Writer : books -> createLabel(books.map[title].join(", "))
			Writer : name -> {
				createLabel(parent, "")
			} target {
				observeText
			}
			Writer : firstName -> toolkit.createLabel(parent, "") target observeText(SWT::Modify)
			Borrower : firstName -> {
				createText(firstName, SWT::MULTI, SWT::BORDER, SWT::WRAP, SWT::V_SCROLL)
			}
		}
	}
}
			'''
			toBeFormatted = '''
import org.eclipse.emf.parsley.examples.library.Borrower
import org.eclipse.emf.parsley.examples.library.Library
import org.eclipse.emf.parsley.examples.library.Writer

module my.empty {
	formControlFactory {
		control {
			Library : name -> { }
			Writer  :  books -> 
				createLabel(
					books.map[title].join(", "))
			Writer : name -> { createLabel(parent, "") }
				target { observeText }
			Writer : firstName -> 
				toolkit.createLabel(parent, "")
				target observeText(SWT::Modify)
			Borrower : firstName -> {
				createText(firstName, SWT::MULTI, SWT::BORDER,
									SWT::WRAP, SWT::V_SCROLL)
			}
		}
	}
}
			'''
		]
	}

	@Test def void testFeaturesProvider() {
		assertFormatted[
			expectation = '''
import org.eclipse.emf.parsley.examples.library.Library
import org.eclipse.emf.parsley.examples.library.Writer

module my.empty {
	featuresProvider {
		features {
			Library -> name
			Writer -> firstName, lastName, books
		}
	}
}
			'''
			toBeFormatted = '''
import org.eclipse.emf.parsley.examples.library.Library
import org.eclipse.emf.parsley.examples.library.Writer

module my.empty {
	featuresProvider {
		features {
			Library  ->  name
			Writer -> firstName ,  lastName, books
		}
	}
}
			'''
		]
	}

	@Test def void testFeatureCaptionProvider() {
		assertFormatted[
			expectation = '''
import org.eclipse.emf.parsley.examples.library.Library
import org.eclipse.emf.parsley.examples.library.Writer

module my.empty {
	featureCaptionProvider {
		text {
			Library : name -> 'Name'
			Library : books -> 'Books'
			Writer : lastName -> name.toFirstUpper
		}
	}
}
			'''
			toBeFormatted = '''
import org.eclipse.emf.parsley.examples.library.Library
import org.eclipse.emf.parsley.examples.library.Writer

module my.empty {
	featureCaptionProvider {
		text {
			Library:name -> 'Name'
			Library:books  ->  'Books'
			Writer:lastName -> name.toFirstUpper
		}
	}
}
			'''
		]
	}

	@Test def void testCaptionProviderWithLabel() {
		assertFormatted[
			expectation = '''
import org.eclipse.emf.parsley.examples.library.EXTLibraryPackage
import org.eclipse.emf.parsley.examples.library.Library
import org.eclipse.emf.parsley.examples.library.Writer
import org.eclipse.swt.SWT
import org.eclipse.swt.widgets.Label

module my.empty {
	formFeatureCaptionProvider {
		text {
			Library : name -> 'Name' // constant
			Library : books -> 'Books' // constant
			Writer : lastName -> name.toFirstUpper // the implicit param is an EStructuralFeature
		}
		label {
			Library : name -> createLabel(parent, "Name")
			Library : books -> createLabel(parent, EXTLibraryPackage.eINSTANCE.library,
				EXTLibraryPackage.eINSTANCE.library_Books)
			Writer : lastName -> {
				new Label(parent, SWT.NONE) => [ l |
					l.^text = name
				]
			// the implicit param is an EStructuralFeature
			// 'name' comes from EStructuralFeature
			}
		}
	}
}
			'''
			toBeFormatted = '''
import org.eclipse.emf.parsley.examples.library.EXTLibraryPackage
import org.eclipse.emf.parsley.examples.library.Library
import org.eclipse.emf.parsley.examples.library.Writer
import org.eclipse.swt.SWT
import org.eclipse.swt.widgets.Label

module my.empty {
	formFeatureCaptionProvider {
		text {
			Library:name -> 'Name' // constant
			Library:books -> 'Books' // constant
			Writer:lastName -> name.toFirstUpper // the implicit param is an EStructuralFeature
		}
		label {
			Library:name -> createLabel(parent, "Name")
			Library:books -> createLabel(parent, EXTLibraryPackage.eINSTANCE.library, EXTLibraryPackage.eINSTANCE.library_Books)
			Writer:lastName -> {
				new Label(parent, SWT.NONE) => [
					l |
					l.^text = name
				] 
				// the implicit param is an EStructuralFeature
				// 'name' comes from EStructuralFeature
			}
		}
	}
}
			'''
		]
	}

	@Test def void testTableLabelProvider() {
		assertFormatted[
			expectation = '''
import org.eclipse.emf.parsley.examples.library.Book
import org.eclipse.emf.parsley.examples.library.Library
import org.eclipse.emf.parsley.examples.library.Writer
import org.eclipse.swt.graphics.ImageData
import org.eclipse.jface.resource.JFaceResources;
import org.eclipse.swt.SWT;
import org.eclipse.swt.widgets.Display;

module my.empty {
	tableLabelProvider {
		text {
			Library : name -> 'Name' // constant
			Library : books -> 'Books' // constant
			Writer : lastName -> name.toFirstUpper // the implicit param is an EStructuralFeature
		}

		image {
			Book : author -> if (author.name.nullOrEmpty)
				"noname.gif"
			else
				new ImageData("writer.jpeg")
		}

		font {
			Library : name -> JFaceResources.getFontRegistry().getBold(JFaceResources.DEFAULT_FONT)
		}

		foreground {
			Library : books -> Display.getCurrent().getSystemColor(SWT.COLOR_BLUE)
		}

		background {
			Library : address -> Display.getCurrent().getSystemColor(SWT.COLOR_GREEN)
		}

		rowFont {
			Library -> JFaceResources.getFontRegistry().getBold(JFaceResources.DEFAULT_FONT)
		}

		rowForeground {
			Library -> Display.getCurrent().getSystemColor(SWT.COLOR_BLUE)
		}

		rowBackground {
			Library -> Display.getCurrent().getSystemColor(SWT.COLOR_GREEN)
		}
	}
}
			'''
			toBeFormatted = '''
import org.eclipse.emf.parsley.examples.library.Book
import org.eclipse.emf.parsley.examples.library.Library
import org.eclipse.emf.parsley.examples.library.Writer
import org.eclipse.swt.graphics.ImageData
import org.eclipse.jface.resource.JFaceResources;
import org.eclipse.swt.SWT;
import org.eclipse.swt.widgets.Display;

module my.empty {
	tableLabelProvider {
		text {
			Library:name -> 'Name' // constant
			Library:books -> 'Books' // constant
			Writer:lastName -> name.toFirstUpper // the implicit param is an EStructuralFeature
		}
		
				image {
			Book: author -> 
				if (author.name.nullOrEmpty) 
					"noname.gif"
				else
					new ImageData("writer.jpeg")
		}
		
			font {
			Library : name -> JFaceResources.getFontRegistry().getBold(JFaceResources.DEFAULT_FONT)
		}
		
	foreground {
			Library : books -> Display.getCurrent().getSystemColor(SWT.COLOR_BLUE)
		}
		
			background {
			Library : address -> Display.getCurrent().getSystemColor(SWT.COLOR_GREEN)
		}
		
	rowFont {
			Library -> JFaceResources.getFontRegistry().getBold(JFaceResources.DEFAULT_FONT)
		}
		
			rowForeground {
			Library -> Display.getCurrent().getSystemColor(SWT.COLOR_BLUE)
		}
		
	rowBackground {
			Library -> Display.getCurrent().getSystemColor(SWT.COLOR_GREEN)
		}
	}
}
			'''
		]
	}

	@Test def void testLabelProvider() {
		assertFormatted[
			expectation = '''
import org.eclipse.emf.parsley.examples.library.Book
import org.eclipse.emf.parsley.examples.library.BookOnTape
import org.eclipse.emf.parsley.examples.library.Borrower
import org.eclipse.emf.parsley.examples.library.Lendable
import org.eclipse.emf.parsley.examples.library.Library
import org.eclipse.emf.parsley.examples.library.Writer
import org.eclipse.swt.graphics.ImageData
import org.eclipse.jface.resource.JFaceResources;
import org.eclipse.swt.SWT;
import org.eclipse.swt.widgets.Display;

module my.empty {
	labelProvider {
		text {
			Library -> 'foo' // constant
			Writer writer -> writer.getName() // explicit param
			Book -> title // implit 'it' param
			Lendable -> 'copies: ' + copies
			Borrower -> { // complex block
				val buffer = 'borrowed: ' + borrowed.map [ b |
					b.copies
				]
				buffer.toUpperCase
			}
			BookOnTape -> getTitle
		}

		image {
			Library -> 'library.jpeg' // constant
			Writer writer -> if (writer.name.nullOrEmpty)
				"noname.gif"
			else
				new ImageData("writer.jpeg")
		}

		font {
			Library -> JFaceResources.getFontRegistry().getBold(JFaceResources.DEFAULT_FONT)
		}

		foreground {
			Library -> Display.getCurrent().getSystemColor(SWT.COLOR_BLUE)
		}

		background {
			Library -> Display.getCurrent().getSystemColor(SWT.COLOR_GREEN)
		}
	}
}
			'''
			toBeFormatted = '''
import org.eclipse.emf.parsley.examples.library.Book
import org.eclipse.emf.parsley.examples.library.BookOnTape
import org.eclipse.emf.parsley.examples.library.Borrower
import org.eclipse.emf.parsley.examples.library.Lendable
import org.eclipse.emf.parsley.examples.library.Library
import org.eclipse.emf.parsley.examples.library.Writer
import org.eclipse.swt.graphics.ImageData
import org.eclipse.jface.resource.JFaceResources;
import org.eclipse.swt.SWT;
import org.eclipse.swt.widgets.Display;

module my.empty {
	labelProvider {
			text {
				Library -> 'foo' // constant
		Writer writer -> writer.getName() // explicit param
			Book -> title // implit 'it' param
			Lendable -> 'copies: ' + copies
			Borrower -> { // complex block
				val buffer = 'borrowed: ' + borrowed.map [
					b | b.copies
				]
				buffer.toUpperCase
			}
			BookOnTape -> getTitle
		}
		
			image {
			Library -> 'library.jpeg' // constant
		Writer writer -> 
				if (writer.name.nullOrEmpty) 
					"noname.gif"
				else
					new ImageData("writer.jpeg")
		}
		
	font {
			Library -> JFaceResources.getFontRegistry().getBold(JFaceResources.DEFAULT_FONT)
		}
		
			foreground {
			Library -> Display.getCurrent().getSystemColor(SWT.COLOR_BLUE)
		}
		
background {
			Library -> Display.getCurrent().getSystemColor(SWT.COLOR_GREEN)
		}
	}
}
			'''
		]
	}

	@Test def void testBindings() {
		assertFormatted[
			expectation = '''
import org.eclipse.jface.viewers.ILabelProvider
import org.eclipse.jface.viewers.IBaseLabelProvider
import org.eclipse.emf.parsley.ui.provider.ViewerLabelProvider

module my.empty {
	bindings {
		type ILabelProvider -> ViewerLabelProvider
		type IBaseLabelProvider -> ViewerLabelProvider
		provide IBaseLabelProvider -> ViewerLabelProvider
		value IBaseLabelProvider a -> ViewerLabelProvider
	}
}
			'''
			toBeFormatted = '''
import org.eclipse.jface.viewers.ILabelProvider
import org.eclipse.jface.viewers.IBaseLabelProvider
import org.eclipse.emf.parsley.ui.provider.ViewerLabelProvider

module my.empty {
	bindings {
		type  ILabelProvider  ->  ViewerLabelProvider
		type  IBaseLabelProvider -> ViewerLabelProvider
		provide  IBaseLabelProvider  ->  ViewerLabelProvider
		value IBaseLabelProvider  a  ->  ViewerLabelProvider
	}
}
			'''
		]
	}

	@Test def void testProposals() {
		assertFormatted[
			expectation = '''
import org.eclipse.emf.parsley.examples.library.Book
import org.eclipse.emf.parsley.examples.library.Borrower
import org.eclipse.emf.parsley.examples.library.EXTLibraryFactory
import org.eclipse.emf.parsley.examples.library.Library
import org.eclipse.emf.parsley.examples.library.Writer

module my.empty {
	proposals {
		Library : name -> {
			newArrayList('foo', 'bar')
		}
		Writer : books -> {
			books
		} // it.books
		Book : author -> {
			newArrayList(
				EXTLibraryFactory::eINSTANCE.createWriter => [
					name = "Foo"
				],
				EXTLibraryFactory::eINSTANCE.createWriter => [
					name = "Bar"
				]
			)
		}
		Borrower : borrowed -> {
			val p = defaultProposals(feature) => [
				add(EXTLibraryFactory::eINSTANCE.createBook => [
					title = "Fake Book"
				])
			]
			return p
		}
	}
}
			'''
			toBeFormatted = '''
import org.eclipse.emf.parsley.examples.library.Book
import org.eclipse.emf.parsley.examples.library.Borrower
import org.eclipse.emf.parsley.examples.library.EXTLibraryFactory
import org.eclipse.emf.parsley.examples.library.Library
import org.eclipse.emf.parsley.examples.library.Writer

module my.empty {
	proposals {
	Library : name -> { newArrayList('foo', 'bar') }
			Writer : books -> 
			{ books } // it.books
		Book : author -> {
				newArrayList(
				EXTLibraryFactory::eINSTANCE.createWriter => [
					name = "Foo"
				],
				EXTLibraryFactory::eINSTANCE.createWriter => [
					name = "Bar"
				]
			)
		}
	Borrower : borrowed -> {
			val p = defaultProposals(feature) => [
				add(EXTLibraryFactory::eINSTANCE.createBook => [
					title = "Fake Book"
				])
			]
			return p
		}
	}
}
			'''
		]
	}

}