/*******************************************************************************
 * Copyright (c) 2010 IBM Corporation
 * 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.ptp.pldt.tests;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.eclipse.cdt.core.model.CoreModel;
import org.eclipse.cdt.core.model.ICElement;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IMarker;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IAdaptable;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.ptp.pldt.mpi.analysis.actions.RunAnalyseMPIAnalysiscommandHandler;

/**
 * 
 * Test MPI Barrier Analysis
 * 
 * Current status of tests: 29 April 2010
 * 
 * testMPI_barriers_tiny():
 * OK, this very trivial test case of two barriers does match, and no error is found
 * 
 * testMPI_barriers_helloBarrier
 * (not working) Barriers are not found to be in the same set, and a barrier error is found when it should not.
 * 
 * testMPI_barriers_error()
 * (not working) does not detect an error, when it should.
 * 
 * Most changes are in org.eclipse.ptp.pldt.mpi.analysis.analysis package
 * most significant changes are in MPIMVAnalaysis.java
 * notation of my initials (BRT) accompany most changes made by me, and notes
 * regarding these problems.
 * See also https://bugs.eclipse.org/bugs/show_bug.cgi?id=306064 Barrier Analysis bug
 * 
 * @author beth
 * 
 */
public class Test_MPI_barriers extends PldtBaseTestFramework {

	public void testMPI_barriers_tiny() throws Exception {
		System.out.println("\n==> " + getMethodName() + "()...");
		int[] expectedMarkerLocn = { 7, 10 };
		BarrierSetBasics bsb = new BarrierSetBasics(2, 2);// 2 sets, 2 members in each
		barrierBase("testMPIbarriersTiny.c", expectedMarkerLocn, bsb);
	}

	public void testMPI_barriers_helloBarrier() throws Exception {
		System.out.println("\n==> " + getMethodName() + "()...");
		int[] expectedMarkerLocn = { 33, 42 };
		BarrierSetBasics bsb = new BarrierSetBasics(2, 2);
		barrierBase("testMPIbarriers.c", expectedMarkerLocn, bsb);
	}

	public void testMPI_barriers_helloBarrierFnCall() throws Exception {
		System.out.println("\n==> " + getMethodName() + "()...");
		int[] expectedMarkerLocn = { 6, 36 };
		BarrierSetBasics bsb = new BarrierSetBasics(2, 2);
		barrierBase("testMPIbarriersFnCall.c", expectedMarkerLocn, bsb);
	}

	public void testMPI_barriers_error() throws Exception {
		System.out.println("\n==> " + getMethodName() + "()...");
		int[] expectedMarkerLocn = { 33 };
		BarrierSetBasics bsb = new BarrierSetBasics(1, 1, true);
		barrierBase("testMPIbarriersErr.c", expectedMarkerLocn, bsb);
	}

