/*

* Copyright (c) 2006 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description: 

*

*/

package com.nokia.carbide.cpp.epoc.engine.tests.model;

import java.util.HashSet;

import java.util.Set;

import junit.framework.TestCase;

import org.eclipse.core.runtime.CoreException;

import org.eclipse.core.runtime.IPath;

import org.eclipse.core.runtime.Path;

import org.eclipse.jface.text.Document;

import com.nokia.carbide.cpp.epoc.engine.model.IModelProvider;

import com.nokia.carbide.cpp.epoc.engine.model.mmp.IMMPModel;

import com.nokia.carbide.cpp.epoc.engine.model.mmp.IMMPOwnedModel;

import com.nokia.carbide.cpp.epoc.engine.model.mmp.IMMPView;

import com.nokia.carbide.cpp.epoc.engine.model.mmp.IMMPViewConfiguration;

public class ModelProviderThreadTests {

	private static boolean modelThreadFailed;

	class Reader implements Runnable {

		private IPath path;

		private String result;

		private IModelProvider<IMMPOwnedModel, IMMPModel> provider;

		private IMMPViewConfiguration viewConfiguration;

		public Reader(IModelProvider<IMMPOwnedModel, IMMPModel> provider, IMMPViewConfiguration viewConfiguration, IPath path) {

			this.provider = provider;

			this.viewConfiguration = viewConfiguration;

			this.path = path;

		}

		public String getResult() {

			return result;

		}

		/* (non-Javadoc)

		 * @see java.lang.Runnable#run()

		 */

		public void run() {

			while (!modelThreadFailed && modelWritingCount < MAX_ITERATIONS) {

				try {

					doRead();

				} catch (CoreException e) {

					TestCase.fail(e.getMessage());

					return;

				}

				Thread.yield();

				if (Thread.interrupted())

					return;

			}

			// failed, so force early exit

			modelWritingCount = MAX_ITERATIONS;

		}

		/**

		 * 

		 */

		private void doRead() throws CoreException {

			IMMPModel model = provider.getSharedModel(path);

			TestCase.assertNotNull(model);

			try {

				IMMPView view = model.createView(viewConfiguration);

				try {

					if (DUMP) System.out.println(Thread.currentThread().getName()+ "> r");

				} finally {

					view.dispose();

				}

			} finally {

				provider.releaseSharedModel(model);

			}

		}

	}

	final boolean DUMP = false;

	final int MAX_ITERATIONS = 50;

	public static int modelWritingCount;

	synchronized int nextModelWritingCount() {

		return modelWritingCount++;

	}

	class Writer implements Runnable {

		private IPath path;

		private IModelProvider<IMMPOwnedModel, IMMPModel> provider;

		private IMMPViewConfiguration viewConfiguration;

		public Writer(IModelProvider<IMMPOwnedModel, IMMPModel> provider, IMMPViewConfiguration viewConfiguration, IPath path) {

			this.provider = provider;

			this.viewConfiguration = viewConfiguration;

			this.path = path;

		}

		/* (non-Javadoc)

		 * @see java.lang.Runnable#run()

		 */

		public void run() {

			int cnt;

			while (!modelThreadFailed && (cnt = nextModelWritingCount()) < MAX_ITERATIONS) {

				try {

					addSource(cnt);

				} catch (CoreException e) {

					TestCase.fail(e.getMessage());

					return;

				}

				if (Thread.interrupted())

					return;

			}

		}

		/**

		 * 

		 */

		private void addSource(final int count) throws CoreException {

			IMMPModel model = provider.getSharedModel(path);

			TestCase.assertNotNull(model);

			try {

				IMMPView view = model.createView(viewConfiguration);

				try {

					if (DUMP) System.out.println(Thread.currentThread().getName()+ "> w"+count);

					while (!modelThreadFailed) {

						try {

							view.getSources().add(new Path("" + count));

							view.commit();

							break;

						} catch (IllegalStateException e) {

							if (DUMP) System.out.println(Thread.currentThread().getName()+ "> out of sync, trying again");

							view.revert();

						} catch (Throwable t) {

							if (DUMP) System.out.println(Thread.currentThread().getName()+ "> failure while committing");

							t.printStackTrace();

							modelThreadFailed = true;

						}

					}

				} finally {

					view.dispose();

				}

			} finally {

				provider.releaseSharedModel(model);

			}

		}

	}

	/**

	 * Ensure the reader thread got sensible results.

	 * @param result

	 */

	private void validate(String result) {

		if (result.trim().length() == 0)

			return;

		int maxNum = -1;

		Set<Integer> found = new HashSet<Integer>(); 

		String[] nums = result.split("\\s+");

		for (String num : nums) {

			int n = Integer.parseInt(num);

			found.add(n);

			maxNum = Math.max(n, maxNum);

		}

		if (maxNum + 1 != found.size()) {

			TestCase.fail("Invalid model contents: " + result);

		}

	}

	/**

	 * Ensure the models work sanely with threading.

	 * @throws Exception

	 */

	public void testThreading(IModelProvider<IMMPOwnedModel, IMMPModel> provider,

			IMMPViewConfiguration viewConfig,

			IPath mmpPath) throws CoreException {

		// create the initial content

		IMMPOwnedModel ownedModel = provider.createModel(mmpPath);

		ownedModel.setDocument(new Document("// test file\n"));

		provider.registerModel(ownedModel);

		provider.releaseSharedModel(ownedModel);

		final int READER_COUNT = 5;

		final int WRITER_COUNT = 2;

		Reader[] readers = new Reader[READER_COUNT];

		Writer[] writers = new Writer[WRITER_COUNT];

		Thread[] readerThreads = new Thread[READER_COUNT];

		Thread[] writerThreads = new Thread[WRITER_COUNT];

		try {

			for (int i = 0; i < WRITER_COUNT; i++) {

				writers[i] = new Writer(provider, viewConfig, mmpPath);

				writerThreads[i] = new Thread(writers[i]);

				writerThreads[i].start();

			}

			for (int i = 0; i < READER_COUNT; i++) {

				readers[i] = new Reader(provider, viewConfig, mmpPath);

				readerThreads[i] = new Thread(readers[i]);

				readerThreads[i].start();

			}

			while (modelWritingCount < MAX_ITERATIONS) {

				try {

					Thread.sleep(100);

				} catch (InterruptedException e) {

					TestCase.fail();

				}

			}

		} catch (Throwable t) {

			for (int i = 0; i <  WRITER_COUNT; i++) {

				writerThreads[i].interrupt();

			}

			for (int i = 0; i <  READER_COUNT; i++) {

				readerThreads[i].interrupt();

			}

			TestCase.fail(t.toString());

		}

		try {

			for (int i = 0; i <  WRITER_COUNT; i++) {

				writerThreads[i].join();

			}

			for (int i = 0; i <  READER_COUNT; i++) {

				readerThreads[i].join();

			}

		} catch (InterruptedException e) {

			TestCase.fail();

		}

		TestCase.assertFalse(modelThreadFailed);

		// now validate results

		IMMPModel model = provider.getSharedModel(mmpPath);

		TestCase.assertNotNull(model);

		try {

			IMMPView view = model.createView(viewConfig);

			try {

				StringBuilder builder = new StringBuilder();

				for (IPath path : view.getSources()) {

					builder.append(path.lastSegment());

					builder.append(' ');

				}

				// can't actually validate -- we have no idea whether writers'

				// commits have come in order or not, since one writer may have

				// been out-of-sync and had to retry its commit late.

				validate(builder.toString());

			} finally {

				view.dispose();

			}

		} finally {

			provider.releaseSharedModel(model);

		}

	}

}