import java.io.File;
import java.io.FileOutputStream;
import java.nio.channels.FileChannel;
import java.nio.channels.FileLock;
import java.util.logging.Level;
import java.util.logging.Logger;

import org.GNOME.Accessibility.Application;


// TODO: Auto-generated Javadoc
/**
 * The Class AppLock.
 *
 * @see http
 *      ://fresh2l.com/en/blog/2011/01/08/howto-run-only-single-java-application
 *      -instance
 * @author http://fresh2L.com
 * @version 1.0
 */
public class AppLock {

        /**
         * Instantiates a new app lock.
         */
        private AppLock() {
        }

        /** The lock_file. */
        File lock_file = null;

        /** The lock. */
        FileLock lock = null;

        /** The lock_channel. */
        FileChannel lock_channel = null;

        /** The lock_stream. */
        FileOutputStream lock_stream = null;

        /**
         * Instantiates a new app lock.
         *
         * @param key
         *            the key
         * @throws Exception
         *             the exception
         */
        private AppLock(String key) throws Exception {
                String tmp_dir = System.getProperty("java.io.tmpdir");
                if (!tmp_dir.endsWith(System.getProperty("file.separator"))) {
                        tmp_dir += System.getProperty("file.separator");
                }

                // Acquire MD5
                try {
                        java.security.MessageDigest md = java.security.MessageDigest
                                        .getInstance("MD5");
                        md.reset();
                        String hash_text = new java.math.BigInteger(1, md.digest(key
                                        .getBytes())).toString(16);
                        // Как правило нули в начале строки урезаются этот код добавляет
                        // нули обратно
                        while (hash_text.length() < 32) {
                                hash_text = "0" + hash_text;
                        }
                        lock_file = new File(tmp_dir + hash_text + ".app_lock");
                } catch (Exception ex) {
                        System.out.println("AppLock.AppLock() file fail");
                }

                // MD5 acquire fail
                if (lock_file == null) {
                        lock_file = new File(tmp_dir + key + ".app_lock");
                }

                lock_stream = new FileOutputStream(lock_file);

                String f_content = "Java AppLock Object\r\nLocked by key: " + key
                                + "\r\n";
                lock_stream.write(f_content.getBytes());

                lock_channel = lock_stream.getChannel();

                lock = lock_channel.tryLock();

                if (lock == null) {
                        throw new Exception("Can't create Lock");
                }
        }

        /**
         * Release.
         *
         * @throws Throwable
         *             the throwable
         */
        private void release() throws Throwable {
                if (lock.isValid()) {
                        lock.release();
                }
                if (lock_stream != null) {
                        lock_stream.close();
                }
                if (lock_channel.isOpen()) {
                        lock_channel.close();
                }
                if (lock_file.exists()) {
                        lock_file.delete();
                }
        }

        /*
         * (non-Javadoc)
         *
         * @see java.lang.Object#finalize()
         */
        @Override
        protected void finalize() throws Throwable {
                this.release();
                super.finalize();
        }

        /** The instance. */
        private static AppLock instance;

        /**
         * Sets the lock.
         *
         * @param key
         *            the key
         * @return true, if successful
         */
        public static boolean setLock(String key) {
                if (instance != null) {
                        return true;
                }

                try {
                        instance = new AppLock(key);
                } catch (Exception ex) {
                        instance = null;
                        Logger.getLogger(Application.class.getName()).log(Level.SEVERE,
                                        "Broken off Applock", ex);
                        return false;
                }

                Runtime.getRuntime().addShutdownHook(new Thread() {
                        @Override
                        public void run() {
                                AppLock.releaseLock();
                        }
                });
                return true;
        }

        /**
         * Release lock.
         *
         * @throws NoSuchFieldException
         */
        public static void releaseLock() {
                try {
                        if (instance == null) {
                                throw new NoSuchFieldException("INSTATCE IS NULL");
                        }
                        instance.release();
                } catch (Throwable ex) {
                        Logger.getLogger(AppLock.class.getName()).log(Level.SEVERE,
                                        "Fail to release", ex);
                }
        }
}