/*******************************************************************************
 * Copyright (c) 2009 IBM Corporation 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:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.wst.html.core.tests.cleanup;

import java.io.IOException;

import junit.extensions.TestSetup;
import junit.framework.Test;
import junit.framework.TestCase;
import junit.framework.TestSuite;

import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.jface.text.IDocument;
import org.eclipse.wst.html.core.internal.cleanup.HTMLCleanupProcessorImpl;
import org.eclipse.wst.html.core.tests.ProjectUtil;
import org.eclipse.wst.sse.core.StructuredModelManager;
import org.eclipse.wst.sse.core.internal.cleanup.AbstractStructuredCleanupProcessor;
import org.eclipse.wst.sse.core.internal.provisional.IStructuredModel;
import org.eclipse.wst.sse.core.utils.StringUtils;

public class TestHTMLCleanupProcessor extends TestCase {
	/**
	 * The name of the project that all of these tests will use
	 */
	private static final String PROJECT_NAME = "TestHTMLCleanupProcessor";
	
	/**
	 * The location of the testing files
	 */
	private static final String PROJECT_FILES = "/testresources/HTMLCleanupProcessor";
	
	/**
	 * The project that all of the tests use
	 */
	private static IProject fProject;
	
	/**
	 * Default constructor
	 */
	public TestHTMLCleanupProcessor() {
		super("Test HTML Cleanup Processor");
	}
	
	/**
	 * Constructor that takes a test name.
	 * 
	 * @param name The name this test run should have.
	 */
	public TestHTMLCleanupProcessor(String name) {
		super(name);
	}
	
	/**
	 * <p>Use this method to add these tests to a larger test suite so set up
	 * and tear down can be performed</p>
	 * 
	 * @return a {@link TestSetup} that will run all of the tests in this class
	 * with set up and tear down.
	 */
	public static Test suite() {
		TestSuite ts = new TestSuite(TestHTMLCleanupProcessor.class);
		return new TestHTMLCleanupProcessorSetup(ts);

	}
	
	/**
	 * <p><b>TEST:</b> collapsing empty tags in an html document</p>
	 */
	public void testCollapseEmptyTagsHTML()throws Exception  {
		HTMLCleanupProcessorImpl cleanupProcessor = getProcessorForForEmptyTagsTest();
		runTest("test1.html", "test1-expected.html", cleanupProcessor);
	}
	
	/**
	 * <p><b>TEST:</b> collapsing empty tags in an xhtml document</p>
	 */
	public void testCollapseEmptyTagsXHTML()throws Exception  {
		HTMLCleanupProcessorImpl cleanupProcessor = getProcessorForForEmptyTagsTest();
		runTest("test2.html", "test2-expected.html", cleanupProcessor);
	}
	
	/**
	 * @return a configured {@link HTMLCleanupProcessorImpl} for testing compressing empty tags
	 */
	private static HTMLCleanupProcessorImpl getProcessorForForEmptyTagsTest() {
		HTMLCleanupProcessorImpl cleanupProcessor = new HTMLCleanupProcessorImpl();
		cleanupProcessor.getCleanupPreferences().setCompressEmptyElementTags(true);
		cleanupProcessor.getCleanupPreferences().setInsertRequiredAttrs(false);
		cleanupProcessor.getCleanupPreferences().setInsertMissingTags(true);
		cleanupProcessor.getCleanupPreferences().setQuoteAttrValues(false);
		cleanupProcessor.getCleanupPreferences().setFormatSource(false);
		cleanupProcessor.getCleanupPreferences().setConvertEOLCodes(false);
		
		return cleanupProcessor;
	}
	
	/**
	 * <p>Runs an {@link AbstractStructuredCleanupProcessor} test</p>
	 * 
	 * @param originalFile file to clean up
	 * @param expectedResultsFile expected results of cleaning up the original file
	 * @param configuredCleanupProcessor the processor to use to do the cleaning
	 * 
	 * @throws Exception tests can throw exceptions now and then
	 */
	private void runTest(String originalFile, String expectedResultsFile,
			AbstractStructuredCleanupProcessor configuredCleanupProcessor) throws Exception {
		
		IStructuredModel model = null;
		IStructuredModel expectedModel = null;
		try {
			model = getModelForEdit(originalFile);
			expectedModel = getModelForEdit(expectedResultsFile);
			
			configuredCleanupProcessor.refreshCleanupPreferences = false;
			configuredCleanupProcessor.cleanupModel(model);
			configuredCleanupProcessor.refreshCleanupPreferences = true;
			
			model.save();
			
			standardizeLineEndings(model.getStructuredDocument());
			standardizeLineEndings(expectedModel.getStructuredDocument());
			
			assertEquals("Clean up results did not match expected results",
					expectedModel.getStructuredDocument().get(),
					model.getStructuredDocument().get());
		} finally {
			if(model != null) {
				model.releaseFromEdit();
			}
			
			if(expectedModel != null) {
				expectedModel.releaseFromEdit();
			}
		}
	}
	
	/**
	 * <p>Given a file name in <code>fProject</code> attempts to get a model
	 * for it, if the file doesn't exist or it can't get the model the test fails.</p>
	 * 
	 * @param filename
	 * @return
	 * @throws CoreException 
	 * @throws IOException 
	 */
	private IStructuredModel getModelForEdit(final String filename) throws IOException, CoreException {
		IFile file = fProject.getFile(filename);
		assertTrue("Test file " + file + " can not be found", file.exists());
		
		IStructuredModel model = StructuredModelManager.getModelManager().getModelForEdit(file);
		assertNotNull("Could not get model for " + file, model);
		
		return model;
	}
	
	
	/**
	 * <p>Line endings can be an issue when running tests on different OSs.
	 * This function standardizes the line endings to use <code>\n</code></p>
	 * 
	 * <p>It will get the text from the given editor, change the line endings,
	 * and then save the editor</p>
	 * 
	 * @param editor standardize the line endings of the text presented in this
	 * editor.
	 */
	private void standardizeLineEndings(IDocument doc) {
		String contents = doc.get();
		contents = StringUtils.replace(contents, "\r\n", "\n");
		contents = StringUtils.replace(contents, "\r", "\n");
		doc.set(contents);
	}
	
	/**
	 * <p>This inner class is used to do set up and tear down before and
	 * after (respectively) all tests in the inclosing class have run.</p>
	 */
	private static class TestHTMLCleanupProcessorSetup extends TestSetup {
		private static final String WTP_AUTOTEST_NONINTERACTIVE = "wtp.autotest.noninteractive";
		private static String previousWTPAutoTestNonInteractivePropValue = null;
		
		/**
		 * Default constructor
		 * 
		 * @param test do setup for the given test
		 */
		public TestHTMLCleanupProcessorSetup(Test test) {
			super(test);
		}

		/**
		 * <p>This is run once before all of the tests</p>
		 * 
		 * @see junit.extensions.TestSetup#setUp()
		 */
		public void setUp() throws Exception {
			fProject = ProjectUtil.createProject(PROJECT_NAME, null, null);
			ProjectUtil.copyBundleEntriesIntoWorkspace(PROJECT_FILES, PROJECT_NAME);
			
			String noninteractive = System.getProperty(WTP_AUTOTEST_NONINTERACTIVE);
			if (noninteractive != null) {
				previousWTPAutoTestNonInteractivePropValue = noninteractive;
			} else {
				previousWTPAutoTestNonInteractivePropValue = "false";
			}
			System.setProperty(WTP_AUTOTEST_NONINTERACTIVE, "true");
		}

		/**
		 * <p>This is run once after all of the tests have been run</p>
		 * 
		 * @see junit.extensions.TestSetup#tearDown()
		 */
		public void tearDown() throws Exception {
			fProject.delete(true, new NullProgressMonitor());
			
			if (previousWTPAutoTestNonInteractivePropValue != null) {
				System.setProperty(WTP_AUTOTEST_NONINTERACTIVE, previousWTPAutoTestNonInteractivePropValue);
			}
		}
	}
}