package components.simplereader;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.URI;
import java.net.URISyntaxException;
import java.net.URL;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;

/**
 * {@code SimpleReader} represented as {@link java.io.BufferedReader
 * java.io.BufferedReader} with implementations of primary methods.
 *
 * @correspondence <pre>
 * this.is_open = [$this.rep is open] and
 *  this.ext_name = $this.name and
 *  if $this.lookAheadIsValid then
 *    this.contents = [$this.lookAhead * the contents of $this.rep]
 *  else
 *    this.contents = [the contents of $this.rep]
 * </pre>
 * @convention {@code
 * [$this.rep is not null when the stream is open and
 *  lookAheadIsValid is true iff the contents of $this.rep is not <>]
 * }
 */
public class SimpleReader1L extends SimpleReaderSecondary {

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

    /**
     * The input stream.
     */
    private BufferedReader rep;
    /**
     * The stream name.
     */
    private String name;
    /**
     * The look ahead character buffer.
     */
    private char lookAhead;
    /**
     * Flag to keep track of whether the lookAhead contains the first character
     * in this.content.
     */
    private boolean lookAheadIsValid;

    /**
     * Creator of initial representation.
     */
    private void createNewRep() {
        this.rep = new BufferedReader(new InputStreamReader(System.in));
        this.name = "";
    }

    /**
     * Inputs one character from $this.rep.
     *
     * @requires $this.lookAheadIsValid = false
     * @ensures <pre>
     * [$this.lookAhead contains the first character from #$this.rep and
     * $thislookAheadIsValid is true unless the end of the stream has
     * been reached. It is non-static because it needs to be able to
     * modify the representation.]
     * </pre>
     */
    private void getOneChar() {
        try {
            int nextCh = this.rep.read();
            if (nextCh != -1) {
                this.lookAhead = (char) nextCh;
                this.lookAheadIsValid = true;
            }
        } catch (IOException e) {
            throw new AssertionError("Violation of: can read from reader");
        }

    }

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

    /**
     * No-argument constructor (for input from stdin).
     */
    public SimpleReader1L() {
        this.createNewRep();
    }

    /**
     * Constructor for input from given file.
     *
     * @param source
     *            the name of the file or of a URL to input from
     */
    public SimpleReader1L(String source) {
        assert source != null : "Violation of: name is not null";
        this.name = source;

        URI uri = null;
        boolean isUri = false;

        // check if source is a valid URI
        try {
            uri = new URI(source);
            isUri = (uri.getScheme() != null);
        } catch (URISyntaxException e) {
            // not a valid URI — likely a local file path
        }

        if (isUri) {
            try {
                URL url = uri.toURL();
                this.rep = new BufferedReader(new InputStreamReader(url.openStream()));
            } catch (IOException e) {
                throw new AssertionError(
                        "Violation of: " + source + " is a valid URL and is accessible");
            }
        } else {
            // treat as local file path
            Path path = Paths.get(source);
            if (!Files.exists(path)) {
                throw new AssertionError("Violation of: " + source + " exists");
            }
            if (!Files.isReadable(path)) {
                throw new AssertionError("Violation of: " + source + " is readable");
            }
            try {
                this.rep = Files.newBufferedReader(path);
            } catch (IOException e) {
                throw new AssertionError("Violation of: " + source + " can be opened");
            }
        }
    }

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

    @Override
    public final SimpleReader 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(SimpleReader source) {
        assert source != null : "Violation of: source is not null";
        assert source != this : "Violation of: source is not this";
        assert source instanceof SimpleReader1L
                : "Violation of: source is of dynamic type SimpleReader1L";
        /*
         * This cast cannot fail since the assert above would have stopped
         * execution in that case.
         */
        SimpleReader1L localSource = (SimpleReader1L) source;
        this.rep = localSource.rep;
        this.name = localSource.name;
        this.lookAhead = localSource.lookAhead;
        this.lookAheadIsValid = localSource.lookAheadIsValid;
        localSource.createNewRep();
    }

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

    @Override
    public final char read() {
        assert this.rep != null : "Violation of: this is open";
        if (!this.lookAheadIsValid) {
            this.getOneChar();
        }
        assert this.lookAheadIsValid : "Violation of: this is not at end-of-stream";
        this.lookAheadIsValid = false;
        return this.lookAhead;
    }

    @Override
    public final char peek() {
        assert this.rep != null : "Violation of: this is open";
        if (!this.lookAheadIsValid) {
            this.getOneChar();
        }
        assert this.lookAheadIsValid : "Violation of: this is not at end-of-stream";
        return this.lookAhead;
    }

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

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

    @Override
    public final boolean atEOS() {
        assert this.rep != null : "Violation of: this is open";
        if (!this.lookAheadIsValid) {
            this.getOneChar();
        }
        return !this.lookAheadIsValid;
    }

    @Override
    public final void close() {
        assert this.rep != null : "Violation of: this is open";
        try {
            this.rep.close();
            this.rep = null;
        } catch (IOException e) {
            throw new AssertionError("Violation of: this can be closed");
        }
    }

}