package org.apidesign.delegatingwriter;

import java.io.BufferedWriter;

import java.io.IOException;

import java.io.Writer;

/**

 * This is a regular {@link BufferedWriter}, just its implementation

 * of the append method can choose from three options. This allows us to

 * simulate the potential pros and cons of various possible implementations.

 * 

 * @author Jaroslav Tulach <jaroslav.tulach@apidesign.org>

 */

public class AltBufferedWriter extends BufferedWriter {

    private final Writer out;

    private final Behaviour behaviour;

    public AltBufferedWriter(Writer out) {

        // behave exactly like BufferedWriter in 1.5 behaves

        this(out, Behaviour.DELEGATE_TO_SUPER);

    }

    public AltBufferedWriter(Writer out, Behaviour behaviour) {

        super(out);

        this.out = out;

        this.behaviour = behaviour;

    }

    @Override

    public Writer append(CharSequence csq) throws IOException {

        switch (behaviour) {

            case THROW_EXCEPTION: 

                return appendThrowException(csq); 

            case DELEGATE_TO_SUPER: 

                return appendDelegateToSuper(csq);

            case DELEGATE_TO_OUT: 

                return appendDelegateToUnderlaying(csq);

            case DELEGATE_CONDITIONALLY: 

                return appendDelegateConditionally(csq);

            default: 

                throw new IllegalStateException("Unknown" + behaviour);

        }

    }

    public Writer appendThrowException(CharSequence csq) throws IOException {

        /* in case of real code, this would be part of 

         the regular append method. BEGIN: writer.throw

    public Writer append(CharSequence csq) throws IOException {

        /* thrown an exception as this method is new and 

         subclasses need to override it */

        throw new UnsupportedOperationException();

    }

    // END: writer.throw

    public Writer appendDelegateToSuper(CharSequence csq) throws IOException {

        // non-efficient variant of delegating via converting to String first 

        // and using one of methods that existed in 1.4

        // BEGIN: writer.super

        if (csq == null) {

            write("null");

        } else {

            write(csq.toString());

        }

        return this;

        // END: writer.super

    }

    public Writer appendDelegateToUnderlaying(CharSequence csq) throws IOException {

        // BEGIN: writer.delegateout

        // efficient, yet dangerous delegation skipping methods unknown to 

        // subclasses that used version 1.4

        if (shouldBufferAsTheSequenceIsNotTooBig(csq)) {

            write(csq.toString());

        } else {

            flush();

            out.append(csq);

        }

        return this;

        // END: writer.delegateout

    }

    private Writer appendDelegateConditionally(CharSequence csq) 

    throws IOException {

        // BEGIN: writer.conditionally

        boolean isOverriden = false;

        try {

            isOverriden = 

                (

                    getClass().getMethod(

                        "write", String.class

                    ).getDeclaringClass() != Writer.class

                ) ||

                (

                    getClass().getMethod(

                        "write", Integer.TYPE

                    ).getDeclaringClass() != BufferedWriter.class

                ) ||

                (

                    getClass().getMethod(

                        "write", String.class, Integer.TYPE, Integer.TYPE

                    ).getDeclaringClass() != BufferedWriter.class

                );

        } catch (Exception ex) {

            throw new IOException(ex);

        }

        if (isOverriden || shouldBufferAsTheSequenceIsNotTooBig(csq)) {

            write(csq.toString());

        } else {

            flush();

            out.append(csq);

        }

        return this;

        // END: writer.conditionally

    }

    /** At the end the purpose of BufferedWriter is to buffer writes, this

     * method is here to decide when it is OK to prefer buffering and when 

     * it is better to delegate directly into the underlaying stream.

     * 

     * @param csq the seqence to evaluate

     * @return true if buffering from super class should be used

     */

    private static boolean shouldBufferAsTheSequenceIsNotTooBig(CharSequence csq) {

        if (csq == null) {

            return false;

        }

        // as buffers are usually bigger than 1024, it makes sense to 

        // pay the penalty of converting the sequence to string, but buffering

        // the write

        if (csq.length() < 1024) {

            return true;

        } else {

            // otherwise, just directly write down the char sequence

            return false;

        }

    }

    public enum Behaviour {

        THROW_EXCEPTION, 

        DELEGATE_TO_SUPER, 

        DELEGATE_TO_OUT, 

        DELEGATE_CONDITIONALLY

    }

}