package jsqlite;

import java.io.*;

/**
 * Internal class implementing java.io.InputStream on
 * SQLite 3.4.0 incremental blob I/O interface.
 */

class BlobR extends InputStream {

    /**
     * Blob instance
     */

    private Blob blob;

    /**
     * Read position, file pointer.
     */

    private int pos;

    /**
     * Contruct InputStream from blob instance.
     */

    BlobR(Blob blob) {
        this.blob = blob;
        this.pos = 0;
    }

    /**
     * Return number of available bytes for reading.
     *
     * @return available input bytes
     */

    public int available() throws IOException {
        int ret = blob.size - pos;
        return (ret < 0) ? 0 : ret;
    }

    /**
     * Mark method; dummy to satisfy InputStream class.
     */

    public void mark(int limit) {
    }

    /**
     * Reset method; dummy to satisfy InputStream class.
     */

    public void reset() throws IOException {
    }

    /**
     * Mark support; not for this class.
     *
     * @return always false
     */

    public boolean markSupported() {
        return false;
    }

    /**
     * Close this blob InputStream.
     */

    public void close() throws IOException {
        blob.close();
        blob = null;
        pos = 0;
    }

    /**
     * Skip over blob data.
     */

    public long skip(long n) throws IOException {
        long ret = pos + n;
        if (ret < 0) {
            ret = 0;
            pos = 0;
        } else if (ret > blob.size) {
            ret = blob.size;
            pos = blob.size;
        } else {
            pos = (int) ret;
        }
        return ret;
    }

    /**
     * Read single byte from blob.
     *
     * @return byte read
     */

    public int read() throws IOException {
        byte b[] = new byte[1];
        int n = blob.read(b, 0, pos, b.length);
        if (n > 0) {
            pos += n;
            return b[0];
        }
        return -1;
    }

    /**
     * Read byte array from blob.
     *
     * @param b byte array to be filled
     * @return number of bytes read
     */

    public int read(byte b[]) throws IOException {
        int n = blob.read(b, 0, pos, b.length);
        if (n > 0) {
            pos += n;
            return n;
        }
        return -1;
    }

    /**
     * Read slice of byte array from blob.
     *
     * @param b   byte array to be filled
     * @param off offset into byte array
     * @param len length to be read
     * @return number of bytes read
     */

    public int read(byte b[], int off, int len) throws IOException {
        if (off + len > b.length) {
            len = b.length - off;
        }
        if (len < 0) {
            return -1;
        }
        if (len == 0) {
            return 0;
        }
        int n = blob.read(b, off, pos, len);
        if (n > 0) {
            pos += n;
            return n;
        }
        return -1;
    }
}

/**
 * Internal class implementing java.io.OutputStream on
 * SQLite 3.4.0 incremental blob I/O interface.
 */

class BlobW extends OutputStream {

    /**
     * Blob instance
     */

    private Blob blob;

    /**
     * Read position, file pointer.
     */

    private int pos;

    /**
     * Contruct OutputStream from blob instance.
     */

    BlobW(Blob blob) {
        this.blob = blob;
        this.pos = 0;
    }

    /**
     * Flush blob; dummy to satisfy OutputStream class.
     */

    public void flush() throws IOException {
    }

    /**
     * Close this blob OutputStream.
     */

    public void close() throws IOException {
        blob.close();
        blob = null;
        pos = 0;
    }

    /**
     * Write blob data.
     *
     * @param v byte to be written at current position.
     */

    public void write(int v) throws IOException {
        byte b[] = new byte[1];
        b[0] = (byte) v;
        pos += blob.write(b, 0, pos, 1);
    }

    /**
     * Write blob data.
     *
     * @param b byte array to be written at current position.
     */

    public void write(byte[] b) throws IOException {
        if (b != null && b.length > 0) {
            pos += blob.write(b, 0, pos, b.length);
        }
    }

    /**
     * Write blob data.
     *
     * @param b   byte array to be written.
     * @param off offset within byte array
     * @param len length of data to be written
     */

    public void write(byte[] b, int off, int len) throws IOException {
        if (b != null) {
            if (off + len > b.length) {
                len = b.length - off;
            }
            if (len <= 0) {
                return;
            }
            pos += blob.write(b, off, pos, len);
        }
    }
}

/**
 * Class to represent SQLite3 3.4.0 incremental blob I/O interface.
 *
 * Note, that all native methods of this class are
 * not synchronized, i.e. it is up to the caller
 * to ensure that only one thread is in these
 * methods at any one time.
 */

public class Blob {

    /**
     * Internal handle for the SQLite3 blob.
     */

    private long handle = 0;

    /**
     * Cached size of blob, setup right after blob
     * has been opened.
     */

    protected int size = 0;

    /**
     * Return InputStream for this blob
     *
     * @return InputStream
     */

    public InputStream getInputStream() {
        return (InputStream) new BlobR(this);
    }

    /**
     * Return OutputStream for this blob
     *
     * @return OutputStream
     */

    public OutputStream getOutputStream() {
        return (OutputStream) new BlobW(this);
    }

    /**
     * Close blob.
     */

    public native void close();

    /**
     * Internal blob write method.
     *
     * @param b   byte array to be written
     * @param off offset into byte array
     * @param pos offset into blob
     * @param len length to be written
     * @return number of bytes written to blob
     */

    native int write(byte[] b, int off, int pos, int len) throws IOException;

    /**
     * Internal blob read method.
     *
     * @param b   byte array to be written
     * @param off offset into byte array
     * @param pos offset into blob
     * @param len length to be written
     * @return number of bytes written to blob
     */

    native int read(byte[] b, int off, int pos, int len) throws IOException;

    /**
     * Destructor for object.
     */

    protected native void finalize();

    /**
     * Internal native initializer.
     */

    private static native void internal_init();

    static {
        internal_init();
    }
}