package freenet.client.async;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.util.Arrays;
import java.util.Random;

import freenet.client.FECCodec;
import freenet.client.InsertException;
import freenet.client.InsertException.InsertExceptionMode;
import freenet.client.async.PersistentJobRunner.CheckpointLock;
import freenet.crypt.ChecksumChecker;
import freenet.crypt.ChecksumFailedException;
import freenet.keys.CHKBlock;
import freenet.keys.CHKEncodeException;
import freenet.keys.ClientCHK;
import freenet.keys.ClientCHKBlock;
import freenet.node.KeysFetchingLocally;
import freenet.node.SendableRequestItem;
import freenet.node.SendableRequestItemKey;
import freenet.support.Logger;
import freenet.support.MemoryLimitedChunk;
import freenet.support.MemoryLimitedJob;
import freenet.support.MemoryLimitedJobRunner;
import freenet.support.api.LockableRandomAccessBuffer.RAFLock;
import freenet.support.io.CountedOutputStream;
import freenet.support.io.NativeThread;
import freenet.support.io.NullOutputStream;
import freenet.support.io.StorageFormatException;

/** A single segment within a splitfile to be inserted. */
public class SplitFileInserterSegmentStorage {
    
    private static volatile boolean logMINOR;
    private static volatile boolean logDEBUG;
    static {
        Logger.registerClass(SplitFileInserterSegmentStorage.class);
    }

    final SplitFileInserterStorage parent;

    final int segNo;
    final int dataBlockCount;
    final int crossCheckBlockCount;
    final int checkBlockCount;
    final int totalBlockCount;
    
    /** Has the segment been encoded? If so, all of the check blocks have been written. */
    private boolean encoded;
    private boolean encoding;

    private final int statusLength;
    /** Length of a single key stored on disk. Includes checksum. */
    private final int keyLength;
    
    // FIXME These are refilled by SplitFileInserterCrossSegmentStorage on construction...
    /** For each cross-segment block, the cross-segment responsible */
    private final SplitFileInserterCrossSegmentStorage[] crossSegmentBlockSegments;
    /** For each cross-segment block, the block number within that cross-segment */
    private final int[] crossSegmentBlockNumbers;
    
    private final boolean[] blocksHaveKeys;
    private int blocksWithKeysCounter;
    
    // These are only used in construction.
    private transient final boolean[] crossDataBlocksAllocated;
    private transient int crossDataBlocksAllocatedCount;
    private transient int crossCheckBlocksAllocatedCount;

    // These are also in parent but we need them here for easy access, especially as we don't want to
    // make the byte[] visible.
    /** For modern splitfiles, the crypto key is the same for every block. */
    private final byte[] splitfileCryptoKey;
    /** Crypto algorithm is the same for every block. */
    private final byte splitfileCryptoAlgorithm;
    
    /** LOCKING: Locked with (this) as needs to access encoded in chooseBlock */
    private final SplitFileInserterSegmentBlockChooser blockChooser;
    private boolean metadataDirty;
    
    /** Set if the insert is cancelled. */
    private boolean cancelled;
    
    public SplitFileInserterSegmentStorage(SplitFileInserterStorage parent, int segNo, 
            boolean persistent, int dataBlocks, int checkBlocks, int crossCheckBlocks, int keyLength,
            byte splitfileCryptoAlgorithm, byte[] splitfileCryptoKey, Random random, int maxRetries,
            int consecutiveRNFsCountAsSuccess, KeysFetchingLocally keysFetching) {
        this.parent = parent;
        this.segNo = segNo;
        this.dataBlockCount = dataBlocks;
        this.checkBlockCount = checkBlocks;
        this.crossCheckBlockCount = crossCheckBlocks;
        totalBlockCount = dataBlockCount + crossCheckBlockCount + checkBlockCount;
        this.keyLength = keyLength;
        crossSegmentBlockSegments = new SplitFileInserterCrossSegmentStorage[crossCheckBlocks];
        crossSegmentBlockNumbers = new int[crossCheckBlocks];
        blocksHaveKeys = new boolean[totalBlockCount];
        this.splitfileCryptoAlgorithm = splitfileCryptoAlgorithm;
        this.splitfileCryptoKey = splitfileCryptoKey;
        crossDataBlocksAllocated = new boolean[dataBlocks + crossCheckBlocks];
        blockChooser = new SplitFileInserterSegmentBlockChooser(this, totalBlockCount, random, 
                maxRetries, keysFetching, consecutiveRNFsCountAsSuccess);
        try {
            CountedOutputStream cos = new CountedOutputStream(new NullOutputStream());
            DataOutputStream dos = new DataOutputStream(cos);
            innerStoreStatus(dos);
            dos.close();
            statusLength = (int) cos.written() + parent.checker.checksumLength();
        } catch (IOException e) {
            throw new Error(e); // Impossible
        }
    }

