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

import javax.swing.text.MutableAttributeSet;

import java.io.PrintWriter;
import java.io.Writer;
import java.util.ArrayList;
import java.util.Collection;
import java.util.LinkedList;
import java.util.List;
import java.util.Stack;

import org.apache.commons.lang3.StringUtils;
import org.apache.maven.doxia.sink.SinkEventAttributes;
import org.apache.maven.doxia.sink.impl.AbstractTextSink;
import org.apache.maven.doxia.sink.impl.SinkEventAttributeSet;
import org.apache.maven.doxia.sink.impl.SinkUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * APT generator implementation.
 * <br>
 * <b>Note</b>: The encoding used is UTF-8.
 *
 * @author eredmond
 * @since 1.0
 */
public class AptSink extends AbstractTextSink implements AptMarkup {
    private static final Logger LOGGER = LoggerFactory.getLogger(AptSink.class);

    // ----------------------------------------------------------------------
    // Instance fields
    // ----------------------------------------------------------------------

    /**  A buffer that holds the current text when headerFlag or bufferFlag set to <code>true</code>. */
    private StringBuffer buffer;

    /**  A buffer that holds the table caption. */
    private StringBuilder tableCaptionBuffer;

    /**  authors. */
    private Collection<String> authors;

    /**  title. */
    private String title;

    /**  date. */
    private String date;

    /** startFlag. */
    private boolean startFlag;

    /**  tableCaptionFlag. */
    private boolean tableCaptionFlag;

    /**  tableCellFlag. */
    private boolean tableCellFlag;

    /**  headerFlag. */
    private boolean headerFlag;

    /**  bufferFlag. */
    private boolean bufferFlag;

    /**  itemFlag. */
    private boolean itemFlag;

    /**  verbatimFlag. */
    private boolean verbatimFlag;

    /**  verbatim source. */
    private boolean isSource;

    /**  gridFlag for tables. */
    private boolean gridFlag;

    /**  number of cells in a table. */
    private int cellCount;

    /**  The writer to use. */
    private final PrintWriter writer;

    /**  justification of table cells. */
    private int[] cellJustif;

    /**  a line of a row in a table. */
    private String rowLine;

    /**  listNestingIndent. */
    private String listNestingIndent;

    /**  listStyles. */
    private final Stack<String> listStyles;

    /** Keep track of the closing tags for inline events. */
    protected Stack<List<String>> inlineStack = new Stack<>();

    // ----------------------------------------------------------------------
    // Public protected methods
    // ----------------------------------------------------------------------

    /**
     * Constructor, initialize the Writer and the variables.
     *
     * @param writer not null writer to write the result. <b>Should</b> be an UTF-8 Writer.
     * You could use <code>newWriter</code> methods from {@code org.codehaus.plexus.util.WriterFactory}.
     */
    protected AptSink(Writer writer) {
        this.writer = new PrintWriter(writer);
        this.listStyles = new Stack<>();

        init();
    }

    /**
     * Returns the buffer that holds the current text.
     *
     * @return A StringBuffer.
     */
    protected StringBuffer getBuffer() {
        return buffer;
    }

    /**
     * Used to determine whether we are in head mode.
     *
     * @param headFlag True for head mode.
     */
    protected void setHeadFlag(boolean headFlag) {
        this.headerFlag = headFlag;
    }

    /**
     * {@inheritDoc}
     */
    protected void init() {
        super.init();

        resetBuffer();

        this.tableCaptionBuffer = new StringBuilder();
        this.listNestingIndent = "";

        this.authors = new LinkedList<>();
        this.title = null;
        this.date = null;
        this.startFlag = true;
        this.tableCaptionFlag = false;
        this.tableCellFlag = false;
        this.headerFlag = false;
        this.bufferFlag = false;
        this.itemFlag = false;
        this.verbatimFlag = false;
        this.isSource = false;
        this.gridFlag = false;
        this.cellCount = 0;
        this.cellJustif = null;
        this.rowLine = null;
        this.listStyles.clear();
        this.inlineStack.clear();
    }

    /**
     * Reset the StringBuilder.
     */
    protected void resetBuffer() {
        buffer = new StringBuffer();
    }

    /**
     * Reset the TableCaptionBuffer.
     */
    protected void resetTableCaptionBuffer() {
        tableCaptionBuffer = new StringBuilder();
    }

