/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license at legal-notices/CDDLv1_0.txt
 * or http://forgerock.org/license/CDDLv1.0.html.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at legal-notices/CDDLv1_0.txt.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information:
 *      Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 *
 *
 *      Copyright 2009 Sun Microsystems, Inc.
 *      Portions copyright 2011-2013 ForgeRock AS
 */

package org.forgerock.opendj.ldif;

import java.io.BufferedWriter;
import java.io.IOException;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.Writer;
import java.util.List;
import java.util.regex.Pattern;

import org.forgerock.opendj.ldap.ByteSequence;
import org.forgerock.opendj.ldap.ByteString;
import org.forgerock.opendj.ldap.controls.Control;

import com.forgerock.opendj.util.Validator;

/**
 * Common LDIF writer functionality.
 */
abstract class AbstractLDIFWriter extends AbstractLDIFStream {

    /**
     * LDIF writer implementation interface.
     */
    interface LDIFWriterImpl {

        /**
         * Closes any resources associated with this LDIF writer implementation.
         *
         * @throws IOException
         *             If an error occurs while closing.
         */
        void close() throws IOException;

        /**
         * Flushes this LDIF writer implementation so that any buffered data is
         * written immediately to underlying stream, flushing the stream if it
         * is also {@code Flushable}.
         * <p>
         * If the intended destination of this stream is an abstraction provided
         * by the underlying operating system, for example a file, then flushing
         * the stream guarantees only that bytes previously written to the
         * stream are passed to the operating system for writing; it does not
         * guarantee that they are actually written to a physical device such as
         * a disk drive.
         *
         * @throws IOException
         *             If an error occurs while flushing.
         */
        void flush() throws IOException;

        /**
         * Prints the provided {@code CharSequence}. Implementations must not
         * add a new-line character sequence.
         *
         * @param s
         *            The {@code CharSequence} to be printed.
         * @throws IOException
         *             If an error occurs while printing {@code s}.
         */
        void print(CharSequence s) throws IOException;

        /**
         * Prints a new-line character sequence.
         *
         * @throws IOException
         *             If an error occurs while printing the new-line character
         *             sequence.
         */
        void println() throws IOException;
    }

    /**
     * LDIF string list writer implementation.
     */
    private static final class LDIFWriterListImpl implements LDIFWriterImpl {
        private final StringBuilder builder = new StringBuilder();
        private final List<String> ldifLines;

        LDIFWriterListImpl(final List<String> ldifLines) {
            this.ldifLines = ldifLines;
        }

        @Override
        public void close() throws IOException {
            // Nothing to do.
        }

        @Override
        public void flush() throws IOException {
            // Nothing to do.
        }

        @Override
        public void print(final CharSequence s) throws IOException {
            builder.append(s);
        }

        @Override
        public void println() throws IOException {
            ldifLines.add(builder.toString());
            builder.setLength(0);
        }
    }

    /**
     * LDIF output stream writer implementation.
     */
    private static final class LDIFWriterOutputStreamImpl implements LDIFWriterImpl {
        private final BufferedWriter writer;

        LDIFWriterOutputStreamImpl(final Writer writer) {
            this.writer =
                    writer instanceof BufferedWriter ? (BufferedWriter) writer
                            : new BufferedWriter(writer);
        }

        @Override
        public void close() throws IOException {
            writer.close();
        }

        @Override
        public void flush() throws IOException {
            writer.flush();
        }

        @Override
        public void print(final CharSequence s) throws IOException {
            writer.append(s);
        }

        @Override
        public void println() throws IOException {
            writer.newLine();
        }
    }

    /*
     * Regular expression used for splitting comments on line-breaks.
     */
    private static final Pattern SPLIT_NEWLINE = Pattern.compile("\\r?\\n");
    boolean addUserFriendlyComments = false;
    final LDIFWriterImpl impl;
    int wrapColumn = 0;
    private final StringBuilder builder = new StringBuilder(80);

    AbstractLDIFWriter(final List<String> ldifLines) {
        this.impl = new LDIFWriterListImpl(ldifLines);
    }

    AbstractLDIFWriter(final OutputStream out) {
        this(new OutputStreamWriter(out));
    }

    AbstractLDIFWriter(final Writer writer) {
        this.impl = new LDIFWriterOutputStreamImpl(writer);
    }

    final void close0() throws IOException {
        flush0();
        impl.close();
    }

    final void flush0() throws IOException {
        impl.flush();
    }