    /** Create a segment from the fixed settings stored in the RAF by writeFixedSettings(). 
     * @throws IOException 
     * @throws StorageFormatException */
    public SplitFileInserterSegmentStorage(SplitFileInserterStorage parent, DataInputStream dis, 
            int segNo, int keyLength, byte splitfileCryptoAlgorithm, byte[] splitfileCryptoKey, 
            Random random, int maxRetries, int consecutiveRNFsCountAsSuccess, 
            KeysFetchingLocally keysFetching) throws IOException, StorageFormatException {
        this.parent = parent;
        this.segNo = segNo;
        this.keyLength = keyLength;
        dataBlockCount = dis.readInt();
        if(dataBlockCount < 0)
            throw new StorageFormatException("Bogus data block count");
        crossCheckBlockCount = dis.readInt();
        if(crossCheckBlockCount < 0)
            throw new StorageFormatException("Bogus cross-check block count");
        if((crossCheckBlockCount == 0) != (parent.crossSegments == null))
            throw new StorageFormatException("Cross-check block count inconsistent with parent");
        checkBlockCount = dis.readInt();
        if(checkBlockCount < 0)
            throw new StorageFormatException("Bogus check block count");
        totalBlockCount = dataBlockCount + crossCheckBlockCount + checkBlockCount;
        if(totalBlockCount > FECCodec.MAX_TOTAL_BLOCKS_PER_SEGMENT)
            throw new StorageFormatException("Bogus total block count");
        this.statusLength = dis.readInt();
        if(statusLength < 0)
            throw new StorageFormatException("Bogus status length");
        crossSegmentBlockSegments = new SplitFileInserterCrossSegmentStorage[crossCheckBlockCount];
        crossSegmentBlockNumbers = new int[crossCheckBlockCount];
        blocksHaveKeys = new boolean[totalBlockCount];
        this.splitfileCryptoAlgorithm = splitfileCryptoAlgorithm;
        this.splitfileCryptoKey = splitfileCryptoKey;
        crossDataBlocksAllocated = new boolean[dataBlockCount + crossCheckBlockCount];
        blockChooser = new SplitFileInserterSegmentBlockChooser(this, totalBlockCount, random, 
                maxRetries, keysFetching, consecutiveRNFsCountAsSuccess);
        try {
            CountedOutputStream cos = new CountedOutputStream(new NullOutputStream());
            DataOutputStream dos = new DataOutputStream(cos);
            innerStoreStatus(dos);
            dos.close();
            int minStatusLength = (int) cos.written() + parent.checker.checksumLength();
            if(minStatusLength > statusLength)
                throw new StorageFormatException("Bad status length (too short)");
        } catch (IOException e) {
            throw new Error(e); // Impossible
        }
    }
    
    // These two are only used in construction...
    
    /** Allocate a cross-segment data block. Note that this algorithm must be reproduced exactly 
     * for splitfile compatibility; the Random seed is actually determined by the splitfile metadata.
     * @param seg The cross-segment to allocate a block for.
     * @param random PRNG seeded from the splitfile metadata, which determines which blocks to 
     * allocate in a deterministic manner.
     * @return The data block number allocated.
     */
    int allocateCrossDataBlock(SplitFileInserterCrossSegmentStorage seg, Random random) {
        int size = dataBlockCount;
        if(crossDataBlocksAllocatedCount == size) return -1;
        int x = 0;
        for(int i=0;i<10;i++) {
            x = random.nextInt(size);
            if(!crossDataBlocksAllocated[x]) {
                crossDataBlocksAllocated[x] = true;
                crossDataBlocksAllocatedCount++;
                return x;
            }
        }
        for(int i=0;i<size;i++) {
            x++;
            if(x == size) x = 0;
            if(!crossDataBlocksAllocated[x]) {
                crossDataBlocksAllocated[x] = true;
                crossDataBlocksAllocatedCount++;
                return x;
            }
        }
        throw new IllegalStateException("Unable to allocate cross data block even though have not used all slots up???");
    }

