/**
 * TecplotGeomReader -- A class that can read and write an ASCII Tecplot formatted triangle file.
 *
 * Copyright (C) 2019, Joseph A. Huwaldt. All rights reserved.
 *
 * This library is free software; you can redistribute it and/or modify it under the terms
 * of the GNU Lesser General Public License as published by the Free Software Foundation;
 * either version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful, but WITHOUT ANY
 * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
 * PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License along with
 * this program; if not, write to the Free Software Foundation, Inc., 59 Temple Place -
 * Suite 330, Boston, MA 02111-1307, USA. Or visit: http://www.gnu.org/licenses/lgpl.html
 */
package geomss.geom.reader;

import geomss.geom.GeomList;
import geomss.geom.Point;
import geomss.geom.Triangle;
import geomss.geom.TriangleList;
import java.io.*;
import java.nio.file.Files;
import java.text.MessageFormat;
import java.util.ArrayList;
import java.util.List;
import java.util.Locale;
import static java.util.Objects.requireNonNull;
import javax.measure.quantity.Length;
import javax.measure.unit.Unit;
import javolution.text.TypeFormat;
import javolution.util.FastTable;

/**
 * A {@link GeomReader} for reading and writing geometry from/to an Tecplot ASCII
 * formatted triangle file. The first 3 columns of data are assumed to be the X,Y,Z points.
 *
 * <p> Modified by: Joseph A. Huwaldt </p>
 *
 * @author Joseph A. Huwaldt, Date: July 12, 2019
 * @version July 12, 2019
 */
public class TecplotGeomReader extends AbstractGeomReader {

    //  Debug output flag.
    //private static final boolean DEBUG = false;

    //  A brief description of the data read by this reaader.
    private static final String DESCRIPTION = RESOURCES.getString("tecplotDescription");

    //  The preferred file extension for files of this reader's type.
    public static final String EXTENSION = "dat";
    
    //  Used to split strings on white space.
    private static final String WHITESPACE = "\\s+";

    /**
     * Returns a string representation of the object. This will return a brief description
     * of the format read by this reader.
     *
     * @return A brief description of the format read by this reader.
     */
    @Override
    public String toString() {
        return DESCRIPTION;
    }

    /**
     * Returns the preferred file extension (not including the ".") for files of this
     * GeomReader's type.
     *
     * @return The preferred file extension for files of this readers type.
     */
    @Override
    public String getExtension() {
        return EXTENSION;
    }

    /**
     * Method that determines if this reader can read geometry from the specified input
     * file.
     *
     * @param inputFile The input file containing the geometry to be read in.
     * @return GeomReader.NO if the file format is not recognized by this reader.
     *         GeomReader.YES if the file has the extension ".dat" and contains a Tecplot header.
     * @throws java.io.IOException If there is a problem reading from the specified file.
     */
    @Override
    public int canReadData(File inputFile) throws IOException {

        String name = inputFile.getName();
        name = name.toLowerCase().trim();
        if (name.endsWith(".dat")) {
            //  Try reading the number of variables from the file.
            try (BufferedReader reader = Files.newBufferedReader(inputFile.toPath())) {
                
                List<String> variables = getVariables(reader);
                if (!variables.isEmpty())
                    return YES;
                
            } catch (IOException e) {
            }
        }

        return NO;
    }