	public void barrierBase(String filename, int[] expectedLinenos, BarrierSetBasics bsb) throws Exception {

		IFile file = importFile("resources", filename);
		assertNotNull(file);

		IFile mpiInclude = importFile("resources/includes", "mpi.h");
		assertNotNull(mpiInclude);
		String tempPath = mpiInclude.getFullPath().toOSString();// includePath= /RegressionTestProject/mpi.h
		System.out.println("tempPath=" + tempPath);
		String includePath = mpiInclude.getWorkspace().getRoot().getRawLocation().toOSString()
				+ mpiInclude.getFullPath().toFile().getAbsolutePath();
		System.out.println("includePath= " + includePath);

		assertTrue(file instanceof IAdaptable);

		CoreModel.getDefault().getCModel().makeConsistent(new NullProgressMonitor());// jeff

		assertNotNull(cproject);
		ICElement ce = cproject.findElement(file.getFullPath());

		// ICElement covers folders and translationunits
		// final ICElement ce = (ICElement) ((IAdaptable)file).getAdapter(ICElement.class);
		assertNotNull(ce);
		List<String> includes = Arrays.asList(new String[] { includePath });
		RunAnalyseMPIAnalysiscommandHandler racm = new RunAnalyseMPIAnalysiscommandHandler();

		// racm.runResource(new NullProgressMonitor(), ce, 0, includes);
		// =================================
		IStructuredSelection selection = new StructuredSelection(file);
		final boolean reportErrors = false;
		boolean error = racm.analyseBarriers(selection, reportErrors);
		System.out.println("Barrier error?=" + error + "; expected " + bsb.getError());
		if (bsb.getError()) {
			assertTrue("Expected to find barrier error in " + filename, error);
		}
		else {
			assertFalse("No barrier errors should be found in " + filename, error);
		}

		String barrierMarkerID = org.eclipse.ptp.pldt.mpi.analysis.internal.IDs.barrierMarkerID;

		// =================================
		IMarker[] markers = file.findMarkers(barrierMarkerID, true, IResource.DEPTH_INFINITE);
		int expectedNumber = expectedLinenos.length;
		assertNotNull(expectedNumber + " Barrier Markers should be found", markers);
		System.out.println("numMarkers: " + markers.length + "    number expected: " + expectedNumber);
		assertEquals(expectedNumber + " barrier markers should be found on " + filename, expectedNumber, markers.length);

		// ////////////
		ArtifactWithLine[] expectedArts = new ArtifactWithLine[expectedLinenos.length];
		ArtifactWithLine[] markerArts = new ArtifactWithLine[markers.length];
		for (int i = 0; i < expectedArts.length; i++) {
			expectedArts[i] = new ArtifactWithLine(expectedLinenos[i], "barrier");
		}
		for (int i = 0; i < markerArts.length; i++) {
			markerArts[i] = new ArtifactWithLine(markers[i]);
		}
		Arrays.sort(expectedArts);
		Arrays.sort(markerArts);

		assertEquals(expectedArts.length, markerArts.length);

		// Since these tests are in a loop, if one fails, must inspect the Console output to know which ones finished and which one
		// failed.
		for (int i = 0; i < markers.length; i++) {
			// Marker should be on the line number we expect
			System.out.println(i + ". " + expectedArts[i].getLineNo() + " = " + markerArts[i].getLineNo());
			assertEquals(expectedArts[i].getLineNo(), markerArts[i].getLineNo());
			// /
			// IMarker marker = markers[i];
			// //showMarker(marker);
			// int lineNo=(Integer) marker.getAttribute(IMarker.LINE_NUMBER);
			// System.out.println(i+ " marker: lineNo "+lineNo+
			// " name: "+marker.getAttribute(IDs.NAME)+"   expectedLocn: "+expectedLinenos[i]);
			// assertEquals("expected barrier marker locn",expectedLinenos[i], lineNo);
		}

		barrierSetTest(filename, file, bsb);

	}