    @Override
    public void head(SinkEventAttributes attributes) {
        boolean startFlag = this.startFlag;

        init();

        headerFlag = true;
        this.startFlag = startFlag;
    }

    /**
     * {@inheritDoc}
     */
    public void head_() {
        headerFlag = false;

        if (!startFlag) {
            write(EOL);
        }
        write(HEADER_START_MARKUP + EOL);
        if (title != null) {
            write(" " + title + EOL);
        }
        write(HEADER_START_MARKUP + EOL);
        for (String author : authors) {
            write(" " + author + EOL);
        }
        write(HEADER_START_MARKUP + EOL);
        if (date != null) {
            write(" " + date + EOL);
        }
        write(HEADER_START_MARKUP + EOL);
    }

    /**
     * {@inheritDoc}
     */
    public void title_() {
        if (buffer.length() > 0) {
            title = buffer.toString();
            resetBuffer();
        }
    }

    /**
     * {@inheritDoc}
     */
    public void author_() {
        if (buffer.length() > 0) {
            authors.add(buffer.toString());
            resetBuffer();
        }
    }

    /**
     * {@inheritDoc}
     */
    public void date_() {
        if (buffer.length() > 0) {
            date = buffer.toString();
            resetBuffer();
        }
    }

    @Override
    public void section_(int level) {
        write(EOL);
    }

    @Override
    public void sectionTitle(int level, SinkEventAttributes attributes) {
        if (level > 5) {
            LOGGER.warn(
                    "{}Replacing unsupported section title level {} in APT with level 5",
                    getLocationLogPrefix(),
                    level);
            level = 5;
        }
        if (level == 1) {
            write(EOL);
        } else if (level > 1) {
            write(EOL + StringUtils.repeat(SECTION_TITLE_START_MARKUP, level - 1));
        }
    }

    @Override
    public void sectionTitle_(int level) {
        if (level >= 1) {
            write(EOL + EOL);
        }
    }

    @Override
    public void list(SinkEventAttributes attributes) {
        listNestingIndent += " ";
        listStyles.push(LIST_START_MARKUP);
        write(EOL);
    }

    /**
     * {@inheritDoc}
     */
    public void list_() {
        if (listNestingIndent.length() <= 1) {
            write(EOL + listNestingIndent + LIST_END_MARKUP + EOL);
        } else {
            write(EOL);
        }
        listNestingIndent = StringUtils.chomp(listNestingIndent, " ");
        listStyles.pop();
        itemFlag = false;
    }

    @Override
    public void listItem(SinkEventAttributes attributes) {
        // if (!numberedList)
        // write(EOL + listNestingIndent + "*");
        // else
        numberedListItem();
        itemFlag = true;
    }

    /**
     * {@inheritDoc}
     */
    public void listItem_() {
        write(EOL);
        itemFlag = false;
    }

    @Override
    public void numberedList(int numbering, SinkEventAttributes attributes) {
        listNestingIndent += " ";
        write(EOL);

        String style;
        switch (numbering) {
            case NUMBERING_UPPER_ALPHA:
                style = String.valueOf(NUMBERING_UPPER_ALPHA_CHAR);
                break;
            case NUMBERING_LOWER_ALPHA:
                style = String.valueOf(NUMBERING_LOWER_ALPHA_CHAR);
                break;
            case NUMBERING_UPPER_ROMAN:
                style = String.valueOf(NUMBERING_UPPER_ROMAN_CHAR);
                break;
            case NUMBERING_LOWER_ROMAN:
                style = String.valueOf(NUMBERING_LOWER_ROMAN_CHAR);
                break;
            case NUMBERING_DECIMAL:
            default:
                style = String.valueOf(NUMBERING);
        }

        listStyles.push(style);
    }

    /**
     * {@inheritDoc}
     */
    public void numberedList_() {
        if (listNestingIndent.length() <= 1) {
            write(EOL + listNestingIndent + LIST_END_MARKUP + EOL);
        } else {
            write(EOL);
        }
        listNestingIndent = StringUtils.chomp(listNestingIndent, " ");
        listStyles.pop();
        itemFlag = false;
    }

