/*
 * 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.maven.doxia.module;

import java.io.IOException;
import java.io.StringReader;
import java.io.StringWriter;
import java.io.Writer;

import org.apache.maven.doxia.AbstractModuleTest;
import org.apache.maven.doxia.parser.ParseException;
import org.apache.maven.doxia.parser.Parser;
import org.apache.maven.doxia.sink.Sink;
import org.apache.maven.doxia.sink.impl.SinkTestDocument;
import org.apache.maven.doxia.sink.impl.TextSink;
import org.junit.jupiter.api.Test;

import static org.junit.jupiter.api.Assertions.assertEquals;

/**
 * If a module provides both Parser and Sink, this class
 * can be used to check that chaining them together
 * results in the identity transformation, ie the model is still the same
 * after being piped through a Parser and the corresponding Sink.
 */
public abstract class AbstractIdentityTest extends AbstractModuleTest {
    /** Expected Identity String */
    private String expected;

    /**
     * Set to true if the identity transformation should actually be asserted,
     * by default only the expected and actual results are written to a file, but not compared.
     */
    private boolean assertIdentity;

    /**
     * Create a new instance of the parser to test.
     *
     * @return the parser to test.
     */
    protected abstract Parser createParser();

    /**
     * Return a new instance of the sink that is being tested.
     *
     * @param writer The writer for the sink.
     * @return A new sink.
     */
    protected abstract Sink createSink(Writer writer);

    /**
     * Pipes a full model generated by {@link SinkTestDocument} through
     * a Sink (generated by {@link #createSink(Writer)}) and a Parser
     * (generated by {@link #createParser()}) and checks if the result
     * is the same as the original model. By default, this doesn't actually
     * assert anything (use {@link #assertIdentity(boolean)} in the setUp()
     * of an implementation to switch on the test), but the two generated
     * output files, expected.txt and actual.txt, can be compared for differences.
     *
     * @throws IOException if there's a problem reading/writing a test file.
     * @throws ParseException if a model cannot be parsed.
     */
    @Test
    public void identity() throws Exception {
        // generate the expected model
        StringWriter writer = new StringWriter();
        Sink sink = new TextSink(writer);
        SinkTestDocument.generate(sink);
        sink.close();
        expected = writer.toString();

        // write to file for comparison
        try (Writer fileWriter = getTestWriter("expectedTextSink")) {
            fileWriter.write(expected);
        }
        // generate the actual model
        writer = new StringWriter();
        sink = createSink(writer);
        SinkTestDocument.generate(sink);
        sink.close();

        String expectedViaTargetSink = writer.toString();
        // write to file for comparison
        try (Writer fileWriter = getTestWriter("expectedTargetSink")) {
            fileWriter.write(expectedViaTargetSink);
        }
        StringReader reader = new StringReader(expectedViaTargetSink);
        writer = new StringWriter();
        sink = new TextSink(writer);
        Parser parser = createParser();
        parser.parse(reader, sink);
        String actual = writer.toString();

        // write to file for comparison
        try (Writer fileWriter = getTestWriter("actualTextSink")) {
            fileWriter.write(actual);
        }

        // Disabled by default, it's unlikely that all our modules
        // will pass this test any time soon, but the generated
        // output files can still be compared.

        if (assertIdentity) {
            // TODO: make this work for at least apt and xdoc modules?
            assertEquals(
                    getExpected(),
                    actual,
                    "Identity test failed! See results in "
                            + getTestWriterFile("actual").getParent());
        }
    }

    protected String getOutputDir() {
        return "identity/";
    }

    /**
     * The output files generated by this class are text files,
     * independent of the kind of module being tested.
     *
     * @return The String "txt".
     */
    protected String outputExtension() {
        return "txt";
    }

    /**
     * Set to true if the identity transformation should actually be asserted,
     * by default only the expected and actual results are written to a file, but not compared.
     * This should be called during setUp().
     *
     * @param doAssert True to actually execute the test.
     */
    protected void assertIdentity(boolean doAssert) {
        this.assertIdentity = doAssert;
    }

    /**
     * @return the expected identity string
     */
    protected String getExpected() {
        return expected;
    }
}
