/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You 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 org.apache.commons.geometry.io.euclidean.threed.obj;

import java.io.Writer;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.function.DoubleFunction;
import java.util.stream.Stream;

import org.apache.commons.geometry.euclidean.internal.EuclideanUtils;
import org.apache.commons.geometry.euclidean.threed.BoundarySource3D;
import org.apache.commons.geometry.euclidean.threed.PlaneConvexSubset;
import org.apache.commons.geometry.euclidean.threed.Vector3D;
import org.apache.commons.geometry.euclidean.threed.mesh.Mesh;
import org.apache.commons.geometry.io.core.utils.AbstractTextFormatWriter;
import org.apache.commons.geometry.io.euclidean.threed.FacetDefinition;

/** Class for writing OBJ files containing 3D polygon geometries.
 */
public final class ObjWriter extends AbstractTextFormatWriter {

    /** Space character. */
    private static final char SPACE = ' ';

    /** Number of vertices written to the output. */
    private int vertexCount;

    /** Number of normals written to the output. */
    private int normalCount;

    /** Create a new instance that writes output with the given writer.
     * @param writer writer used to write output
     */
    public ObjWriter(final Writer writer) {
        super(writer);
    }

    /** Get the number of vertices written to the output.
     * @return the number of vertices written to the output.
     */
    public int getVertexCount() {
        return vertexCount;
    }

    /** Get the number of vertex normals written to the output.
     * @return the number of vertex normals written to the output.
     */
    public int getVertexNormalCount() {
        return normalCount;
    }

    /** Write an OBJ comment with the given value.
     * @param comment comment to write
     * @throws java.io.UncheckedIOException if an I/O error occurs
     */
    public void writeComment(final String comment) {
        for (final String line : comment.split("\\R")) {
            write(ObjConstants.COMMENT_CHAR);
            write(SPACE);
            write(line);
            writeNewLine();
        }
    }

    /** Write an object name to the output. This is metadata for the file and
     * does not affect the geometry, although it may affect how the file content
     * is read by other programs.
     * @param objectName the name to write
     * @throws java.io.UncheckedIOException if an I/O error occurs
     */
    public void writeObjectName(final String objectName) {
        writeKeywordLine(ObjConstants.OBJECT_KEYWORD, objectName);
    }

    /** Write a group name to the output. This is metadata for the file and
     * does not affect the geometry, although it may affect how the file content
     * is read by other programs.
     * @param groupName the name to write
     * @throws java.io.UncheckedIOException if an I/O error occurs
     */
    public void writeGroupName(final String groupName) {
        writeKeywordLine(ObjConstants.GROUP_KEYWORD, groupName);
    }

    /** Write a vertex and return the 0-based index of the vertex in the output.
     * @param vertex vertex to write
     * @return 0-based index of the written vertex
     * @throws java.io.UncheckedIOException if an I/O error occurs
     */
    public int writeVertex(final Vector3D vertex) {
        return writeVertexLine(createVectorString(vertex));
    }

    /** Write a vertex normal and return the 0-based index of the normal in the output.
     * @param normal normal to write
     * @return 0-based index of the written normal
     * @throws java.io.UncheckedIOException if an I/O error occurs
     */
    public int writeVertexNormal(final Vector3D normal) {
        return writeVertexNormalLine(createVectorString(normal));
    }

    /** Write a face with the given 0-based vertex indices.
     * @param vertexIndices 0-based vertex indices for the face
     * @throws IllegalArgumentException if fewer than 3 vertex indices are given
     * @throws IndexOutOfBoundsException if any vertex index is computed to be outside of
     *      the bounds of the elements written so far
     * @throws java.io.UncheckedIOException if an I/O error occurs
     */
    public void writeFace(final int... vertexIndices) {
        writeFaceWithOffsets(0, vertexIndices, 0, null);
    }

    /** Write a face with the given 0-based vertex indices and 0-based normal index. The normal
     * index is applied to all face vertices.
     * @param vertexIndices 0-based vertex indices
     * @param normalIndex 0-based normal index
     * @throws IndexOutOfBoundsException if any vertex or normal index is computed to be outside of
     *      the bounds of the elements written so far
     * @throws java.io.UncheckedIOException if an I/O error occurs
     */
    public void writeFace(final int[] vertexIndices, final int normalIndex) {
        final int[] normalIndices = new int[vertexIndices.length];
        Arrays.fill(normalIndices, normalIndex);

        writeFaceWithOffsets(0, vertexIndices, 0, normalIndices);
    }

