/*
 * 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.stl;

import java.io.Closeable;
import java.io.OutputStream;
import java.nio.ByteBuffer;

import org.apache.commons.geometry.euclidean.threed.Vector3D;
import org.apache.commons.geometry.io.core.internal.GeometryIOUtils;

/** Low-level class for writing binary STL content.
 */
public class BinaryStlWriter implements Closeable {

    /** Output stream to write to. */
    private final OutputStream out;

    /** Buffer used to construct triangle definitions. */
    private final ByteBuffer triangleBuffer = StlUtils.byteBuffer(StlConstants.BINARY_TRIANGLE_BYTES);

    /** Construct a new instance for writing to the given output.
     * @param out output stream to write to
     */
    public BinaryStlWriter(final OutputStream out) {
        this.out = out;
    }

    /** Write binary STL header content. If {@code headerContent} is null, the written header
     * will consist entirely of zeros. Otherwise, up to 80 bytes from {@code headerContent}
     * are written to the header, with any remaining bytes of the header filled with zeros.
     * @param headerContent bytes to include in the header; may be null
     * @param triangleCount number of triangles to be included in the content
     * @throws java.io.UncheckedIOException if an I/O error occurs
     */
    public void writeHeader(final byte[] headerContent, final int triangleCount) {
        writeHeader(headerContent, triangleCount, out);
    }

    /** Write a triangle to the output using a default attribute value of 0.
     * Callers are responsible for ensuring that the number of triangles written
     * matches the number given in the header.
     *
     * <p>If a normal is given, the vertices are ordered using the right-hand rule,
     * meaning that they will be in a counter-clockwise orientation when looking down
     * the normal. Thus, the given point ordering may not be the ordering used in
     * the written content.</p>
     * @param p1 first point
     * @param p2 second point
     * @param p3 third point
     * @param normal triangle normal; may be null
     * @throws java.io.UncheckedIOException if an I/O error occurs
     */
    public void writeTriangle(final Vector3D p1, final Vector3D p2, final Vector3D p3,
            final Vector3D normal) {
        writeTriangle(p1, p2, p3, normal, 0);
    }

    /** Write a triangle to the output. Callers are responsible for ensuring
     * that the number of triangles written matches the number given in the header.
     *
     * <p>If a non-zero normal is given, the vertices are ordered using the right-hand rule,
     * meaning that they will be in a counter-clockwise orientation when looking down
     * the normal. If no normal is given, or the given value cannot be normalized, a normal
     * is computed from the triangle vertices, also using the right-hand rule. If this also
     * fails (for example, if the triangle vertices do not define a plane), then the
     * zero vector is used.</p>
     * @param p1 first point
     * @param p2 second point
     * @param p3 third point
     * @param normal triangle normal; may be null
     * @param attributeValue 2-byte STL triangle attribute value
     * @throws java.io.UncheckedIOException if an I/O error occurs
     */
    public void writeTriangle(final Vector3D p1, final Vector3D p2, final Vector3D p3,
            final Vector3D normal, final int attributeValue) {
        triangleBuffer.rewind();

        putVector(StlUtils.determineNormal(p1, p2, p3, normal));
        putVector(p1);

        if (StlUtils.pointsAreCounterClockwise(p1, p2, p3, normal)) {
            putVector(p2);
            putVector(p3);
        } else {
            putVector(p3);
            putVector(p2);
        }

        triangleBuffer.putShort((short) attributeValue);

        GeometryIOUtils.acceptUnchecked(out::write, triangleBuffer.array());
    }

    /** {@inheritDoc} */
    @Override
    public void close() {
        GeometryIOUtils.closeUnchecked(out);
    }

    /** Put all double components of {@code vec} into the internal buffer.
     * @param vec vector to place into the buffer
     */
    private void putVector(final Vector3D vec) {
        triangleBuffer.putFloat((float) vec.getX());
        triangleBuffer.putFloat((float) vec.getY());
        triangleBuffer.putFloat((float) vec.getZ());
    }

    /** Write binary STL header content to the given output stream. If {@code headerContent}
     * is null, the written header will consist entirely of zeros. Otherwise, up to 80 bytes
     * from {@code headerContent} are written to the header, with any remaining bytes of the
     * header filled with zeros.
     * @param headerContent
     * @param triangleCount
     * @param out
     * @throws java.io.UncheckedIOException if an I/O error occurs
     */
    static void writeHeader(final byte[] headerContent, final int triangleCount, final OutputStream out) {
        // write the header
        final byte[] bytes = new byte[StlConstants.BINARY_HEADER_BYTES];
        if (headerContent != null) {
            System.arraycopy(
                    headerContent, 0,
                    bytes, 0,
                    Math.min(headerContent.length, StlConstants.BINARY_HEADER_BYTES));
        }

        GeometryIOUtils.acceptUnchecked(out::write, bytes);

        // write the triangle count number
        ByteBuffer countBuffer = StlUtils.byteBuffer(Integer.BYTES);
        countBuffer.putInt(triangleCount);
        countBuffer.flip();

        GeometryIOUtils.acceptUnchecked(out::write, countBuffer.array());
    }
}