package Torello.Java;

import java.io.BufferedWriter;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.InputStream;
import java.io.IOException;

import java.util.Arrays;
import java.util.Objects;

/**
 * Allows a user to pipe data directly from Java-Memory, and into an instance of 
 * <CODE>java.lang.Process</CODE>.
 */
public class OSJavaPipe implements Cloneable
{
    // ********************************************************************************************
    // ********************************************************************************************
    // Two Private-Fields, Two Inpsection Methods
    // ********************************************************************************************
    // ********************************************************************************************


    private Object  textOrDataToPipe;
    private byte    dataType;

    /**
     * Retrieve the Data-Type that is contained by this instance' internal PIPE-Data contents.
     * @return The Static-Flag Constant associated with the Data-Type that has been assigned to
     * this instance.
     */
    public byte getDataType()
    { return this.dataType; }

    /**
     * Retrieve the actual data, as a {@code java.lang.Object} contained by this instance.
     * @return This class internal Data-Field
     */
    public Object getPipeData()
    { return this.textOrDataToPipe; }


    // ********************************************************************************************
    // ********************************************************************************************
    // Static-Flag Constants, representing the Data's Type
    // ********************************************************************************************
    // ********************************************************************************************


    /**
     * Constant used to indicate that this class data-contents currently contain a non-null
     * {@code int[]}-Array.
     */
    public static final byte INT_ARR = 1;

    /**
     * Constant used to indicate that this class data-contents currently contain a non-null
     * {@code byte[]}-Array.
     */
    public static final byte BYTE_ARR = 2;

    /**
     * Constant used to indicate that this class data-contents currently contain a non-null
     * {@code char[]}-Array.
     */
    public static final byte CHAR_ARR = 3;

    /**
     * Constant used to indicate that this class data-contents currently contain a non-null
     * {@code String}.
     */
    public static final byte STRING = 4;

    /**
     * Constant used to indicate that this class data-contents currently contain a non-null
     * {@code InputStream}.
     */
    public static final byte INPUT_STREAM = 5;


    // ********************************************************************************************
    // ********************************************************************************************
    // Constructors
    // ********************************************************************************************
    // ********************************************************************************************


    private OSJavaPipe() { }

    /**
     * Constructs an instance of this class, assigning the input {@code int[]}-Array Parameter to
     * the internal Data-Field.
     * 
     * @param intArrData Any Java {@code int[]} Integer-Array.
     * @throws NullPointerException if {@code 'intArrData'} is null.
     */
    public OSJavaPipe(final int[] intArrData)
    { this.setData(intArrData); }

    /**
     * Constructs an instance of this class, assigning the input {@code byte[]}-Array Parameter to
     * the internal Data-Field.
     * 
     * @param byteArrData Any Java {@code byte[]} Byte-Array.
     * @throws NullPointerException if {@code 'byteArrData'} is null.
     */
    public OSJavaPipe(final byte[] byteArrData)
    { this.setData(byteArrData); }

    /**
     * Constructs an instance of this class, assigning the input {@code char[]}-Array Parameter to
     * the internal Data-Field.
     * 
     * @param charArrData Any Java {@code char[]} Char-Array.
     * @throws NullPointerException if {@code 'charArrData'} is null.
     */
    public OSJavaPipe(final char[] charArrData)
    { this.setData(charArrData); }

    /**
     * Constructs an instance of this class, assigning the input {@code String}-Parameter to the
     * internal Data-Field.
     * 
     * @param strData Any Java {@code String}.
     * @throws NullPointerException if {@code 'strData'} is null.
     */
    public OSJavaPipe(final String strData)
    { this.setData(strData); }

    /**
     * Constructs an instance of this class, assigning the {@code InputStream} Parameter to the
     * internal Data-Field.
     * 
     * @param inputStream Any Java Input-Stream.
     * @throws NullPointerException if {@code 'inputStream'} is null.
     */
    public OSJavaPipe(final InputStream inputStream)
    { this.setData(inputStream); }


    // ********************************************************************************************
    // ********************************************************************************************
    // This Class Main User-API for assigning some data
    // ********************************************************************************************
    // ********************************************************************************************


    /**
     * Sets the data to be used for piping into an Operating-System Process.
     * @param intArrData Any Java {@code int[]} Integer-Array.
     * @throws NullPointerException if {@code 'intArrData'} is null.
     */
    public synchronized void setData(final int[] intArrData)
    {
        Objects.requireNonNull(intArrData, "The int[]-Array passed may not be null");

        this.textOrDataToPipe   = intArrData;
        this.dataType           = INT_ARR;
    }

    /**
     * Sets the data to be used for piping into an Operating-System Process.
     * @param byteArrData Any Java {@code byte[]} Byte-Array.
     * @throws NullPointerException if {@code 'byteArrData'} is null.
     */
    public synchronized void setData(final byte[] byteArrData)
    {
        Objects.requireNonNull(byteArrData, "The byte[]-Array passed may not be null");

        this.textOrDataToPipe   = byteArrData;
        this.dataType           = BYTE_ARR;
    }

    /**
     * Sets the data to be used for piping into an Operating-System Process.
     * @param charArrData Any Java {@code char[]} Char-Array.
     * @throws NullPointerException if {@code 'charArrData'} is null.
     */
    public synchronized void setData(final char[] charArrData)
    {
        Objects.requireNonNull(charArrData, "The char[]-Array passed may not be null");

        this.textOrDataToPipe   = charArrData;
        this.dataType           = CHAR_ARR;
    }

