/*

  * Copyright 2007, 2008, 2009, 2012 Ange Optimization ApS

  *

  * Licensed under the Apache License, Version 2.0 (the "License");

  * you may not use this file except in compliance with the License.

  * You may obtain a copy of the License at

  *

  *     http://www.apache.org/licenses/LICENSE-2.0

  *

  * Unless required by applicable law or agreed to in writing, software

  * distributed under the License is distributed on an "AS IS" BASIS,

  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  * See the License for the specific language governing permissions and

  * limitations under the License.

  */

 package eu.simuline.octave.io;

 import java.io.BufferedReader;

 import java.io.IOException;

 import java.io.StringReader;

 import java.io.StringWriter;

 import java.io.Writer;

 import java.util.Collections;

 import java.util.Map;

 import eu.simuline.octave.exception.OctaveClassCastException;

 import eu.simuline.octave.exception.OctaveIOException;

 import eu.simuline.octave.exception.OctaveParseException;

 import eu.simuline.octave.exec.OctaveExec;

 import eu.simuline.octave.exec.ReaderWriteFunctor;

 import eu.simuline.octave.exec.WriteFunctor;

 import eu.simuline.octave.exec.WriterReadFunctor;

 import eu.simuline.octave.io.spi.OctaveDataReader;

 import eu.simuline.octave.io.spi.OctaveDataWriter;

 import eu.simuline.octave.type.OctaveObject;

 // ER: Has only static methods or methods based on {@link #octaveExec} 

 /**

  * The object controlling IO of Octave data of {@link #octaveExec}. 

  * The basic operations are to 

  * <ul>

  * <li>

  * set a map of variable names to their values 

  * via {@link #set(Map)} (no setting of a single value), 

  * <li>

  * get the value for a variable name via {@link #get(String)}, 

  * <li>

  * check whether a variable with a given name exists 

  * via {@link #existsVar(String)}. 

  * </ul>

  * The rest are static utility methods. 

  * Part is for reading objects from a reader: 

  * <ul>

  * <li>

  * {@link #readerReadLine(BufferedReader)} reads a line 

  * <li>

  * {@link #read(BufferedReader)} reads an object 

  * <li>

  * {@link #readWithName(BufferedReader)} yields a singleton map name-->object, 

  * where name is the name of a variable 

  * <li>

  * {@link #readWithName(String)} yields a singleton map name-->object, 

  * as above but reading from a string. 

  * </ul>

  * Part is for writing: 

  * <ul>

  * <li>

  * {@link #write(Writer, OctaveObject)}

 write(Writer, String, OctaveObject)

 toText(String, OctaveObject)

 toText(OctaveObject)

  * </ul>

  */

 public final class OctaveIO {

     private static final String GLOBAL = "global ";

     private static final String TYPE   = "# type: ";

     private static final String NAME   = "# name: ";

     private final OctaveExec octaveExec;

     /**

      * @param octaveExec

      */

     public OctaveIO(final OctaveExec octaveExec) {

         this.octaveExec = octaveExec;

     }

     /**

      * Sets the map <code>values</code> 

      * mapping variable names to according values. 

      *

      * @param values

      */

     public void set(final Map<String, OctaveObject> values) {

         final StringWriter outputWriter = new StringWriter();

         this.octaveExec.evalRW(new DataWriteFunctor(values),

                                new WriterReadFunctor(outputWriter));

         final String output = outputWriter.toString();

         if (output.length() != 0) {

             throw new IllegalStateException

                 ("Unexpected output: '" + output + "'");

         }

     }

     /**

      * Gets the value of the variable <code>name</code> 

      * or null if this variable does not exist 

      * according to {@link #existsVar(String)}. 

      *

      * @param name

      *    the name of a variable 

      * @return 

      *    the value of the variable <code>name</code> from octave 

      *    or <code>null</code> if the variable does not exist. 

      * @throws OctaveClassCastException

      *    if the value can not be cast to T

      */

     public OctaveObject get(final String name) {

         if (!existsVar(name)) {

             return null;

         }

         final WriteFunctor writeFunctor = 

             new ReaderWriteFunctor(new StringReader("save -text - " + name));

         final DataReadFunctor readFunctor = new DataReadFunctor(name);

         this.octaveExec.evalRW(writeFunctor, readFunctor);

         return readFunctor.getData();

     }

     /**

      * Returns whether the variable <code>name</code> exists. 

      *

      * @param name

      *    the name of a variable 

      * @return 

      *    whether the variable <code>name</code> exists. 

      */

     private boolean existsVar(final String name) {

         StringReader checkCmd = new StringReader

             ("printf('%d', exist('" + name + "','var'));");

         final StringWriter existResult = new StringWriter();

         this.octaveExec.evalRW(new ReaderWriteFunctor(checkCmd),

                                new WriterReadFunctor(existResult));

         final String s = existResult.toString();

         // switch (s) {

         // case "1":

         //     return true;

         // case "0": 

         //     return false;

         // default:

         //     throw new OctaveParseException("Unexpected output '" + s + "'");

         // }

         if ("1".equals(s)) {

             return true;

         } else if ("0".equals(s)) {

             return false;

         } else {

             throw new OctaveParseException("Unexpected output '" + s + "'");

         }

     }

     /**

      * Reads a line from <code>reader</code> into a string if possible. 

      * Returns null at the end of the stream and throws an exception 

      * in case of io problems. 

      *

      * @param reader

      *    the reader to read a line from. 

      * @return 

      *    next line from <code>reader</code>, <code>null</code> at end of stream

      * @throws OctaveIOException

      *    in case of IOException reading from <code>reader</code>. 

      */

     public static String readerReadLine(final BufferedReader reader) {

         try {

             return reader.readLine();

         } catch (IOException e) {

             throw new OctaveIOException(e);

         }

     }

     /**

      * Read a single object from Reader. 

      * The first line read determines the type of object 

      * and the rest of reading is delegated to the OctaveDataReader 

      * associated with that type given by 

      * {@link OctaveDataReader#getOctaveDataReader(String)}. 

      *

      * @param reader

      *    a reader starting with first line 

      *    <code>{@link #TYPE}[global ]type</code>, 

      *    i.e. <code>global </code> is optional 

      *    and type is the type of the object to be read. 

      * @return 

      *    OctaveObject read from Reader

      * @throws OctaveParseException **** appropriate type? 

      *    if the type read before is not registered 

      *    and so there is no appropriate reader. 

      */

     public static OctaveObject read(final BufferedReader reader) {

         // may throw OctaveIOException 

         final String line = OctaveIO.readerReadLine(reader);

         // line == null at end of stream 

         if (line == null || !line.startsWith(TYPE)) {

             throw new OctaveParseException

                 ("Expected '" + TYPE + "' got '" + line + "'");

         }

         String typeGlobal = line.substring(TYPE.length());

         // Ignore "global " prefix to type (it is not really a type)

         String type = typeGlobal.startsWith(GLOBAL)

             ? typeGlobal.substring(GLOBAL.length())

             : typeGlobal;

         final OctaveDataReader dataReader = 

             OctaveDataReader.getOctaveDataReader(type);

         if (dataReader == null) {

             throw new OctaveParseException

                 ("Unknown octave type, type='" + type + "'");

         }

         return dataReader.read(reader);

     }

     /**

      * Read a single variable - object pair from Reader. 

      * The variable is given by its name. 

      *

      * @param reader

      *    a reader starting with first line <code>{@link #NAME}name</code>, 

      *    where name is the name of the variable. 

      *    the following lines represent the object stored in that variable. 

      * @return 

      *   a singleton map with the name of a variable and object stored therein. 

      */

     // used in DataReadFunctor.doReads(Reader) only and tests. 

     public static 

         Map<String, OctaveObject> readWithName(final BufferedReader reader) {

         // read name from the first line 

         // may throw OctaveIOException 

         final String line = OctaveIO.readerReadLine(reader);

         if (!line.startsWith(NAME)) {

             throw new OctaveParseException

                 ("Expected '" + NAME + "', but got '" + line + "'");

         }

         final String name = line.substring(NAME.length());

         // read value and put into singleton map 

         return Collections.singletonMap(name, read(reader));

     }

     /**

      * Read a single object from String, 

      * it is an error if there is data left after the object. 

      *

      * @param input

      *    

      * @return 

      *    a singleton map with the name and object

      * @throws OctaveParseException

      *    if there is data left after the object is read

      */

     public static Map<String, OctaveObject> readWithName(final String input) {

         final BufferedReader bufferedReader = 

             new BufferedReader(new StringReader(input));

         // may throw OctaveIOException 

         final Map<String, OctaveObject> map = readWithName(bufferedReader);

         try {

             final String line = bufferedReader.readLine();

             if (line != null) {

                 throw new OctaveParseException

                     ("Too much data in input, first extra line is '" + 

                      line + "'");

             }

         } catch (IOException e) {

             throw new OctaveIOException(e);

         }

         return map;

     }

     // newly introduced, not yet used. 

     /**

      * Writes a line given by <code>strWithNl</code> to <code>writer</code> 

      * if possible. 

      *

      * @param writer

      * @param strWithNl

      * @throws OctaveIOException

      *    in case of IOException writing to <code>writer</code>. 

      */

     public static void writerWriteLine(Writer writer, String strWithNl) {

         try {

             writer.write(strWithNl);

         } catch (IOException e) {

             throw new OctaveIOException(e);

         }

     }

     /**

      * ER: 

      * Writes the {@link OctaveObject} <code>octaveType</code> (****bad name) 

      * to the writer <code>writer</code>. 

      * To that end, fetch an {@link OctaveDataWriter} 

      * of the appropriate type given by <code>octaveType</code> 

      * and use this writer to write <code>octaveType</code> 

      * onto <code>writer</code>. 

      * @param <T>

      *    the type of {@link OctaveObject} to be written. 

      * @param writer

      *    the writer to write the object <code>octValue</code> onto. 

      * @param octValue

      *    the object to write to <code>writer</code>. 

      * @throws OctaveParseException **** appropriate type? 

      *    if the type of <code>octValue</code> is not registered 

      *    and so there is no appropriate writer. 

      * @throws IOException

      *    if the process of writing fails. 

      */

     public static <T extends OctaveObject> void write(final Writer writer,

                                                       final T octValue) 

         throws IOException {

         final OctaveDataWriter<T> dataWriter = 

             OctaveDataWriter.getOctaveDataWriter(octValue);

         if (dataWriter == null) {

             throw new OctaveParseException

                 ("No writer for java type " + octValue.getClass() + ". ");

         }

         // may throw IOException 

         dataWriter.write(writer, octValue);

     }

     /**

      * ER: 

      * Writes the name <code>name</code> 

      * and the {@link OctaveObject} <code>octValue</code> 

      * to the writer <code>writer</code> 

      * using {@link #write(Writer, OctaveObject)}. 

      * @param writer

      *    the writer to write the object <code>octaveType</code> onto. 

      * @param name

      *    the name, **** of a variable 

      * @param octValue

      *    the object to write to <code>writer</code>. 

      * @throws OctaveParseException **** appropriate type? 

      *    if the type of <code>octaveType</code> is not registered 

      *    and so there is no appropriate writer. 

      * @throws IOException

      *    if the process of writing fails. 

      */

     public static void write(final Writer writer,

                              final String name,

                              final OctaveObject octValue) throws IOException {

         // may throw IOException 

         writer.write("# name: " + name + "\n"); // just a comment??? **** 

         // may throw IOException, OctaveParseException

         write(writer, octValue);

     }

     /**

      * Returns  as a string how the variable <code>name</code> 

      * and the {@link OctaveObject} <code>octaveType</code> (****bad name) 

      * are written. 

      *

      * @param name

      *    the name, **** of a variable 

      * @param octValue

      *    the object to write to <code>writer</code>. 

      * @return 

      *    The result from saving the value octaveType 

      *    in octave -text format

      */

     // seems to be used only locally and in tests 

     public static String toText(final String name,

                                 final OctaveObject octValue) {

         try {

             final Writer writer = new StringWriter();

             write(writer, name, octValue);

             return writer.toString();

         } catch (final IOException e) {

             throw new OctaveIOException(e);

         }

     }

     /**

      * Returns as a string how the {@link OctaveObject} <code>octaveType</code> 

      * (****bad name) is written without variable, 

      * i.e. with variable <code>"ans"</code>. 

      *

      * @param octValue

      * @return toText("ans", octValue)

      */

     public static String toText(final OctaveObject octValue) {

         return toText("ans", octValue);

     }

 }