package eu.siacs.conversations.utils.zlib;

import java.io.IOException;
import java.io.OutputStream;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.security.NoSuchAlgorithmException;
import java.util.zip.Deflater;
import java.util.zip.DeflaterOutputStream;

/**
 * <p>Android 2.2 includes Java7 FLUSH_SYNC option, which will be used by this
 * Implementation, preferable via reflection. The @hide was remove in API level
 * 19. This class might thus go away in the future.</p>
 * <p>Please use {@link ZLibOutputStream#SUPPORTED} to check for flush
 * compatibility.</p> 
 */
public class ZLibOutputStream extends DeflaterOutputStream {

    /**
     * The reflection based flush method.
     */

    private final static Method method;
    /**
     * SUPPORTED is true if a flush compatible method exists.
     */
    public final static boolean SUPPORTED;

    /**
     * Static block to initialize {@link #SUPPORTED} and {@link #method}.
     */
    static {
        Method m = null;
        try {
            m = Deflater.class.getMethod("deflate", byte[].class, int.class, int.class, int.class);
        } catch (SecurityException e) {
        } catch (NoSuchMethodException e) {
        }
        method = m;
        SUPPORTED = (method != null);
    }

    /**
     * Create a new ZLib compatible output stream wrapping the given low level
     * stream. ZLib compatiblity means we will send a zlib header. 
     * @param os OutputStream The underlying stream.
     * @throws IOException In case of a lowlevel transfer problem.
     * @throws NoSuchAlgorithmException In case of a {@link Deflater} error.
     */
    public ZLibOutputStream(OutputStream os) throws IOException,
            NoSuchAlgorithmException {
        super(os, new Deflater(Deflater.BEST_COMPRESSION));
    }

    /**
     * Flush the given stream, preferring Java7 FLUSH_SYNC if available.
     * @throws IOException In case of a lowlevel exception.
     */
    @Override
    public void flush() throws IOException {
        if (!SUPPORTED) {
            super.flush();
            return;
        }
        try {
	    int count = 0;
            do {
                count = (Integer) method.invoke(def, buf, 0, buf.length, 3);
		if (count > 0) {
                    out.write(buf, 0, count);
		}
            } while (count > 0);
        } catch (IllegalArgumentException e) {
            throw new IOException("Can't flush");
        } catch (IllegalAccessException e) {
            throw new IOException("Can't flush");
        } catch (InvocationTargetException e) {
            throw new IOException("Can't flush");
        }
        super.flush();
    }

}