package org.codehaus.plexus.util.io;

/*
 * Copyright The Codehaus Foundation.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

import java.io.File;
import java.io.IOException;
import java.io.OutputStream;
import java.nio.Buffer;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.file.Path;
import java.nio.file.StandardOpenOption;
import java.util.Objects;

/**
 * Caching OutputStream to avoid overwriting a file with
 * the same content.
 */
public class CachingOutputStream extends OutputStream {
    private final Path path;
    private FileChannel channel;
    private ByteBuffer readBuffer;
    private ByteBuffer writeBuffer;
    private boolean modified;

    public CachingOutputStream(File path) throws IOException {
        this(Objects.requireNonNull(path).toPath());
    }

    public CachingOutputStream(Path path) throws IOException {
        this(path, 32 * 1024);
    }

    public CachingOutputStream(Path path, int bufferSize) throws IOException {
        this.path = Objects.requireNonNull(path);
        this.channel =
                FileChannel.open(path, StandardOpenOption.READ, StandardOpenOption.WRITE, StandardOpenOption.CREATE);
        this.readBuffer = ByteBuffer.allocate(bufferSize);
        this.writeBuffer = ByteBuffer.allocate(bufferSize);
    }

    @Override
    public void write(int b) throws IOException {
        if (writeBuffer.remaining() < 1) {
            ((Buffer) writeBuffer).flip();
            flushBuffer(writeBuffer);
            ((Buffer) writeBuffer).clear();
        }
        writeBuffer.put((byte) b);
    }

    @Override
    public void write(byte[] b) throws IOException {
        write(b, 0, b.length);
    }

    @Override
    public void write(byte[] b, int off, int len) throws IOException {
        if (writeBuffer.remaining() < len) {
            ((Buffer) writeBuffer).flip();
            flushBuffer(writeBuffer);
            ((Buffer) writeBuffer).clear();
        }
        int capacity = writeBuffer.capacity();
        while (len >= capacity) {
            flushBuffer(ByteBuffer.wrap(b, off, capacity));
            off += capacity;
            len -= capacity;
        }
        if (len > 0) {
            writeBuffer.put(b, off, len);
        }
    }

    @Override
    public void flush() throws IOException {
        ((Buffer) writeBuffer).flip();
        flushBuffer(writeBuffer);
        ((Buffer) writeBuffer).clear();
        super.flush();
    }

    private void flushBuffer(ByteBuffer writeBuffer) throws IOException {
        if (modified) {
            channel.write(writeBuffer);
        } else {
            int len = writeBuffer.remaining();
            ByteBuffer readBuffer;
            if (this.readBuffer.capacity() >= len) {
                readBuffer = this.readBuffer;
                ((Buffer) readBuffer).clear();
                readBuffer.limit(len);
            } else {
                readBuffer = ByteBuffer.allocate(len);
            }
            while (len > 0) {
                int read = channel.read(readBuffer);
                if (read <= 0) {
                    modified = true;
                    channel.position(channel.position() - readBuffer.position());
                    channel.write(writeBuffer);
                    return;
                }
                len -= read;
            }
            ((Buffer) readBuffer).flip();
            if (readBuffer.compareTo(writeBuffer) != 0) {
                modified = true;
                channel.position(channel.position() - readBuffer.remaining());
                channel.write(writeBuffer);
            }
        }
    }

    @Override
    public void close() throws IOException {
        if (channel.isOpen()) {
            flush();
            long position = channel.position();
            if (position != channel.size()) {
                modified = true;
                channel.truncate(position);
            }
            channel.close();
        }
    }

    public boolean isModified() {
        return modified;
    }
}