    /** Write a face with the given vertex and normal indices. Indices are 0-based.
     * The {@code normalIndices} argument may be null, but if present, must contain the
     * same number of indices as {@code vertexIndices}.
     * @param vertexIndices 0-based vertex indices; may not be null
     * @param normalIndices 0-based normal indices; may be null but if present must contain
     *      the same number of indices as {@code vertexIndices}
     * @throws IllegalArgumentException if fewer than 3 vertex indices are given or {@code normalIndices}
     *      is not null but has a different length than {@code vertexIndices}
     * @throws IndexOutOfBoundsException if any vertex or normal index is computed to be outside of
     *      the bounds of the elements written so far
     * @throws java.io.UncheckedIOException if an I/O error occurs
     */
    public void writeFace(final int[] vertexIndices, final int[] normalIndices) {
        writeFaceWithOffsets(0, vertexIndices, 0, normalIndices);
    }

    /** Write the boundaries present in the given boundary source using a {@link MeshBuffer}
     * with an unlimited size.
     * @param src boundary source containing the boundaries to write to the output
     * @throws IllegalArgumentException if any boundary in the argument is infinite
     * @throws java.io.UncheckedIOException if an I/O error occurs
     * @see #meshBuffer(int)
     * @see #writeMesh(Mesh)
     */
    public void writeBoundaries(final BoundarySource3D src) {
        writeBoundaries(src, -1);
    }

    /** Write the boundaries present in the given boundary source using a {@link MeshBuffer} with
     * the given {@code batchSize}.
     * @param src boundary source containing the boundaries to write to the output
     * @param batchSize batch size to use for the mesh buffer; pass {@code -1} to use a buffer
     *      of unlimited size
     * @throws IllegalArgumentException if any boundary in the argument is infinite
     * @throws java.io.UncheckedIOException if an I/O error occurs
     * @see #meshBuffer(int)
     * @see #writeMesh(Mesh)
     */
    public void writeBoundaries(final BoundarySource3D src, final int batchSize) {
        final MeshBuffer buffer = meshBuffer(batchSize);

        try (Stream<PlaneConvexSubset> stream = src.boundaryStream()) {
            final Iterator<PlaneConvexSubset> it = stream.iterator();
            while (it.hasNext()) {
                buffer.add(it.next());
            }
        }

        buffer.flush();
    }

    /** Write a mesh to the output. All vertices and faces are written exactly as found. For example,
     * if a vertex is duplicated in the argument, it will also be duplicated in the output.
     * @param mesh the mesh to write
     * @throws java.io.UncheckedIOException if an I/O error occurs
     */
    public void writeMesh(final Mesh<?> mesh) {
        final int vertexOffset = vertexCount;

        for (final Vector3D vertex : mesh.vertices()) {
            writeVertex(vertex);
        }

        for (final Mesh.Face face : mesh.faces()) {
            writeFaceWithOffsets(vertexOffset, face.getVertexIndices(), 0, null);
        }
    }

    /** Create a new {@link MeshBuffer} instance with an unlimited batch size, meaning that
     * no vertex definitions are duplicated in the mesh output. This produces the most compact
     * mesh but at the most of higher memory usage during writing.
     * @return new mesh buffer instance
     */
    public MeshBuffer meshBuffer() {
        return meshBuffer(-1);
    }

    /** Create a new {@link MeshBuffer} instance with the given batch size. The batch size determines
     * how many faces will be stored in the buffer before being flushed. Faces stored in the buffer
     * share duplicate vertices, reducing the number of vertices required in the file. The {@code batchSize}
     * is therefore a trade-off between higher memory usage (high batch size) and a higher probability of duplicate
     * vertices present in the output (low batch size). A batch size of {@code -1} indicates an unlimited
     * batch size.
     * @param batchSize number of faces to store in the buffer before automatically flushing to the
     *      output
     * @return new mesh buffer instance
     */
    public MeshBuffer meshBuffer(final int batchSize) {
        return new MeshBuffer(batchSize);
    }

