package components.simplewriter;

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;

/**
 * {@code SimpleWriter} represented as {@link java.io.PrintWriter
 * java.io.PrintWriter} with implementations of primary methods.
 *
 * @correspondence <pre>
 * this.is_open = [$this.rep is open] and
 *  this.ext_name = $this.name and
 *  this.contents = [the contents of $this.rep]
 * </pre>
 * @convention [$this.rep is not null when the stream is open]
 */
public class SimpleWriter1L extends SimpleWriterSecondary {

    /*
     * Private members --------------------------------------------------------
     */

    /**
     * The output stream.
     */
    private PrintWriter rep;
    /**
     * The stream name.
     */
    private String name;

    /**
     * Creator of initial representation.
     */
    private void createNewRep() {
        this.rep = new PrintWriter(
                new BufferedWriter(new OutputStreamWriter(System.out)));
        this.name = "";
    }

    /*
     * Constructors -----------------------------------------------------------
     */

    /**
     * No-argument constructor (for output to stdout).
     */
    public SimpleWriter1L() {
        this.createNewRep();
    }

    /**
     * Constructor for output to given file.
     *
     * @param fileName
     *            the name of the file to output to
     */
    public SimpleWriter1L(String fileName) {
        try {
            this.rep = new PrintWriter(new BufferedWriter(new FileWriter(fileName)));
            this.name = fileName;
        } catch (IOException e) {
            throw new AssertionError("Violation of: " + fileName + " can be opened");
        }
    }

    /*
     * Standard methods -------------------------------------------------------
     */

    @Override
    public final SimpleWriter newInstance() {
        try {
            return this.getClass().getConstructor().newInstance();
        } catch (ReflectiveOperationException e) {
            throw new AssertionError(
                    "Cannot construct object of type " + this.getClass());
        }
    }

    @Override
    public final void clear() {
        this.createNewRep();
    }

    @Override
    public final void transferFrom(SimpleWriter source) {
        assert source != null : "Violation of: source is not null";
        assert source != this : "Violation of: source is not this";
        assert source instanceof SimpleWriter1L
                : "Violation of: source is of dynamic type SimpleWriter1L";
        /*
         * This cast cannot fail since the assert above would have stopped
         * execution in that case.
         */
        SimpleWriter1L localSource = (SimpleWriter1L) source;
        this.rep = localSource.rep;
        this.name = localSource.name;
        localSource.createNewRep();
    }

    /*
     * Kernel methods ---------------------------------------------------------
     */

    @Override
    public final void print(String s) {
        assert s != null : "Violation of: s is not null";
        assert this.rep != null : "Violation of: this is open";
        this.rep.print(s);
        this.rep.flush();
    }

    @Override
    public final void print(int i) {
        assert this.rep != null : "Violation of: this is open";
        this.rep.print(i);
        this.rep.flush();
    }

    @Override
    public final void print(long x) {
        assert this.rep != null : "Violation of: this is open";
        this.rep.print(x);
        this.rep.flush();
    }

    @Override
    public final void print(double d) {
        assert this.rep != null : "Violation of: this is open";
        this.rep.print(d);
        this.rep.flush();
    }

    @Override
    public final void print(double d, int precision, boolean scientific) {
        assert this.rep != null : "Violation of: this is open";
        assert precision >= 0 : "Violation of: precision >= 0";
        if (scientific) {
            this.rep.printf("%." + precision + "e", d);
        } else {
            this.rep.printf("%." + precision + "f", d);
        }
        this.rep.flush();
    }

    @Override
    public final void print(boolean b) {
        assert this.rep != null : "Violation of: this is open";
        this.rep.print(b);
        this.rep.flush();
    }

    @Override
    public final void print(char c) {
        assert this.rep != null : "Violation of: this is open";
        this.rep.print(c);
        this.rep.flush();
    }

    @Override
    public final void print(Object o) {
        assert o != null : "Violation of: o is not null";
        assert this.rep != null : "Violation of: this is open";
        this.rep.print(o);
        this.rep.flush();
    }

    @Override
    public final void println(String s) {
        assert s != null : "Violation of: s is not null";
        assert this.rep != null : "Violation of: this is open";
        this.rep.println(s);
        this.rep.flush();
    }

    @Override
    public final void println(int i) {
        assert this.rep != null : "Violation of: this is open";
        this.rep.println(i);
        this.rep.flush();
    }

    @Override
    public final void println(long x) {
        assert this.rep != null : "Violation of: this is open";
        this.rep.println(x);
        this.rep.flush();
    }

    @Override
    public final void println(double d) {
        assert this.rep != null : "Violation of: this is open";
        this.rep.println(d);
        this.rep.flush();
    }

    @Override
    public final void println(double d, int precision, boolean scientific) {
        assert this.rep != null : "Violation of: this is open";
        assert precision >= 0 : "Violation of: precision >= 0";
        if (scientific) {
            this.rep.printf("%." + precision + "e", d);
        } else {
            this.rep.printf("%." + precision + "f", d);
        }
        this.rep.println();
        this.rep.flush();
    }

    @Override
    public final void println(boolean b) {
        assert this.rep != null : "Violation of: this is open";
        this.rep.println(b);
        this.rep.flush();
    }

    @Override
    public final void println(char c) {
        assert this.rep != null : "Violation of: this is open";
        this.rep.println(c);
        this.rep.flush();
    }

    @Override
    public final void println() {
        assert this.rep != null : "Violation of: this is open";
        this.rep.println();
        this.rep.flush();
    }

    @Override
    public final void println(Object o) {
        assert o != null : "Violation of: o is not null";
        assert this.rep != null : "Violation of: this is open";
        this.rep.println(o);
        this.rep.flush();
    }

    @Override
    public final void write(char c) {
        assert this.rep != null : "Violation of: this is open";
        this.rep.write(c);
    }

    @Override
    public final String name() {
        return this.name;
    }

    @Override
    public final boolean isOpen() {
        return this.rep != null;
    }

    @Override
    public final void close() {
        assert this.rep != null : "Violation of: this is open";
        /*
         * Flush stream before closing just in case the last output was with the
         * write method which does not flush by default. It is possible (likely)
         * that close would flush anyway, but at least in the case of System.out
         * where we are not calling close, flush may still be needed.
         */
        this.rep.flush();
        /*
         * Close stream only if it is not connected to System.out.
         */
        if (!this.name.equals("")) {
            this.rep.close();
        }
        this.rep = null;
    }

}