    /** Allocate a cross-segment check block. **Note that this algorithm must be reproduced exactly 
     * for splitfile compatibility**; the Random seed is actually determined by the splitfile metadata.
     * @param seg The cross-segment to allocate a block for.
     * @param random PRNG seeded from the splitfile metadata, which determines which blocks to 
     * allocate in a deterministic manner.
     * @param crossSegmentBlockNumber Block number within the cross-segment.
     * @return The block number allocated (between dataBlockCount and dataBlockCount+crossSegmentCheckBlocks).
     */
    int allocateCrossCheckBlock(SplitFileInserterCrossSegmentStorage seg, Random random, int crossSegmentBlockNumber) {
        if(crossCheckBlocksAllocatedCount == crossCheckBlockCount) return -1;
        int x = crossCheckBlockCount - (1 + random.nextInt(crossCheckBlockCount));
        for(int i=0;i<crossCheckBlockCount;i++) {
            x++;
            if(x == crossCheckBlockCount) x = 0;
            if(crossSegmentBlockSegments[x] == null) {
                crossSegmentBlockSegments[x] = seg;
                crossSegmentBlockNumbers[x] = crossSegmentBlockNumber;
                crossCheckBlocksAllocatedCount++;
                return x + dataBlockCount;
            }
        }
        throw new IllegalStateException("Unable to allocate cross check block even though have not used all slots up???");
    }

    public void storeStatus(boolean force) {
        if(!parent.persistent) return;
        if(parent.hasFinished()) return;
        try {
            DataOutputStream dos;
            synchronized(this) {
                if(!force && !metadataDirty) return;
                if(cancelled) return;
                try {
                    dos = new DataOutputStream(parent.writeChecksummedTo(parent.segmentStatusOffset(segNo), statusLength));
                    innerStoreStatus(dos);
                } catch (IOException e) {
                    Logger.error(this, "Impossible: "+e, e);
                    return;
                }
                metadataDirty = false;
            }
            // Outside the lock is safe since if we fail we will fail the whole splitfile.
            dos.close();
        } catch (IOException e) {
            Logger.error(this, "I/O error writing segment status?: "+e, e);
            parent.failOnDiskError(e);
        }
    }

    private void innerStoreStatus(DataOutputStream dos) throws IOException {
        dos.writeInt(segNo); // To make checksum different.
        dos.writeBoolean(encoded);
        blockChooser.write(dos);
    }
    
    public void readStatus() throws IOException, ChecksumFailedException, StorageFormatException {
        byte[] data = new byte[statusLength-parent.checker.checksumLength()];
        parent.preadChecksummed(parent.getOffsetSegmentStatus(segNo), data, 0, data.length);
        DataInputStream dis = new DataInputStream(new ByteArrayInputStream(data));
        if(dis.readInt() != segNo) throw new StorageFormatException("Bad segment number");
        encoded = dis.readBoolean();
        blockChooser.read(dis);
    }

    public long storedStatusLength() {
        return statusLength;
    }

    public void writeFixedSettings(DataOutputStream dos) throws IOException {
        dos.writeInt(dataBlockCount);
        dos.writeInt(crossCheckBlockCount);
        dos.writeInt(checkBlockCount);
        dos.writeInt(statusLength);
    }
    
    static int getKeyLength(SplitFileInserterStorage parent) {
        return encodeKey(1, 1, ClientCHK.TEST_KEY, parent.hasSplitfileKey(), parent.checker, parent).length;
    }
    
    private static byte[] encodeKey(int segNo, int blockNumber, ClientCHK key, 
            boolean hasSplitfileKey, ChecksumChecker checker, SplitFileInserterStorage parent) {
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        DataOutputStream dos = new DataOutputStream(baos);
        try {
            dos.writeInt(segNo);
            dos.writeInt(blockNumber);
            dos.writeByte(1); // 1 = present, 0 = not present
            innerWriteKey(key, dos, hasSplitfileKey);
            dos.close();
        } catch (IOException e) {
            throw new Error(e); // Impossible
        }
        byte[] fullBuf = baos.toByteArray();
        byte[] bufNoKeyNumber = Arrays.copyOfRange(fullBuf, 8, fullBuf.length);
        byte[] ret = checker.appendChecksum(bufNoKeyNumber);
        return ret;
    }
    