	public void barrierSetTest(String filename, IFile file, BarrierSetBasics bsb) throws CoreException {
		IMarker[] markers;
		// Barrier Sets
		final String barrierSetMarkerID = org.eclipse.ptp.pldt.mpi.analysis.internal.IDs.matchingSetMarkerID;
		final String barrierParentID = org.eclipse.ptp.pldt.mpi.analysis.internal.IDs.parentIDAttr;
		final String barrierMyID = org.eclipse.ptp.pldt.mpi.analysis.internal.IDs.myIDAttr;

		markers = file.findMarkers(barrierSetMarkerID, true, IResource.DEPTH_INFINITE);
		// assertNotNull("2 Barrier Markers should be found",markers);

		int[] expectedMarkerLocn2 = { 7, 10, 7, 10, 7, 10 };// actual values are unused? 6 members: 2 parents, two child nodes each?

		int expectedLen = expectedMarkerLocn2.length;
		System.out.println("===============Barrier Sets: numMarkers: " + markers.length + "  expected: " + expectedLen);
		// assertEquals(expectedLen+" barrier markers should be found on "+filename,expectedLen, markers.length);

		// int expectedRoots=2;
		// get parent root markers (parentID=0)
		List<IMarker> setRoots = new ArrayList<IMarker>();
		for (int i = 0; i < markers.length; i++) {
			IMarker marker = markers[i];
			int lineNo = (Integer) marker.getAttribute(IMarker.LINE_NUMBER);

			int parentID = ((Integer) marker.getAttribute(barrierParentID)).intValue();
			if (parentID == 0) {
				setRoots.add(marker);
				System.out.println("found set starting at line " + lineNo);
			}
		}
		System.out.println("num barrier sets found: " + setRoots.size() + "    num expected: " + bsb.getNumSets());
		assertEquals("Number of barrier sets", bsb.getNumSets(), setRoots.size());

		// list what's in each set
		for (Iterator<IMarker> iterator = setRoots.iterator(); iterator.hasNext();) {
			IMarker iMarker = (IMarker) iterator.next();
			int setParentID = ((Integer) iMarker.getAttribute(barrierMyID)).intValue();
			int setParentLineNo = ((Integer) iMarker.getAttribute(IMarker.LINE_NUMBER)).intValue();
			System.out.println("set parentID: " + setParentID + " lineNo: " + setParentLineNo);
			ArrayList<IMarker> barrierSet = new ArrayList<IMarker>();
			for (int i = 0; i < markers.length; i++) {
				IMarker setMemberMarker = markers[i];
				int parentID = ((Integer) setMemberMarker.getAttribute(barrierParentID)).intValue();
				int memberID = ((Integer) setMemberMarker.getAttribute(barrierMyID)).intValue();
				if (parentID == setParentID) {
					int lineNo = (Integer) setMemberMarker.getAttribute(IMarker.LINE_NUMBER);
					System.out.println("  set member: lineNo: " + lineNo + "  parentID: " + parentID + " memberMyID: " + memberID);
					barrierSet.add(setMemberMarker);
				}
			}
			System.out.println("Barrier set with parentID " + setParentID + " expected " + bsb.numInEachSet + " members and found "
					+ barrierSet.size() + " members.");
		}
		// System.out.println("Barrier Sets: expect "+expectedRoots+"; found "+setRoots.size());
		// assertEquals("Expected "+expectedRoots+" barrier set roots", expectedRoots,setRoots.size());
		// // for each set, inspect what we expect in the set
		// for (int i = 0; i < markers.length; i++) {
		// IMarker marker = markers[i];
		// int lineNo=(Integer) marker.getAttribute(IMarker.LINE_NUMBER);
		//
		// int parentID = ((Integer) marker.getAttribute(barrierParentID)).intValue();
		// System.out.println(i+ " marker: lineNo "+lineNo+ " name: "+marker.getAttribute(IDs.NAME)
		// +" parent="+parentID);
		//
		// //assertEquals("expected barrier marker locn",expectedMarkerLocn2[i], lineNo);
		// }
		System.out.println("end barrier set inspection. ");
	}

	String showMarker(IMarker marker) {
		return showMarker(marker, "");
	}

	String showMarker(IMarker marker, String title) {
		StringBuffer buf = new StringBuffer(" ");
		buf.append("Marker: " + title);
		Map map = null;

		try {
			map = marker.getAttributes();
			Set keyset = map.keySet();
			System.out.println("Marker has " + keyset.size() + " values");
			for (Iterator<String> iterator = keyset.iterator(); iterator.hasNext();) {
				String key = (String) iterator.next();
				Object obj = marker.getAttribute(key);
				String value = obj.toString();
				System.out.println("  " + key + ": " + value);
			}
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return "";
	}

	/**
	 * Holds the basic parameters of what we expect to find in a Barrier Set. <br>
	 * Admittedly lightweight for now
	 * 
	 * @author beth
	 * 
	 */
	class BarrierSetBasics {

		int numSets;
		int numInEachSet; // note: all sets don't have to be the same size but in our very simple test cases so far, this is true
		boolean hasError = false;

		BarrierSetBasics(int numSets, int numInEachSet) {
			this.numSets = numSets;
			this.numInEachSet = numInEachSet;

		}

		BarrierSetBasics(int numSets, int numInEachSet, boolean hasError) {
			this(numSets, numInEachSet);
			this.hasError = hasError;

		}

		public int getNumSets() {
			return numSets;
		}

		public int getNumInEachSet() {
			return numInEachSet;
		}

		public boolean getError() {
			return hasError;
		}
	}

}