    /**
     * Sets the data to be used for piping into an Operating-System Process.
     * @param strData Any Java {@code String}.
     * @throws NullPointerException if {@code 'strData'} is null.
     */
    public synchronized void setData(final String strData)
    {
        Objects.requireNonNull(strData, "The String-Data passed may not be null");

        this.textOrDataToPipe   = strData;
        this.dataType           = STRING;
    }

    /**
     * Sets the data to be used for piping into an Operating-System Process.
     * @param inputStream Any Java Input-Stream.
     * @throws NullPointerException if {@code 'inputStream'} is null.
     */
    public synchronized void setData(final InputStream inputStream)
    {
        Objects.requireNonNull(inputStream, "The Input-Stream passed may not be null");

        this.textOrDataToPipe   = inputStream;
        this.dataType           = INPUT_STREAM;
    }


    // ********************************************************************************************
    // ********************************************************************************************
    // Package-Private Method for writing this data to an input stream.
    // ********************************************************************************************
    // ********************************************************************************************


    // Class OSCommands uses this Package-Private method to write the contents of the data-field
    // inside this class to the "OutputStream".  The OutputStream instance that is provided as 
    // input to this method is the one that is retrieved by invoking the method:
    //
    // Process.getOutputStream(). 
    // 
    // This OutputStream pipes the text/data that it receives directly to the Operating-System's
    // Process.  NOTE - this method is, essentially, the whole entire purpose of this class.  Also,
    // this class isn't so complicated, it's just a lot of wordy-explanations that help understand
    // how to use java.lang.Process / Process.Redirect / and all those Input-Output Streams.  It
    // hopefully makes it a lot easier to use and extend this stuff.  It certainly does for me.
    // 
    // Again, this is Package-Private, and only invoked in one place, inside the "OSCommands"
    // method.

    synchronized void writeToPipe(final OutputStream os) throws IOException
    {
        switch (this.dataType)
        {
            case INT_ARR :
                for (int i : (int[]) textOrDataToPipe) os.write(i);
                break;

            case BYTE_ARR :
                for (byte b : (byte[]) textOrDataToPipe) os.write(b);
                break;

            case CHAR_ARR :
                for (char c : (char[]) textOrDataToPipe) os.write(c);
                break;

            case STRING :
                BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(os));
                writer.write((String) textOrDataToPipe);
                writer.flush();
                writer.close(); // Important to close the stream to signal end of input
                break;

            case INPUT_STREAM  :
                ((InputStream) textOrDataToPipe).transferTo(os);
                break;

            default: throw new UnreachableError();
        }

        os.flush();
        os.close();
    }


    // ********************************************************************************************
    // ********************************************************************************************
    // java.lang.Object
    // ********************************************************************************************
    // ********************************************************************************************


    private static final String NAME = "OSJavaPipe Contents: ";

    /**
     * Generates a {@code String} this class.  The returned {@code String} merely converts the
     * contained data to a {@code String}, using Standard Java Methods.
     *     
     * @return A simple representation of this class, as a {@code java.lang.String}
     */
    public synchronized String toString()
    {
        switch (this.dataType)
        {
            case INT_ARR : return NAME + "int[]:\n" + StrPrint.abbrev(
                Arrays.toString((int[]) this.textOrDataToPipe),
                60, true, null, 120
            );

            case BYTE_ARR : return NAME + "byte[]:\n" + StrPrint.abbrev(
                Arrays.toString((byte[]) this.textOrDataToPipe),
                60, true, null, 120
            );

            case CHAR_ARR : return NAME + "char[]:\n" + StrPrint.abbrev(
                Arrays.toString((char[]) this.textOrDataToPipe),
                60, true, null, 120
            );

            case STRING : return NAME + "String:\n" + StrPrint.abbrev
                ((String) this.textOrDataToPipe, 60, true, null, 120);

            case INPUT_STREAM : return NAME + "InputStream: Non-Null Data-Input\n";

            default: throw new UnreachableError();
        }
    }

    /**
     * Checks for equality based on whether two instances have identical references.
     *
     * @param other Any Java Object.  Only a valid sub-class of {@code OSJavaPipe} could possibly
     * produce a {@code TRUE} return value
     *
     * @return {@code TRUE} if and only if this class' internal fields are <I>identical
     * references in both {@code 'this'} and {@code 'other'}</I>.
     */
    public synchronized boolean equals(Object other)
    {
        if (other == null)                      return false;
        if (! (other instanceof OSJavaPipe))    return false;

        final OSJavaPipe o = (OSJavaPipe) other;

        return
                Objects.equals(this.textOrDataToPipe, o.textOrDataToPipe)
            &&  (this.dataType == o.dataType);
    }

    /**
     * Makes a copy of {@code 'this'} instance and returns it.
     * @return a clone of {@code 'this'} instance
     */
    public synchronized Object clone()
    {
        // Private-Internal Zero-Argument Constructor
        OSJavaPipe ret = new OSJavaPipe(); 

        ret.dataType            = this.dataType;
        ret.textOrDataToPipe    = this.textOrDataToPipe;

        return ret;
    }

    /**
     * Produces a Hash-Code that may be used to place this instance-reference into a Hash-Table,
     * Set or Map.  The code produced is generated using whatever hash-code value is returned 
     * by this class' internal {@link #textOrDataToPipe} hash-code method.
     * 
     * @return a hashcode 
     */
    public int hashCode()
    { return this.textOrDataToPipe.hashCode(); }
}