package ch.claude_martin.enums.proxy;

import static java.util.Objects.requireNonNull;

import java.lang.reflect.Proxy;
import java.util.Collections;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * Allows to make any object thread-safe. This works similar to
 * {@link Collections#synchronizedCollection(java.util.Collection)}. But this
 * uses a proxy, which will synchronize on the object.
 * 
 * <p>
 * The object must implement some interface so that the returned proxy can be
 * used as an implementation of that interface.
 * 
 * <p>
 * Note: This does not make the elements within the object thread-safe. This
 * only works if the object hides all information and no other objects share
 * references to the inner data structures.
 * 
 * @author Claude Martin
 */
public class SynchronizedObject {

	/**
	 * Returns a proxy instance which will synchronize all calls to the object.
	 * 
	 * @param object
	 *          The object which will be used for synchronization and to redirect
	 *          all method invocations.
	 * @param type
	 *          The interface type of the returned proxy. Both the object and the
	 *          proxy will share this interface.
	 * @return A new tread-safe proxy.
	 */
	@SuppressWarnings("unchecked")
	public static <I, T extends I> I synchronize(final T object, final Class<I> type) {
		return (I) Proxy.newProxyInstance(//
		    requireNonNull(object).getClass().getClassLoader(),//
		    new Class[] { requireNonNull(type) },//
		    (proxy, method, args) -> {
			    synchronized (object) {
				    return method.invoke(object, args);
			    }
		    });
	}

	/**
	 * Returns a proxy instance which will synchronize all calls to the object
	 * using a given lock.
	 * 
	 * @param object
	 *          The object which will be used for synchronization and to redirect
	 *          all method invocations.
	 * @param type
	 *          The interface type of the returned proxy. Both the object and the
	 *          proxy will share this interface.
	 * @param lock
	 *          A lock object used to obtain a lock.
	 * @return A new tread-safe proxy.
	 */
	@SuppressWarnings("unchecked")
	public static <I, T extends I> I synchronize(final T object, final Class<I> type, final Lock lock) {
		return (I) Proxy.newProxyInstance(//
		    requireNonNull(object).getClass().getClassLoader(),//
		    new Class[] { requireNonNull(type) },//
		    (proxy, method, args) -> {
			    lock.lock();
			    try {
				    return method.invoke(object, args);
			    } finally {
				    lock.unlock();
			    }
		    });
	}
}

-----------------------------
-----------------------------
(The rest is just for testing)

public final class SynchronizedObjectTest {
	public static void main(final String[] args) throws InterruptedException {
		final ICounter counter = synchronize(new Counter(), ICounter.class);
		final ExecutorService pool = Executors.newCachedThreadPool();
		for (int i = 0; i < 10000; i++)
			pool.execute(() -> counter.increment());
		pool.shutdown();
		pool.awaitTermination(1, TimeUnit.MINUTES);
		System.out.println(counter.get());
	}

	static interface ICounter {
		public int get();

		public void increment();
	}

	static class Counter implements ICounter {
		int i = 0;

		@Override
		public int get() {
			return this.i;
		}

		@Override
		public void increment() {
			this.i++;
		}
	}
}