    static void innerWriteKey(ClientCHK key, DataOutputStream dos, boolean hasSplitfileKey) throws IOException {
        if(hasSplitfileKey) {
            dos.write(key.getRoutingKey());
        } else {
            key.writeRawBinaryKey(dos);
        }
    }

    void clearKeys() throws IOException {
        // Just write 0's. Not valid.
        // FIXME optimise (write the whole lot at once).
        byte[] buf = new byte[keyLength];
        for(int i=0;i<totalBlockCount;i++) {
            parent.innerWriteSegmentKey(segNo, i, buf);
        }
    }
    
    void setKey(int blockNumber, ClientCHK key) throws IOException {
        if(logMINOR) Logger.minor(this, "Setting key "+key+" for block "+blockNumber+" on "+this, new Exception("debug"));
        try {
            ClientCHK oldKey = readKey(blockNumber);
            if(!oldKey.equals(key))
                throw new IOException("Key for block has changed! Data corruption or bugs in SplitFileInserter code");
        } catch (MissingKeyException e) {
            // Ok.
            writeKey(blockNumber, key);
        }
        // Must be called either way as we don't regenerate blocksHaveKeys on startup.
        setHasKey(blockNumber);
    }
    
    /** Write a key for a block.
     * @param blockNo The block number. Can be a data block, cross segment check block or check
     * block, in that numerical order.
     * @param key The key to write.
     * @throws IOException If we are unable to write the key. */
    void writeKey(int blockNumber, ClientCHK key) throws IOException {
        byte[] buf = encodeKey(segNo, blockNumber, key, parent.hasSplitfileKey(), parent.checker, parent);
        parent.innerWriteSegmentKey(segNo, blockNumber, buf);
    }
    
    /** Set a flag indicating that we have a key. Call parent.onHasKeys if we have all of them.
     * Note that this structure is not persisted! */
    private void setHasKey(int blockNumber) {
        synchronized(this) {
            if(blocksHaveKeys[blockNumber]) return;
            blocksHaveKeys[blockNumber] = true;
            blocksWithKeysCounter++;
            if(blocksWithKeysCounter != totalBlockCount) return;
        }
        parent.onHasKeys(this);
    }
    
    public synchronized boolean hasKeys() {
        return blocksWithKeysCounter == totalBlockCount;
    }

    /** Called on startup to check which keys we actually have. Does nothing unless the segment 
     * claims to have been encoded already. FIXME consider calling this later on for robustness, 
     * but we would then need to re-encode ... */
    public void checkKeys() {
        synchronized(this) {
            if(!encoded) return;
        }
        try {
            for(int i=0;i<totalBlockCount;i++) {
                readKey(i);
            }
        } catch (IOException e) {
            parent.failOnDiskError(e);
            return;
        } catch (MissingKeyException e) {
            // Easy to recover so may as well...
            Logger.error(this, "Missing key even though segment encoded. Recovering by re-encoding...");
            synchronized(this) {
                encoded = false;
            }
            return;
        }
    }

    public int storedKeysLength() {
        return keyLength * totalBlockCount;
    }
    
    public byte[] readDataBlock(int blockNo) throws IOException {
        assert(blockNo >= 0 && blockNo < dataBlockCount);
        return parent.readSegmentDataBlock(segNo, blockNo);
    }
    
    private void writeCheckBlock(int checkBlockNo, byte[] buf) throws IOException {
        parent.writeSegmentCheckBlock(segNo, checkBlockNo, buf);
    }
    
    public byte[] readCheckBlock(int checkBlockNo) throws IOException {
        assert(checkBlockNo >= 0 && checkBlockNo < checkBlockCount);
        return parent.readSegmentCheckBlock(segNo, checkBlockNo);
    }