    /** Write a face with the given offsets and indices. The offsets are added to each
     * index before being written.
     * @param vertexOffset vertex offset value
     * @param vertexIndices 0-based vertex indices for the face
     * @param normalOffset normal offset value
     * @param normalIndices 0-based normal indices for the face; may be null if no normal are
     *      defined for the face
     * @throws IllegalArgumentException if fewer than 3 vertex indices are given or {@code normalIndices}
     *      is not null but has a different length than {@code vertexIndices}
     * @throws IndexOutOfBoundsException if any vertex or normal index is computed to be outside of
     *      the bounds of the elements written so far
     * @throws java.io.UncheckedIOException if an I/O error occurs
     */
    private void writeFaceWithOffsets(final int vertexOffset, final int[] vertexIndices,
            final int normalOffset, final int[] normalIndices) {
        if (vertexIndices.length < EuclideanUtils.TRIANGLE_VERTEX_COUNT) {
            throw new IllegalArgumentException("Face must have more than " + EuclideanUtils.TRIANGLE_VERTEX_COUNT +
                    " vertices; found " + vertexIndices.length);
        } else if (normalIndices != null && normalIndices.length != vertexIndices.length) {
            throw new IllegalArgumentException("Face normal index count must equal vertex index count; expected " +
                    vertexIndices.length + " but was " + normalIndices.length);
        }

        write(ObjConstants.FACE_KEYWORD);

        int vertexIdx;
        int normalIdx;
        for (int i = 0; i < vertexIndices.length; ++i) {
            vertexIdx = vertexIndices[i] + vertexOffset;
            if (vertexIdx < 0 || vertexIdx >= vertexCount) {
                throw new IndexOutOfBoundsException("Vertex index out of bounds: " + vertexIdx);
            }

            write(SPACE);
            write(vertexIdx + 1); // convert to OBJ 1-based convention

            if (normalIndices != null) {
                normalIdx = normalIndices[i] + normalOffset;
                if (normalIdx < 0 || normalIdx >= normalCount) {
                    throw new IndexOutOfBoundsException("Normal index out of bounds: " + normalIdx);
                }

                // two separator chars since there is no texture coordinate
                write(ObjConstants.FACE_VERTEX_ATTRIBUTE_SEP_CHAR);
                write(ObjConstants.FACE_VERTEX_ATTRIBUTE_SEP_CHAR);

                write(normalIdx + 1); // convert to OBJ 1-based convention
            }
        }

        writeNewLine();
    }

    /** Create the OBJ string representation of the given vector.
     * @param vec vector to convert to a string
     * @return string representation of the given vector
     */
    private String createVectorString(final Vector3D vec) {
        final DoubleFunction<String> fmt = getDoubleFormat();

        final StringBuilder sb = new StringBuilder();
        sb.append(fmt.apply(vec.getX()))
            .append(SPACE)
            .append(fmt.apply(vec.getY()))
            .append(SPACE)
            .append(fmt.apply(vec.getZ()));

        return sb.toString();
    }

    /** Write a vertex line containing the given string content.
     * @param content vertex string content
     * @return the 0-based index of the added vertex
     * @throws java.io.UncheckedIOException if an I/O error occurs
     */
    private int writeVertexLine(final String content) {
        writeKeywordLine(ObjConstants.VERTEX_KEYWORD, content);
        return vertexCount++;
    }

    /** Write a vertex normal line containing the given string content.
     * @param content vertex normal string content
     * @return the 0-based index of the added vertex normal
     * @throws java.io.UncheckedIOException if an I/O error occurs
     */
    private int writeVertexNormalLine(final String content) {
        writeKeywordLine(ObjConstants.VERTEX_NORMAL_KEYWORD, content);
        return normalCount++;
    }

    /** Write a line of content prefixed with the given OBJ keyword.
     * @param keyword OBJ keyword
     * @param content line content
     * @throws java.io.UncheckedIOException if an I/O error occurs
     */
    private void writeKeywordLine(final String keyword, final String content) {
        write(keyword);
        write(SPACE);
        write(content);
        writeNewLine();
    }

    /** Class used to produce OBJ mesh content from sequences of facets. As facets are added to the buffer
     * their vertices and normals are converted to OBJ vertex and normal definition strings. Vertices and normals
     * that produce equal definition strings are shared among all of the facets in the buffer. This process
     * converts the facet sequence into a compact mesh suitable for writing as OBJ file content.
     *
     * <p>Ideally, no vertices or normals would be duplicated in an OBJ file. However, when working with very large
     * geometries it may not be desirable to store values in memory before writing to the output. This
     * is where the {@code batchSize} property comes into play. The {@code batchSize} represents the maximum
     * number of faces that the buffer will store before automatically flushing its contents to the output and
     * resetting its state. This reduces the amount of memory used by the buffer at the cost of increasing the
     * likelihood of duplicate vertices and/or normals in the output.</p>
     */
    public final class MeshBuffer {

        /** Maximum number of faces that will be stored in the buffer before automatically flushing. */
        private final int batchSize;

        /** Map of vertex definition strings to their local index. */
        private final Map<String, Integer> vertexMap = new LinkedHashMap<>();

        /** Map of vertex normals to their local index. */
        private final Map<String, Integer> normalMap = new LinkedHashMap<>();

        /** List of local face vertex indices. */
        private final List<int[]> faceVertices;