    @Override
    public void numberedListItem(SinkEventAttributes attributes) {
        String style = listStyles.peek();
        if (style.equals(String.valueOf(STAR))) {
            write(EOL + listNestingIndent + STAR + SPACE);
        } else {
            write(EOL
                    + listNestingIndent
                    + LEFT_SQUARE_BRACKET
                    + LEFT_SQUARE_BRACKET
                    + style
                    + RIGHT_SQUARE_BRACKET
                    + RIGHT_SQUARE_BRACKET
                    + SPACE);
        }
        itemFlag = true;
    }

    /**
     * {@inheritDoc}
     */
    public void numberedListItem_() {
        write(EOL);
        itemFlag = false;
    }

    @Override
    public void definitionList(SinkEventAttributes attributes) {
        listNestingIndent += " ";
        listStyles.push("");
        write(EOL);
    }

    /**
     * {@inheritDoc}
     */
    public void definitionList_() {
        if (listNestingIndent.length() <= 1) {
            write(EOL + listNestingIndent + LIST_END_MARKUP + EOL);
        } else {
            write(EOL);
        }
        listNestingIndent = StringUtils.chomp(listNestingIndent, " ");
        listStyles.pop();
        itemFlag = false;
    }

    @Override
    public void definedTerm(SinkEventAttributes attributes) {
        write(EOL + " [");
    }

    /**
     * {@inheritDoc}
     */
    public void definedTerm_() {
        write("] ");
    }

    @Override
    public void definition(SinkEventAttributes attributes) {
        itemFlag = true;
    }

    /**
     * {@inheritDoc}
     */
    public void definition_() {
        write(EOL);
        itemFlag = false;
    }

    /**
     * {@inheritDoc}
     */
    public void pageBreak() {
        write(EOL + PAGE_BREAK + EOL);
    }

    @Override
    public void paragraph(SinkEventAttributes attributes) {
        if (tableCellFlag) {
            // ignore paragraphs in table cells
        } else if (itemFlag) {
            write(EOL + EOL + "  " + listNestingIndent);
        } else {
            write(EOL + " ");
        }
    }

    /**
     * {@inheritDoc}
     */
    public void paragraph_() {
        if (tableCellFlag) {
            // ignore paragraphs in table cells
        } else {
            write(EOL + EOL);
        }
    }

    @Override
    public void verbatim(SinkEventAttributes attributes) {
        MutableAttributeSet atts = SinkUtils.filterAttributes(attributes, SinkUtils.SINK_VERBATIM_ATTRIBUTES);

        boolean source = false;

        if (atts != null && atts.isDefined(SinkEventAttributes.DECORATION)) {
            source = "source"
                    .equals(atts.getAttribute(SinkEventAttributes.DECORATION).toString());
        }

        verbatimFlag = true;
        this.isSource = source;
        write(EOL);
        if (source) {
            write(EOL + VERBATIM_SOURCE_START_MARKUP + EOL);
        } else {
            write(EOL + VERBATIM_START_MARKUP + EOL);
        }
    }

    /**
     * {@inheritDoc}
     */
    public void verbatim_() {
        if (isSource) {
            write(EOL + VERBATIM_SOURCE_END_MARKUP + EOL);
        } else {
            write(EOL + VERBATIM_END_MARKUP + EOL);
        }
        isSource = false;
        verbatimFlag = false;
    }

    @Override
    public void horizontalRule(SinkEventAttributes attributes) {
        write(EOL + HORIZONTAL_RULE_MARKUP + EOL);
    }

    @Override
    public void table(SinkEventAttributes attributes) {
        write(EOL);
    }

    /**
     * {@inheritDoc}
     */
    public void table_() {
        if (rowLine != null) {
            write(rowLine);
        }
        rowLine = null;

        if (tableCaptionBuffer.length() > 0) {
            text(tableCaptionBuffer.toString() + EOL);
        }

        resetTableCaptionBuffer();
    }

    @Override
    public void tableRows(int[] justification, boolean grid) {
        cellJustif = justification;
        gridFlag = grid;
    }

    /**
     * {@inheritDoc}
     */
    public void tableRows_() {
        cellJustif = null;
        gridFlag = false;
    }

    @Override
    public void tableRow(SinkEventAttributes attributes) {
        bufferFlag = true;
        cellCount = 0;
    }

    /**
     * {@inheritDoc}
     */
    public void tableRow_() {
        bufferFlag = false;

        // write out the header row first, then the data in the buffer
        buildRowLine();

        write(rowLine);

        // TODO: This will need to be more clever, for multi-line cells
        if (gridFlag) {
            write(TABLE_ROW_SEPARATOR_MARKUP);
        }

        write(buffer.toString());

        resetBuffer();

        write(EOL);

        // only reset cell count if this is the last row
        cellCount = 0;
    }