    public synchronized void startEncode(final short prio) {
        if(encoded) return;
        if(encoding) return;
        encoding = true;
        int totalBlockCount = dataBlockCount + checkBlockCount + crossCheckBlockCount;
        long limit = totalBlockCount * CHKBlock.DATA_LENGTH + 
            Math.max(parent.codec.maxMemoryOverheadDecode(dataBlockCount, crossCheckBlockCount),
                parent.codec.maxMemoryOverheadEncode(dataBlockCount, crossCheckBlockCount));
        if(logMINOR) Logger.minor(this, "Scheduling encode on "+this+" at priority "+prio+
                " blocks "+totalBlockCount+" memory limit "+limit);
        parent.memoryLimitedJobRunner.queueJob(new MemoryLimitedJob(limit) {
            
            @Override
            public int getPriority() {
                return prio;
            }
            
            @Override
            public boolean start(MemoryLimitedChunk chunk) {
                boolean shutdown = false;
                CheckpointLock lock = null;
                try {
                    lock = parent.jobRunner.lock();
                    innerEncode(chunk);
                } catch (PersistenceDisabledException e) {
                    // Will be retried on restarting.
                    shutdown = true;
                } finally {
                    chunk.release();
                    try {
                        if(!shutdown) {
                            // We do want to call the callback even if we threw something, because we 
                            // may be waiting to cancel. However we DON'T call it if we are shutting down.
                            synchronized(SplitFileInserterSegmentStorage.this) {
                                encoding = false;
                            }
                            parent.onFinishedEncoding(SplitFileInserterSegmentStorage.this);
                        }
                    } finally {
                        // Callback is part of the persistent job, unlock *after* calling it.
                        if(lock != null) lock.unlock(false, MemoryLimitedJobRunner.THREAD_PRIORITY);
                    }
                }
                return true;
            }
            
        });
    }

    private void innerEncode(MemoryLimitedChunk chunk) {
        RAFLock lock = null;
        try {
            synchronized(this) {
                if(cancelled) return;
            }
            lock = parent.lockRAF();
            if(logMINOR) Logger.minor(this, "Encoding "+this+" for "+parent);
            byte[][] dataBlocks = readDataAndCrossCheckBlocks();
            generateKeys(dataBlocks, 0);
            byte[][] checkBlocks = new byte[checkBlockCount][];
            for(int i=0;i<checkBlocks.length;i++)
                checkBlocks[i] = new byte[CHKBlock.DATA_LENGTH];
            if(dataBlocks == null || checkBlocks == null) return; // Failed with disk error.
            parent.codec.encode(dataBlocks, checkBlocks, new boolean[checkBlocks.length], CHKBlock.DATA_LENGTH);
            for(int i=0;i<checkBlocks.length;i++)
                writeCheckBlock(i, checkBlocks[i]);
            generateKeys(checkBlocks, dataBlockCount + crossCheckBlockCount);
            synchronized(this) {
                encoded = true;
            }
            if(logMINOR) Logger.minor(this, "Encoded "+this+" for "+parent);
        } catch (IOException e) {
            parent.failOnDiskError(e);
        } catch (Throwable t) {
            Logger.error(this, "Failed: "+t, t);
            parent.fail(new InsertException(InsertExceptionMode.INTERNAL_ERROR, t, null));
        } finally {
            if(lock != null) lock.unlock();
        }
    }

    /** Generate keys for each block and record them. 
     * @throws IOException */
    private void generateKeys(byte[][] dataBlocks, int offset) throws IOException {
        for(int i=0;i<dataBlocks.length;i++) {
            setKey(i + offset, encodeBlock(dataBlocks[i]).getClientKey());
        }
    }

    private byte[][] readDataAndCrossCheckBlocks() throws IOException {
        byte[][] data = new byte[dataBlockCount + crossCheckBlockCount][];
        RAFLock lock = parent.lockUnderlying();
        try {
            for(int i=0;i<dataBlockCount;i++)
                data[i] = readDataBlock(i);
        } finally {
            lock.unlock();
        }
        for(int i=0;i<crossCheckBlockCount;i++)
            data[i+dataBlockCount] = readCrossCheckBlock(i);
        return data;
    }

    private byte[] readCrossCheckBlock(int blockNo) throws IOException {
        return crossSegmentBlockSegments[blockNo].
            readCheckBlock(crossSegmentBlockNumbers[blockNo], segNo, blockNo + dataBlockCount);
    }

    public synchronized boolean isFinishedEncoding() {
        return encoded;
    }

    /** For unit tests. Generally for concurrency purposes we want something that won't change 
     * back, hence e.g. isFinishedEncoding(). */
    synchronized boolean isEncoding() {
        return encoding;
    }

    public ClientCHKBlock encodeBlock(int blockNo) throws IOException {
        if(parent.isFinishing()) {
            throw new IOException("Already finishing reading block "+blockNo+" for "+this+" for "+parent);
        }
        synchronized(this) {
            if(this.blockChooser.hasSucceeded(blockNo)) {
                Logger.error(this, "Already inserted block "+blockNo+" for "+this+" for "+parent);
                throw new IOException("Already inserted block "+blockNo+" for "+this+" for "+parent);
            }
        }
        byte[] buf = readBlock(blockNo);
        return encodeBlock(buf);
    }