        /** Map of local face indices to their local normal index. */
        private final Map<Integer, Integer> faceToNormalMap = new HashMap<>();

        /** Construct a new mesh buffer instance with the given batch size.
         * @param batchSize batch size; set to -1 to indicate an unlimited size
         */
        MeshBuffer(final int batchSize) {
            this.batchSize = batchSize;
            this.faceVertices = batchSize > -1 ?
                    new ArrayList<>(batchSize) :
                    new ArrayList<>();
        }

        /** Add a facet to this buffer. If {@code batchSize} is greater than {@code -1} and the number
         * of currently stored faces is greater than or equal to {@code batchSize}, then the buffer
         * content is written to the output and the buffer state is reset.
         * @param facet facet to add
         * @throws java.io.UncheckedIOException if an I/O error occurs
         */
        public void add(final FacetDefinition facet) {
            addFace(facet.getVertices(), facet.getNormal());
        }

        /** Add a boundary to this buffer. If {@code batchSize} is greater than {@code -1} and the number
         * of currently stored faces is greater than or equal to {@code batchSize}, then the buffer
         * content is written to the output and the buffer state is reset.
         * @param boundary boundary to add
         * @throws IllegalArgumentException if the boundary is infinite
         * @throws java.io.UncheckedIOException if an I/O error occurs
         */
        public void add(final PlaneConvexSubset boundary) {
            if (boundary.isInfinite()) {
                throw new IllegalArgumentException("OBJ input geometry cannot be infinite: " + boundary);
            } else if (!boundary.isEmpty()) {
                addFace(boundary.getVertices(), null);
            }
        }

        /** Add a vertex to the buffer.
         * @param vertex vertex to add
         * @return the index of the vertex in the buffer
         */
        public int addVertex(final Vector3D vertex) {
            return addToMap(vertex, vertexMap);
        }

        /** Add a normal to the buffer.
         * @param normal normal to add
         * @return the index of the normal in the buffer
         */
        public int addNormal(final Vector3D normal) {
            return addToMap(normal, normalMap);
        }

        /** Flush the buffer content to the output and reset its state.
         * @throws java.io.UncheckedIOException if an I/O error occurs
         */
        public void flush() {
            final int vertexOffset = vertexCount;
            final int normalOffset = normalCount;

            // write vertices
            for (final String vertexStr : vertexMap.keySet()) {
                writeVertexLine(vertexStr);
            }

            // write normals
            for (final String normalStr : normalMap.keySet()) {
                writeVertexNormalLine(normalStr);
            }

            // write faces
            Integer normalIndex;
            int[] normalIndices;
            int faceIndex = 0;
            for (final int[] vertexIndices : faceVertices) {
                normalIndex = faceToNormalMap.get(faceIndex);
                if (normalIndex != null) {
                    normalIndices = new int[vertexIndices.length];
                    Arrays.fill(normalIndices, normalIndex);
                } else {
                    normalIndices = null;
                }

                writeFaceWithOffsets(vertexOffset, vertexIndices, normalOffset, normalIndices);

                ++faceIndex;
            }

            reset();
        }

        /** Convert the given vector to on OBJ definition string and add it to the
         * map if not yet present. The mapped index of the vector is returned.
         * @param vec vector to add
         * @param map map to add the vector to
         * @return the index the vector entry is mapped to
         */
        private int addToMap(final Vector3D vec, final Map<String, Integer> map) {
            final String str = createVectorString(vec);

            return map.computeIfAbsent(str, k -> map.size());
        }

        /** Add a face to the buffer. If {@code batchSize} is greater than {@code -1} and the number
         * of currently stored faces is greater than or equal to {@code batchSize}, then the buffer
         * content is written to the output and the buffer state is reset.
         * @param vertices face vertices
         * @param normal face normal; may be null
         * @throws java.io.UncheckedIOException if an I/O error occurs
         */
        private void addFace(final List<Vector3D> vertices, final Vector3D normal) {
            final int faceIndex = faceVertices.size();

            final int[] vertexIndices = new int[vertices.size()];

            int i = -1;
            for (final Vector3D vertex : vertices) {
                vertexIndices[++i] = addVertex(vertex);
            }
            faceVertices.add(vertexIndices);

            if (normal != null) {
                faceToNormalMap.put(faceIndex, addNormal(normal));
            }

            if (batchSize > -1 && faceVertices.size() >= batchSize) {
                flush();
            }
        }

        /** Reset the buffer state.
         */
        private void reset() {
            vertexMap.clear();
            normalMap.clear();
            faceVertices.clear();
            faceToNormalMap.clear();
        }
    }
}