package vtk;

import java.lang.ref.WeakReference;
import java.lang.reflect.Constructor;
import java.util.HashMap;
import java.util.TreeSet;
import java.util.concurrent.locks.ReentrantLock;

/**
 * Provide a Java thread safe implementation of vtkJavaMemoryManager. This does
 * not make VTK thread safe. This only insure that the change of reference count
 * will never happen in two concurrent thread in the Java world.
 *
 * @see vtkJavaMemoryManager
 * @author sebastien jourdain - sebastien.jourdain@kitware.com
 */
public class vtkJavaMemoryManagerImpl implements vtkJavaMemoryManager {
    private vtkJavaGarbageCollector garbageCollector;
    private ReentrantLock lock;
    private vtkReferenceInformation lastGcResult;
    private HashMap<Long, WeakReference<vtkObjectBase>> objectMap;
    private HashMap<Long, String> objectMapClassName;

    public vtkJavaMemoryManagerImpl() {
        this.lock = new ReentrantLock();
        this.objectMap = new HashMap<Long, WeakReference<vtkObjectBase>>();
        this.objectMapClassName = new HashMap<Long, String>();
        this.garbageCollector = new vtkJavaGarbageCollector();
    }

    // Thread safe
    public vtkObjectBase getJavaObject(Long vtkId) {
        // Check pre-condition
        if (vtkId == null || vtkId.longValue() == 0) {
            throw new RuntimeException("Invalid ID, can not be null or equal to 0.");
        }

        // Check inside the map if the object is already there
        WeakReference<vtkObjectBase> value = objectMap.get(vtkId);
        vtkObjectBase resultObject = (value == null) ? null : value.get();

        // If not, we have to do something
        if (value == null || resultObject == null) {
            try {
                // Make sure no concurrency could happen inside that
                this.lock.lock();

                // Now that we have the lock make sure someone else didn't
                // create the object in between, if so just return the created
                // instance
                value = objectMap.get(vtkId);
                resultObject = (value == null) ? null : value.get();
                if (resultObject != null) {
                    return resultObject;
                }

                // We need to do the work of the gc
                if (value != null && resultObject == null) {
                    this.unRegisterJavaObject(vtkId);
                }

                // No-one did create it, so let's do it
                if (resultObject == null) {
                    try {
                        String className = vtkObjectBase.VTKGetClassNameFromReference(vtkId.longValue());
                        Class c = Class.forName("vtk." + className);
                        Constructor cons = c.getConstructor(new Class[] { long.class });
                        resultObject = (vtkObjectBase) cons.newInstance(new Object[] { vtkId });
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            } finally {
                this.lock.unlock();
            }
        }
        return resultObject;
    }

    // Thread safe
    public void registerJavaObject(Long id, vtkObjectBase obj) {
        try {
            this.lock.lock();
            this.objectMap.put(id, new WeakReference<vtkObjectBase>(obj));
            this.objectMapClassName.put(id, obj.GetClassName());
        } finally {
            this.lock.unlock();
        }
    }

    // Thread safe
    public void unRegisterJavaObject(Long id) {
        try {
            this.lock.lock();
            this.objectMapClassName.remove(id);
            WeakReference<vtkObjectBase> value = this.objectMap.remove(id);

            // Prevent double deletion...
            if (value != null) {
                vtkObjectBase.VTKDeleteReference(id.longValue());
            } else {
                throw new RuntimeException("You try to delete a vtkObject that is not referenced in the Java object Map. You may have call Delete() twice.");
            }
        } finally {
            this.lock.unlock();
        }
    }

    // Thread safe
    public vtkReferenceInformation gc(boolean debug) {
        System.gc();
        try {
            this.lock.lock();
            final vtkReferenceInformation infos = new vtkReferenceInformation(debug);
            for (Long id : new TreeSet<Long>(this.objectMap.keySet())) {
                vtkObjectBase obj = this.objectMap.get(id).get();
                if (obj == null) {
                    infos.addFreeObject(this.objectMapClassName.get(id));
                    this.unRegisterJavaObject(id);
                } else {
                    infos.addKeptObject(this.objectMapClassName.get(id));
                }
            }

            this.lastGcResult = infos;
            return infos;
        } finally {
            this.lock.unlock();
        }
    }

    public vtkJavaGarbageCollector getAutoGarbageCollector() {
        return this.garbageCollector;
    }

    // Thread safe
    public int deleteAll() {
        int size = this.objectMap.size();
        try {
            this.lock.lock();
            for (Long id : new TreeSet<Long>(this.objectMap.keySet())) {
                this.unRegisterJavaObject(id);
            }
        } finally {
            this.lock.unlock();
        }
        return size;
    }

    public int getSize() {
        return objectMap.size();
    }

    public vtkReferenceInformation getLastReferenceInformation() {
        return this.lastGcResult;
    }
}