    private byte[] readBlock(int blockNo) throws IOException {
        assert(blockNo >= 0 && blockNo < totalBlockCount);
        if(blockNo < dataBlockCount)
            return readDataBlock(blockNo);
        else if(blockNo < dataBlockCount + crossCheckBlockCount)
            return readCrossCheckBlock(blockNo - dataBlockCount);
        else
            return readCheckBlock(blockNo - (dataBlockCount + crossCheckBlockCount));
    }
    
    ClientCHKBlock encodeBlock(byte[] buf) {
        assert (buf.length == CHKBlock.DATA_LENGTH);
        ClientCHKBlock block;
        try {
            block = ClientCHKBlock.encodeSplitfileBlock(buf, splitfileCryptoKey,
                    splitfileCryptoAlgorithm);
        } catch (CHKEncodeException e) {
            throw new Error(e); // Impossible!
        }
        return block;
    }

    private ClientCHK innerReadKey(DataInputStream dis) throws IOException {
        if(splitfileCryptoKey != null) {
            byte[] routingKey = new byte[32];
            dis.readFully(routingKey);
            return new ClientCHK(routingKey, splitfileCryptoKey, false, splitfileCryptoAlgorithm, 
                    (short)-1);
        } else {
            return new ClientCHK(dis);
        }
    }

    ClientCHK readKey(int blockNumber) throws IOException, MissingKeyException {
        byte[] buf = parent.innerReadSegmentKey(segNo, blockNumber);
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        DataOutputStream dos = new DataOutputStream(baos);
        dos.writeInt(segNo);
        dos.writeInt(blockNumber);
        dos.close();
        byte[] prefix = baos.toByteArray();
        byte[] checkBuf = new byte[prefix.length + buf.length];
        System.arraycopy(prefix, 0, checkBuf, 0, prefix.length);
        int checksumLength = parent.checker.checksumLength();
        System.arraycopy(buf, 0, checkBuf, prefix.length, buf.length - checksumLength);
        byte[] checksum = Arrays.copyOfRange(buf, buf.length - checksumLength, buf.length);
        if(parent.checker.checkChecksum(checkBuf, 0, checkBuf.length, checksum))
            throw new MissingKeyException();
        DataInputStream dis = new DataInputStream(new ByteArrayInputStream(buf));
        byte b = dis.readByte();
        if(b != 1) throw new MissingKeyException();
        ClientCHK key = innerReadKey(dis);
        setHasKey(blockNumber);
        if(logDEBUG) Logger.debug(this, "Returning "+key);
        return key;
    }

    public class MissingKeyException extends Exception {
        
    }

    /** Has the segment completed all inserts?
     * Should not change once we reach this state, but might be possible in case of disk errors 
     * causing losing keys etc. */
    public synchronized boolean hasSucceeded() {
        if(cancelled) return false;
        return blockChooser.hasSucceededAll();
    }

    /** Has the segment encoded all check blocks and cross-check blocks? */
    public synchronized boolean hasEncoded() {
        return encoded;
    }
    
    /** Called when a block insert succeeds */
    public void onInsertedBlock(int blockNo, ClientCHK key) {
        try {
            if(parent.hasFinished()) return;
            this.setKey(blockNo, key);
            if(blockChooser.onSuccess(blockNo))
                parent.callback.onInsertedBlock();
            lazyWriteMetadata();
        } catch (IOException e) {
            if(parent.hasFinished()) return; // Race condition possible as this is a callback
            parent.failOnDiskError(e);
        }
    }

    /** Called by BlockChooser when all blocks have been inserted. */
    void onInsertedAllBlocks() {
        if(logMINOR) Logger.minor(this, "Inserted all blocks in segment "+this);
        synchronized(this) {
            if(!encoded) return;
        }
        parent.segmentSucceeded(this);
    }
    
