/*
 * $Id$
 *
 * Copyright (C) 2003-2015 JNode.org
 *
 * This library is free software; you can redistribute it and/or modify it
 * under the terms of the GNU Lesser General Public License as published
 * by the Free Software Foundation; either version 2.1 of the License, or
 * (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful, but 
 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
 * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public 
 * License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this library; If not, write to the Free Software Foundation, Inc., 
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */
 
package org.jnode.shell.proclet;

import java.io.IOException;
import java.io.OutputStream;
import java.io.PrintStream;
import java.util.Formatter;
import java.util.Locale;

import org.jnode.util.ProxyStream;
import org.jnode.shell.io.NullOutputStream;

/**
 * This class provides some infrastructure for PrintStream proxies.
 * 
 * @author crawley@jnode.org
 */
public abstract class AbstractProxyPrintStream extends PrintStream implements
        ProxyStream<PrintStream> {
    /*
     * Note: the implementation is mostly copied from PrintStream. Blame this on
     * limitations of the afore-mentioned class's specification ...
     */
    private static PrintStream nullStream;

    private boolean error_occurred = false;

    public AbstractProxyPrintStream() {
        super(new NullOutputStream());
    }

    public boolean checkError() {
        flush();
        return error_occurred || effectiveOutput().checkError();
    }

    protected void setError() {
        error_occurred = true;
    }

    protected void clearError() {
        error_occurred = false;
    }

    protected abstract PrintStream effectiveOutput();

    public void close() {
        PrintStream eo = effectiveOutput();
        eo.flush();
        eo.close();
    }

    public void flush() {
        effectiveOutput().flush();
    }

    protected synchronized void print(String str, boolean println) {
        PrintStream eo = effectiveOutput();
        writeChars(eo, str, 0, str.length());
        if (println) {
            eo.println();
        }
        flush();
    }

    protected synchronized void print(char[] chars, int pos, int len,
            boolean println) {
        PrintStream eo = effectiveOutput();
        writeChars(eo, chars, pos, len);
        if (println) {
            eo.println();
        }
        flush();
    }

    protected void writeChars(PrintStream eo, char[] buf, int offset, int count) {
        // This is inefficient, but it ensures that we use the encoding
        // scheme of the effective stream
        eo.print(new String(buf, offset, count));
    }

    protected void writeChars(PrintStream eo, String str, int offset, int count) {
        // This is inefficient, but it ensures that we use the encoding
        // scheme of the effective stream
        eo.print(str.substring(offset, offset + count));
    }

    public void print(boolean bool) {
        print(String.valueOf(bool), false);
    }

    public void print(int inum) {
        print(String.valueOf(inum), false);
    }

    public void print(long lnum) {
        print(String.valueOf(lnum), false);
    }

    public void print(float fnum) {
        print(String.valueOf(fnum), false);
    }

    public void print(double dnum) {
        print(String.valueOf(dnum), false);
    }

    public void print(Object obj) {
        print(obj == null ? "null" : obj.toString(), false);
    }

    public void print(String str) {
        print(str == null ? "null" : str, false);
    }

    public synchronized void print(char ch) {
        print(new char[] {ch}, 0, 1, false);
    }

    public void print(char[] charArray) {
        print(charArray, 0, charArray.length, false);
    }

    public void println() {
        effectiveOutput().println();
    }

    public void println(boolean bool) {
        print(String.valueOf(bool), true);
    }

    public void println(int inum) {
        print(String.valueOf(inum), true);
    }

    public void println(long lnum) {
        print(String.valueOf(lnum), true);
    }

    public void println(float fnum) {
        print(String.valueOf(fnum), true);
    }

    public void println(double dnum) {
        print(String.valueOf(dnum), true);
    }

    public void println(Object obj) {
        print(obj == null ? "null" : obj.toString(), true);
    }

    public void println(String str) {
        print(str == null ? "null" : str, true);
    }

    public synchronized void println(char ch) {
        print(new char[] {ch}, 0, 1, true);
    }

    public void println(char[] charArray) {
        print(charArray, 0, charArray.length, true);
    }

    public void write(int oneByte) {
        effectiveOutput().write(oneByte & 0xff);
        if (oneByte == '\n') {
            flush();
        }
    }

    public void write(byte[] buffer, int offset, int len) {
        effectiveOutput().write(buffer, offset, len);
        flush();
    }

    public PrintStream append(char c) {
        print(c);
        return this;
    }

    public PrintStream append(CharSequence cs) {
        print(cs == null ? "null" : cs.toString());
        return this;
    }

    public PrintStream append(CharSequence cs, int start, int end) {
        print(cs == null ? "null" : cs.subSequence(start, end).toString());
        return this;
    }

    public PrintStream printf(String format, Object... args) {
        return format(format, args);
    }

    public PrintStream printf(Locale locale, String format, Object... args) {
        return format(locale, format, args);
    }

    public PrintStream format(String format, Object... args) {
        return format(Locale.getDefault(), format, args);
    }

    public PrintStream format(Locale locale, String format, Object... args) {
        Formatter f = new Formatter(this, locale);
        f.format(format, args);
        return this;
    }

    /**
     * Return a print stream that will "deep six" any output.
     */
    protected static synchronized PrintStream getNullPrintStream() {
        if (nullStream == null) {
            nullStream = new PrintStream(new OutputStream() {
                @Override
                public void write(int b) throws IOException {
                }
            }, false);
        }
        return nullStream;
    }
}