package nextrek.imagecache;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

import nextrek.lib.HTTPHelper;
import nextrek.lib.SIC;
import android.content.Context;
import android.os.Environment;
import android.util.Log;

public class DiskLruCache {

    private DiskLruCacheBase mDiskCache;
    private static final int APP_VERSION = 1;
    private static final int VALUE_COUNT = 1;
    private static final String TAG = "DiskLruImageCache";

    public DiskLruCache(Context context, String uniqueName, int diskCacheSize) {
        try {
            enableDiskCache(context, DISK_CACHE_SDCARD);
            final File diskCacheDir = getDiskCacheDir(context, uniqueName);
            mDiskCache = DiskLruCacheBase.open(diskCacheDir, APP_VERSION, VALUE_COUNT, diskCacheSize);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    private boolean writeToFile(byte[] data, DiskLruCacheBase.Editor editor) throws IOException, FileNotFoundException {
        OutputStream fs = editor.newOutputStream(0);
        // BufferedOutputStream ostream = null;
        try {
            // ostream = new BufferedOutputStream(fs, 8192);
            fs.write(data);
            fs.flush();
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        } finally {
            /*
             * if (ostream != null) {
             * ostream.close();
             * ostream = null;
             * }
             */
            if (fs != null) {
                fs.close();
                fs = null;
            }
        }
    }

    /**
     * Enable caching to the phone's internal storage or SD card.
     * 
     * @param context
     *            the current context
     * @param storageDevice
     *            where to store the cached files, either {@link #DISK_CACHE_INTERNAL} or {@link #DISK_CACHE_SDCARD})
     * @return
     */
    //private static final int DISK_CACHE_INTERNAL = 0;
    private static final int DISK_CACHE_SDCARD = 1;
    private boolean isDiskCacheEnabled = false;
    protected String diskCacheDirectory;

    private boolean enableDiskCache(Context context, final int storageDevice) {
        final Context appContext = context.getApplicationContext();

        String rootDir = null;
        if ((storageDevice == DISK_CACHE_SDCARD) && Environment.MEDIA_MOUNTED.equals(Environment.getExternalStorageState())) {
            // SD-card available
            rootDir = Environment.getExternalStorageDirectory().getAbsolutePath() + "/Android/data/" + appContext.getPackageName() + "/cache";
        } else {
            final File internalCacheDir = appContext.getCacheDir();
            // apparently on some configurations this can come back as null
            if (internalCacheDir == null) {
                return (isDiskCacheEnabled = false);
            }
            rootDir = internalCacheDir.getAbsolutePath();
        }

        this.diskCacheDirectory = rootDir;

        final File outFile = new File(diskCacheDirectory);
        if (outFile.mkdirs()) {
            final File nomedia = new File(diskCacheDirectory, ".nomedia");
            try {
                nomedia.createNewFile();
            } catch (final IOException e) {
                Log.e(TAG, "Failed creating .nomedia file");
            }
        }

        isDiskCacheEnabled = outFile.exists();

        if (!isDiskCacheEnabled) {
            if (SIC.DEBUG)
                Log.w(TAG, "Failed creating disk cache directory " + diskCacheDirectory);
        } else {
            if (SIC.DEBUG)
                Log.d(TAG, "enabled write through to " + diskCacheDirectory);
        }

        return isDiskCacheEnabled;
    }

    private File getDiskCacheDir(Context context, String uniqueName) {
        return new File(this.diskCacheDirectory + File.separator + uniqueName);
    }
    
    public String getTempDir() {
        return this.diskCacheDirectory;
    }

    public void put(String key, byte[] data) {

        DiskLruCacheBase.Editor editor = null;
        try {
            editor = mDiskCache.edit(key);
            if (editor == null) {
                return;
            }

            if (writeToFile(data, editor)) {
                mDiskCache.flush();
                editor.commit();
                if (SIC.DEBUG)
                    Log.d(TAG, "put " + key);
            } else {
                editor.abort();
                Log.e(TAG, "ERROR on: image put on disk cache " + key);
            }
        } catch (IOException e) {
            Log.e(TAG, "ERROR on: image put on disk cache " + key);

            try {
                if (editor != null) {
                    editor.abort();
                }
            } catch (IOException ignored) {
            }
        } finally {
            editor = null;
        }

    }

    public byte[] get(String key) {

        DiskLruCacheBase.Snapshot snapshot = null;
        try {

            snapshot = mDiskCache.get(key);
            if (snapshot == null) {
                return null;
            }

            InputStream in = snapshot.getInputStream(0);
            if (in != null) {
                try {
                    if (SIC.DEBUG)
                        Log.d(TAG, "get " + key);
                    return HTTPHelper.toByteArray(in);
                } finally {
                    in.close();
                    in = null;
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (snapshot != null) {
                snapshot.close();
            }
        }

        return null;
    }

    public void close() {
        try {
            mDiskCache.close();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    public void flush() {
        try {
            mDiskCache.flush();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    public boolean containsKey(String key) {

        boolean contained = false;
        DiskLruCacheBase.Snapshot snapshot = null;
        try {
            snapshot = mDiskCache.get(key);
            contained = snapshot != null;
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (snapshot != null) {
                snapshot.close();
                snapshot = null;
            }
        }

        return contained;

    }

    public void clearCache() {
        if (SIC.DEBUG)
            Log.d(TAG, "disk cache CLEARED");

        try {
            mDiskCache.delete();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public File getCacheFolder() {
        return mDiskCache.getDirectory();
    }

}