    /** Construct a table row. */
    private void buildRowLine() {
        StringBuilder rLine = new StringBuilder();
        rLine.append(TABLE_ROW_START_MARKUP);

        for (int i = 0; i < cellCount; i++) {
            if (cellJustif != null) {
                switch (cellJustif[i]) {
                    case 1:
                        rLine.append(TABLE_COL_LEFT_ALIGNED_MARKUP);
                        break;
                    case 2:
                        rLine.append(TABLE_COL_RIGHT_ALIGNED_MARKUP);
                        break;
                    default:
                        rLine.append(TABLE_COL_CENTERED_ALIGNED_MARKUP);
                }
            } else {
                rLine.append(TABLE_COL_CENTERED_ALIGNED_MARKUP);
            }
        }
        rLine.append(EOL);

        this.rowLine = rLine.toString();
    }

    @Override
    public void tableCell(SinkEventAttributes attributes) {
        tableCell(false);
    }

    @Override
    public void tableHeaderCell(SinkEventAttributes attributes) {
        tableCell(true);
    }

    /**
     * Starts a table cell.
     *
     * @param headerRow If this cell is part of a header row.
     */
    public void tableCell(boolean headerRow) {
        if (headerRow) {
            buffer.append(TABLE_CELL_SEPARATOR_MARKUP);
        }
        tableCellFlag = true;
    }

    /**
     * {@inheritDoc}
     */
    public void tableCell_() {
        endTableCell();
    }

    /**
     * {@inheritDoc}
     */
    public void tableHeaderCell_() {
        endTableCell();
    }

    /**
     * Ends a table cell.
     */
    private void endTableCell() {
        tableCellFlag = false;
        buffer.append(TABLE_CELL_SEPARATOR_MARKUP);
        cellCount++;
    }

    @Override
    public void tableCaption(SinkEventAttributes attributes) {
        tableCaptionFlag = true;
    }

    /**
     * {@inheritDoc}
     */
    public void tableCaption_() {
        tableCaptionFlag = false;
    }

    /**
     * {@inheritDoc}
     */
    public void figureCaption_() {
        write(EOL);
    }

    @Override
    public void figureGraphics(String name, SinkEventAttributes attributes) {
        write(EOL + "[" + name + "] ");
    }

    @Override
    public void anchor(String name, SinkEventAttributes attributes) {
        write(ANCHOR_START_MARKUP);
    }

    /**
     * {@inheritDoc}
     */
    public void anchor_() {
        write(ANCHOR_END_MARKUP);
    }

    @Override
    public void link(String name, SinkEventAttributes attributes) {
        if (!headerFlag) {
            write(LINK_START_1_MARKUP);
            text(name.startsWith("#") ? name.substring(1) : name);
            write(LINK_START_2_MARKUP);
        }
    }

    /**
     * {@inheritDoc}
     */
    public void link_() {
        if (!headerFlag) {
            write(LINK_END_MARKUP);
        }
    }

    /**
     * A link with a target.
     *
     * @param name The name of the link.
     * @param target The link target.
     */
    public void link(String name, String target) {
        if (!headerFlag) {
            write(LINK_START_1_MARKUP);
            text(target);
            write(LINK_START_2_MARKUP);
            text(name);
        }
    }

    /** {@inheritDoc} */
    public void inline(SinkEventAttributes attributes) {
        if (!headerFlag) {
            List<String> tags = new ArrayList<>();

            if (attributes != null) {

                if (attributes.containsAttribute(SinkEventAttributes.SEMANTICS, "italic")) {
                    write(ITALIC_START_MARKUP);
                    tags.add(0, ITALIC_END_MARKUP);
                }

                if (attributes.containsAttribute(SinkEventAttributes.SEMANTICS, "bold")) {
                    write(BOLD_START_MARKUP);
                    tags.add(0, BOLD_END_MARKUP);
                }

                if (attributes.containsAttribute(SinkEventAttributes.SEMANTICS, "code")) {
                    write(MONOSPACED_START_MARKUP);
                    tags.add(0, MONOSPACED_END_MARKUP);
                }
            }

            inlineStack.push(tags);
        }
    }