    /**
     * Reads in a Tecplot ASCII formatted triangle geometry file from the
     * specified input file and returns a {@link GeomList} object that contains a set of
     * {@link TriangleList} objects (1 for each "zone" in the Tecplot file).
     * <p>
     * WARNING: This file format is not unit aware. You must set the units
     * to be used by calling "setFileUnits()" before calling this method!
     * </p>
     *
     * @param inputFile The input file containing the geometry to be read in. May not be
     *                  null.
     * @return A {@link GeomList} object containing the geometry read in from the file. If
     *         the file has no geometry in it, then this list will have no triangles in it
     *         (will have a size() of zero).
     * @throws IOException If there is a problem reading the specified file.
     * @see #setFileUnits(javax.measure.unit.Unit) 
     */
    @Override
    public GeomList<TriangleList> read(File inputFile) throws IOException {
        requireNonNull(inputFile);
        _warnings.clear();

        //  Create an initially empty geometry list for output.
        GeomList<TriangleList> output = GeomList.newInstance();

        //  Tecplot ASCII files are required to be in ASCII with U.S. style number formatting.
        //  Get the default locale and save it.  Then change the default locale to US.
        Locale defLocale = Locale.getDefault();
        Locale.setDefault(Locale.US);

        // Create a reader to access the ASCII file.
        try (LineNumberReader reader = new LineNumberReader(new FileReader(inputFile))) {
            try {
                Unit<Length> units = this.getFileUnits();
                
                // Get the variables in the file.
                reader.mark(8192);
                List<String> variables = getVariables(reader);
                reader.reset();
                if (variables.size() < 3) {
                    _warnings.add("No variables found in the \"" + inputFile + "\" file.");
                    return output;
                }
                
                //  REad in the title.
                String[] tokens = reader.readLine().split("=");
                if (tokens.length > 1)
                    output.setName(tokens[1].trim());
                
                //  Loop over all the zones in the file.
                String zone = getNextZone(reader);
                while (zone != null) {
                    
                    //  Read in the number of verticies and triangles in the file.
                    reader.readLine();    //  Skip a line.
                    String line = reader.readLine();
                    tokens = line.trim().split(",");
                    //  First one should be the number of verticies.
                    String[] parts = tokens[0].split("=");
                    int numVerts = TypeFormat.parseInt(parts[1]);
                    //  Second one should be the number of triangles.
                    parts = tokens[1].split("=");
                    int numTris = TypeFormat.parseInt(parts[1]);
                    
                    //  Skip 2 lines.
                    reader.readLine();
                    reader.readLine();

                    //  Read in all the vertices.
                    FastTable<Point> vertices = FastTable.newInstance();
                    for (int i = 0; i < numVerts; ++i) {
                        line = reader.readLine();
                        tokens = line.trim().split(WHITESPACE);
                        double x = TypeFormat.parseDouble(tokens[0]);
                        double y = TypeFormat.parseDouble(tokens[1]);
                        double z = TypeFormat.parseDouble(tokens[2]);
                        Point p = Point.valueOf(x, y, z, units);
                        vertices.add(p);
                    }
                    
                    
                    //  Read in the array of indexes.
                    int numIndexes = numTris * 3;
                    int[] indexes = new int[numIndexes];
                    int pos = 0;
                    for (int i = 0; i < numTris; ++i) {
                        line = reader.readLine();
                        tokens = line.trim().split(WHITESPACE);
                        for (int j = 0; j < 3; ++j) {
                            int idx = TypeFormat.parseInt(tokens[j]) - 1;   //  Convert to 0 offset indexes.
                            indexes[pos++] = idx;
                        }
                    }
                    
                    //  Convert the vertices and indexes into a list of triangles.
                    TriangleList<Triangle> tris = TriangleList.valueOf(vertices, indexes);
                    tris.setName(zone);
                    output.add(tris);
                    FastTable.recycle(vertices);

                    //  Read the next zone.
                    zone = getNextZone(reader);
                }

            } catch (NumberFormatException e) {
                throw new IOException(MessageFormat.format(
                        RESOURCES.getString("parseErrMsg"), DESCRIPTION, reader.getLineNumber()));
            }
            
        } finally {
            //  Restore the default locale.
            Locale.setDefault(defLocale);
        }
        
        return output;
    }

    /**
     * Returns the variables used in the first zone in the file.  It is assumed that all
     * zones have the same set of variables in the same order.
     * 
     * @param reader The buffered reader for this file.
     * @return A list of the variables in the file.
     * @throws IOException if there are any problems reading from the file.
     */
    private static List<String> getVariables(BufferedReader reader) throws IOException {
        List<String> variables = new ArrayList();
        
        String line = reader.readLine();
        while (line != null) {
            line = line.trim();
            if (line.startsWith("VARIABLES") || line.startsWith("\"")) {
                String[] parts = line.split(WHITESPACE);
                
                //  Strip off white space and quote characters.
                for (int j=0; j < parts.length; ++j) {
                    String part = parts[j].trim();
                    if (part.length() > 0 && !part.equals("=") && !part.startsWith("VARIABLES")) {
                        part = part.replaceAll("^\"|\"$", "");
                        variables.add(part);
                    }
                 }
            } else if (line.startsWith("ZONE"))
                break;
            
            line = reader.readLine();
        }
        
        return variables;
    }
    
    /**
     * Return the next zone in the file or null if there are no more zones.
     * 
     * @param reader The buffered reader for this file.
     * @return The name of the next zone or null if there are no more zones.
     * @throws IOException If there is a problem reading from the file.
     */
    private static String getNextZone(BufferedReader reader) throws IOException {
        String zone = null;
        
        String line = reader.readLine();
        while (line != null) {
            line = line.trim();
            if (line.startsWith("ZONE")) {
                int idx = line.indexOf("T=");
                idx = line.indexOf("\"", idx);
                ++idx;
                int idx2 = line.indexOf("\"", idx);
                zone = line.substring(idx, idx2);
                break;
            }
            
            line = reader.readLine();
        }
        
        return zone;
    }
    /**
     * This method always returns <code>false</code> as TRI files do not encode the units
     * that are being used. You must call <code>setFileUnits</code> to set the units being
     * used before reading from a file of this format.
     *
     * @return This implementation always returns false.
     * @see #setFileUnits(javax.measure.unit.Unit) 
     */
    @Override
    public boolean isUnitAware() {
        return false;
    }

}