    final void writeComment0(final CharSequence comment) throws IOException {
        Validator.ensureNotNull(comment);

        /*
         * First, break up the comment into multiple lines to preserve the
         * original spacing that it contained.
         */
        final String[] lines = SPLIT_NEWLINE.split(comment);

        /*
         * Now iterate through the lines and write them out, prefixing and
         * wrapping them as necessary.
         */
        for (final String line : lines) {
            if (!shouldWrap()) {
                impl.print("# ");
                impl.print(line);
                impl.println();
            } else {
                final int breakColumn = wrapColumn - 2;
                if (line.length() <= breakColumn) {
                    impl.print("# ");
                    impl.print(line);
                    impl.println();
                } else {
                    int startPos = 0;
                outerLoop:
                    while (startPos < line.length()) {
                        if (startPos + breakColumn >= line.length()) {
                            impl.print("# ");
                            impl.print(line.substring(startPos));
                            impl.println();
                            startPos = line.length();
                        } else {
                            final int endPos = startPos + breakColumn;
                            int i = endPos - 1;
                            while (i > startPos) {
                                if (line.charAt(i) == ' ') {
                                    impl.print("# ");
                                    impl.print(line.substring(startPos, i));
                                    impl.println();

                                    startPos = i + 1;
                                    continue outerLoop;
                                }
                                i--;
                            }

                            /*
                             * If we've gotten here, then there are no spaces on
                             * the entire line. If that happens, then we'll have
                             * to break in the middle of a word.
                             */
                            impl.print("# ");
                            impl.print(line.substring(startPos, endPos));
                            impl.println();
                            startPos = endPos;
                        }
                    }
                }
            }
        }
    }

    final void writeControls(final List<Control> controls) throws IOException {
        for (final Control control : controls) {
            final StringBuilder key = new StringBuilder("control: ");
            key.append(control.getOID());
            key.append(control.isCritical() ? " true" : " false");
            if (control.hasValue()) {
                writeKeyAndValue(key, control.getValue());
            } else {
                writeLine(key);
            }
        }
    }

    final void writeKeyAndValue(final CharSequence key, final ByteSequence value)
            throws IOException {
        builder.setLength(0);

        /*
         * If the value is empty, then just append a single colon and a single
         * space.
         */
        if (value.length() == 0) {
            builder.append(key);
            builder.append(": ");
        } else if (needsBase64Encoding(value)) {
            if (addUserFriendlyComments) {
                /*
                 * TODO: Only display comments for valid UTF-8 values, not
                 * binary values.
                 */
            }
            builder.setLength(0);
            builder.append(key);
            builder.append(":: ");
            builder.append(value.toBase64String());
        } else {
            builder.append(key);
            builder.append(": ");
            builder.append(value.toString());
        }
        writeLine(builder);
    }

    final void writeKeyAndValue(final CharSequence key, final CharSequence value)
            throws IOException {
        // FIXME: We should optimize this at some point.
        writeKeyAndValue(key, ByteString.valueOf(value.toString()));
    }

    final void writeLine(final CharSequence line) throws IOException {
        final int length = line.length();
        if (shouldWrap() && length > wrapColumn) {
            impl.print(line.subSequence(0, wrapColumn));
            impl.println();
            int pos = wrapColumn;
            while (pos < length) {
                final int writeLength = Math.min(wrapColumn - 1, length - pos);
                impl.print(" ");
                impl.print(line.subSequence(pos, pos + writeLength));
                impl.println();
                pos += wrapColumn - 1;
            }
        } else {
            impl.print(line);
            impl.println();
        }
    }

    private boolean needsBase64Encoding(final ByteSequence bytes) {
        final int length = bytes.length();
        if (length == 0) {
            return false;
        }

        /*
         * If the value starts with a space, colon, or less than, then it needs
         * to be base64 encoded.
         */
        switch (bytes.byteAt(0)) {
        case 0x20: // Space
        case 0x3A: // Colon
        case 0x3C: // Less-than
            return true;
        }

        /*
         * If the value ends with a space, then it needs to be base64 encoded.
         */
        if (length > 1 && bytes.byteAt(length - 1) == 0x20) {
            return true;
        }

        /*
         * If the value contains a null, newline, or return character, then it
         * needs to be base64 encoded.
         */
        byte b;
        for (int i = 0; i < bytes.length(); i++) {
            b = bytes.byteAt(i);
            if (b > 127 || b < 0) {
                return true;
            }

            switch (b) {
            case 0x00: // Null
            case 0x0A: // New line
            case 0x0D: // Carriage return
                return true;
            }
        }

        /* If we've made it here, then there's no reason to base64 encode. */
        return false;
    }

    private boolean shouldWrap() {
        return wrapColumn > 1;
    }

    @SuppressWarnings("unused")
    private void writeKeyAndURL(final CharSequence key, final CharSequence url) throws IOException {
        builder.setLength(0);
        builder.append(key);
        builder.append(":: ");
        builder.append(url);
        writeLine(builder);
    }
}