    /**
     * {@inheritDoc}
     */
    public void inline_() {
        if (!headerFlag) {
            for (String tag : inlineStack.pop()) {
                write(tag);
            }
        }
    }

    /**
     * {@inheritDoc}
     */
    public void italic() {
        inline(SinkEventAttributeSet.Semantics.ITALIC);
    }

    /**
     * {@inheritDoc}
     */
    public void italic_() {
        inline_();
    }

    /**
     * {@inheritDoc}
     */
    public void bold() {
        inline(SinkEventAttributeSet.Semantics.BOLD);
    }

    /**
     * {@inheritDoc}
     */
    public void bold_() {
        inline_();
    }

    /**
     * {@inheritDoc}
     */
    public void monospaced() {
        inline(SinkEventAttributeSet.Semantics.CODE);
    }

    /**
     * {@inheritDoc}
     */
    public void monospaced_() {
        inline_();
    }

    @Override
    public void lineBreak(SinkEventAttributes attributes) {
        if (headerFlag || bufferFlag) {
            buffer.append(EOL);
        } else if (verbatimFlag) {
            write(EOL);
        } else {
            write("\\" + EOL);
        }
    }

    /**
     * {@inheritDoc}
     */
    public void nonBreakingSpace() {
        if (headerFlag || bufferFlag) {
            buffer.append(NON_BREAKING_SPACE_MARKUP);
        } else {
            write(NON_BREAKING_SPACE_MARKUP);
        }
    }

    @Override
    public void text(String text, SinkEventAttributes attributes) {
        if (attributes != null) {
            inline(attributes);
        }
        if (tableCaptionFlag) {
            tableCaptionBuffer.append(text);
        } else if (headerFlag || bufferFlag) {
            buffer.append(text);
        } else if (verbatimFlag) {
            verbatimContent(text);
        } else {
            content(text);
        }
        if (attributes != null) {
            inline_();
        }
    }

    /** {@inheritDoc} */
    public void rawText(String text) {
        write(text);
    }

    /** {@inheritDoc} */
    public void comment(String comment) {
        rawText((startFlag ? "" : EOL) + COMMENT + COMMENT + comment);
    }

    /**
     * {@inheritDoc}
     *
     * Unkown events just log a warning message but are ignored otherwise.
     * @see org.apache.maven.doxia.sink.Sink#unknown(String,Object[],SinkEventAttributes)
     */
    public void unknown(String name, Object[] requiredParams, SinkEventAttributes attributes) {
        LOGGER.warn("{}Unknown Sink event '{}', ignoring!", getLocationLogPrefix(), name);
    }

    /**
     * Write text to output.
     *
     * @param text The text to write.
     */
    protected void write(String text) {
        startFlag = false;
        if (tableCellFlag) {
            buffer.append(text);
        } else {
            writer.write(unifyEOLs(text));
        }
    }

    /**
     * Write Apt escaped text to output.
     *
     * @param text The text to write.
     */
    protected void content(String text) {
        write(escapeAPT(text));
    }

    /**
     * Write Apt escaped text to output.
     *
     * @param text The text to write.
     */
    protected void verbatimContent(String text) {
        write(escapeAPT(text));
    }

    /**
     * {@inheritDoc}
     */
    public void flush() {
        writer.flush();
    }

    /**
     * {@inheritDoc}
     */
    public void close() {
        writer.close();

        init();
    }

    // ----------------------------------------------------------------------
    // Private methods
    // ----------------------------------------------------------------------

    /**
     * Escape special characters in a text in APT:
     *
     * <pre>
     * \~, \=, \-, \+, \*, \[, \], \<, \>, \{, \}, \\
     * </pre>
     *
     * @param text the String to escape, may be null
     * @return the text escaped, "" if null String input
     */
    private static String escapeAPT(String text) {
        if (text == null) {
            return "";
        }

        int length = text.length();
        StringBuilder buffer = new StringBuilder(length);

        for (int i = 0; i < length; ++i) {
            char c = text.charAt(i);
            switch (c) { // 0080
                case '\\':
                case '~':
                case '=':
                case '-':
                case '+':
                case '*':
                case '[':
                case ']':
                case '<':
                case '>':
                case '{':
                case '}':
                    buffer.append('\\');
                    buffer.append(c);
                    break;
                default:
                    buffer.append(c);
            }
        }

        return buffer.toString();
    }
}