    public void onFailure(int blockNo, InsertException e) {
        if(logMINOR) Logger.minor(this, "Failed block "+blockNo+" with "+e+" for "+this+" for "+parent);
        if(parent.hasFinished()) return; // Race condition possible as this is a callback
        parent.addFailure(e);
        if(e.isFatal()) {
            parent.failFatalErrorInBlock();
        } else {
            if(e.mode == InsertExceptionMode.ROUTE_NOT_FOUND && 
                    blockChooser.consecutiveRNFsCountAsSuccess > 0) {
                try {
                    readKey(blockNo);
                    blockChooser.onRNF(blockNo);
                    parent.clearCooldown();
                    return;
                } catch (MissingKeyException e1) {
                    Logger.error(this, "RNF but no key on block "+blockNo+" on "+this);
                } catch (IOException e1) {
                    if(parent.hasFinished()) return; // Race condition possible as this is a callback
                    parent.failOnDiskError(e1);
                    return;
                }
            } else if(blockChooser.consecutiveRNFsCountAsSuccess > 0) {
                if(blockChooser.pushRNFs(blockNo)) {
                    parent.failTooManyRetriesInBlock();
                    return;
                }
            }
            if(blockChooser.onNonFatalFailure(blockNo)) {
                parent.failTooManyRetriesInBlock();
            } else {
                if(blockChooser.maxRetries >= 0) lazyWriteMetadata();
                parent.clearCooldown();
            }
        }
    }

    private void lazyWriteMetadata() {
        synchronized(this) {
            metadataDirty = true;
        }
        parent.lazyWriteMetadata();
    }

    public synchronized boolean hasCompletedOrFailed() {
        if(encoded) return true; // No more encoding jobs will run.
        if(encoding) return false; // Waiting for job to finish.
        if(cancelled) return true;
        if(blockChooser.hasSucceededAll()) return true;
        return false;
    }

    /** Caller must check hasCompletedOrFailed() explicitly after calling cancel() on all 
     * segments. 
     * @return True if the segment has completed cancellation. False if it is waiting for an 
     * encode, in which case a callback to parent will be made when the encode finishes. */
    public synchronized boolean cancel() {
        if(cancelled) return false;
        cancelled = true;
        if(hasCompletedOrFailed()) return true;
        return false;
    }
    
    public synchronized BlockInsert chooseBlock() {
        int chosenBlock = innerChooseBlock();
        if(chosenBlock == -1) return null;
        return new BlockInsert(this, chosenBlock);
    }
    
    synchronized int innerChooseBlock() {
        if(cancelled) return -1;
        return blockChooser.chooseKey();
    }

    static final class BlockInsert implements SendableRequestItemKey, SendableRequestItem {
        
        final SplitFileInserterSegmentStorage segment;
        final int blockNumber;
        final int hashCode;
        
        BlockInsert(SplitFileInserterSegmentStorage segment, int blockNumber) {
            this.segment = segment;
            this.blockNumber = blockNumber;
            hashCode = computeHashCode();
        }

        private int computeHashCode() {
            final int prime = 31;
            int result = 1;
            result = prime * result + blockNumber;
            result = prime * result + ((segment == null) ? 0 : segment.hashCode());
            return result;
        }

        @Override
        public int hashCode() {
            return hashCode;
        }

        @Override
        public boolean equals(Object obj) {
            if (this == obj)
                return true;
            if (obj == null)
                return false;
            if (!(obj instanceof BlockInsert))
                return false;
            BlockInsert other = (BlockInsert) obj;
            if (blockNumber != other.blockNumber)
                return false;
            return segment == other.segment;
        }

        @Override
        public void dump() {
            // Do nothing. We don't encode in advance.
        }

        @Override
        public SendableRequestItemKey getKey() {
            return this;
        }
        
        public String toString() {
            return "BlockInsert:"+segment+":"+blockNumber+"@memory:"+super.hashCode();
        }
        
    }

    /** Set the cross-segment associated with a cross-check block, which tells us how to read that 
     * block from disk.
     * @param crossSegment The cross-segment.
     * @param segmentBlockNumber The block number within this segment
     * @param crossSegmentBlockNumber The cross-check block number (usually between 0 and 2 inclusive).
     */
    void setCrossCheckBlock(SplitFileInserterCrossSegmentStorage crossSegment,
            int segmentBlockNumber, int crossSegmentBlockNumber) {
        crossSegmentBlockSegments[segmentBlockNumber-dataBlockCount] = crossSegment;
        crossSegmentBlockNumbers[segmentBlockNumber-dataBlockCount] = crossSegmentBlockNumber;
    }

    public int countSendableKeys() {
        return blockChooser.countFetchable();
    }
    
    public String toString() {
        return super.toString()+":"+parent;
    }

}
