/*
 * The contents of this file are subject to the terms of the Common Development and
 * Distribution License (the License). You may not use this file except in compliance with the
 * License.
 *
 * You can obtain a copy of the License at legal/CDDLv1.0.txt. See the License for the
 * specific language governing permission and limitations under the License.
 *
 * When distributing Covered Software, include this CDDL Header Notice in each file and include
 * the License file at legal/CDDLv1.0.txt. If applicable, add the following below the CDDL
 * Header, with the fields enclosed by brackets [] replaced by your own identifying
 * information: "Portions Copyright [year] [name of copyright owner]".
 *
 * Copyright 2006-2009 Sun Microsystems, Inc.
 * Portions Copyright 2014-2016 ForgeRock AS.
 */

package com.forgerock.opendj.ldap.tools;

import static com.forgerock.opendj.cli.CliMessages.ERR_FILEARG_NO_SUCH_FILE;
import static com.forgerock.opendj.cli.CommonArguments.showUsageArgument;
import static com.forgerock.opendj.cli.ToolVersionHandler.newSdkVersionHandler;
import static com.forgerock.opendj.cli.Utils.throwIfArgumentsConflict;
import static com.forgerock.opendj.ldap.CoreMessages.ERR_BASE64_DECODE_INVALID_LENGTH;
import static com.forgerock.opendj.ldap.tools.LDAPToolException.newToolException;
import static com.forgerock.opendj.ldap.tools.LDAPToolException.newToolExceptionAlreadyPrinted;
import static com.forgerock.opendj.ldap.tools.LDAPToolException.newToolParamException;
import static com.forgerock.opendj.ldap.tools.ToolsMessages.*;
import static com.forgerock.opendj.ldap.tools.Utils.parseArguments;
import static com.forgerock.opendj.ldap.tools.Utils.runToolAndExit;
import static com.forgerock.opendj.util.StaticUtils.getExceptionMessage;
import static org.forgerock.util.Utils.closeSilently;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.ByteArrayOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.io.UnsupportedEncodingException;
import java.util.ArrayList;
import java.util.List;
import java.util.StringTokenizer;

import com.forgerock.opendj.cli.ArgumentException;
import com.forgerock.opendj.cli.BooleanArgument;
import com.forgerock.opendj.cli.StringArgument;
import com.forgerock.opendj.cli.SubCommand;
import com.forgerock.opendj.cli.SubCommandArgumentParser;
import org.forgerock.opendj.ldap.ResultCode;
import org.forgerock.util.annotations.VisibleForTesting;

/**
 * Tool that can be used for performing base64 encoding and decoding.
 * <p>
 * Base64 is a mechanism for encoding binary data in ASCII form by converting
 * sets of three bytes with eight significant bits each to sets of four bytes
 * with six significant bits each.
 */
public final class Base64 extends ToolConsoleApplication {

    /**
     * The main method for base64 tool.
     *
     * @param args
     *            The command-line arguments provided to this program.
     */
    public static void main(final String[] args) {
        runToolAndExit(new Base64(System.out, System.err), args);
    }

    @VisibleForTesting
    Base64(final PrintStream out, final PrintStream err) {
        super(out, err);
    }

    @Override
    public boolean isInteractive() {
        return false;
    }

    @Override
    int run(final String... args) throws LDAPToolException {
        final SubCommandArgumentParser argParser =
                new SubCommandArgumentParser(Base64.class.getName(), INFO_BASE64_TOOL_DESCRIPTION.get(), false);
        argParser.setShortToolDescription(REF_SHORT_DESC_BASE64.get());
        argParser.setVersionHandler(newSdkVersionHandler());

        final BooleanArgument showUsage;

        final SubCommand decodeSubCommand;
        final StringArgument encodedData;
        final StringArgument encodedFile;
        final StringArgument toRawFile;

        final SubCommand encodeSubCommand;
        final StringArgument rawData;
        final StringArgument rawFile;
        final StringArgument toEncodedFile;

        try {
            decodeSubCommand = new SubCommand(argParser, "decode", INFO_BASE64_DECODE_DESCRIPTION.get());
            encodeSubCommand = new SubCommand(argParser, "encode", INFO_BASE64_ENCODE_DESCRIPTION.get());

            encodedData = StringArgument.builder("encodedData")
                    .shortIdentifier('d')
                    .description(INFO_BASE64_ENCODED_DATA_DESCRIPTION.get())
                    .valuePlaceholder(INFO_DATA_PLACEHOLDER.get())
                    .buildAndAddToSubCommand(decodeSubCommand);

            encodedFile = StringArgument.builder("encodedDataFile")
                    .shortIdentifier('f')
                    .description(INFO_BASE64_ENCODED_FILE_DESCRIPTION.get())
                    .valuePlaceholder(INFO_PATH_PLACEHOLDER.get())
                    .buildAndAddToSubCommand(decodeSubCommand);

            toRawFile = StringArgument.builder("toRawFile")
                    .shortIdentifier('o')
                    .description(INFO_BASE64_TO_RAW_FILE_DESCRIPTION.get())
                    .valuePlaceholder(INFO_PATH_PLACEHOLDER.get())
                    .buildAndAddToSubCommand(decodeSubCommand);

            rawData = StringArgument.builder("rawData")
                    .shortIdentifier('d')
                    .description(INFO_BASE64_RAW_DATA_DESCRIPTION.get())
                    .valuePlaceholder(INFO_DATA_PLACEHOLDER.get())
                    .buildAndAddToSubCommand(encodeSubCommand);

            rawFile = StringArgument.builder("rawDataFile")
                    .shortIdentifier('f')
                    .description(INFO_BASE64_RAW_FILE_DESCRIPTION.get())
                    .valuePlaceholder(INFO_PATH_PLACEHOLDER.get())
                    .buildAndAddToSubCommand(encodeSubCommand);

            toEncodedFile = StringArgument.builder("toEncodedFile")
                    .shortIdentifier('o')
                    .description(INFO_BASE64_TO_ENCODED_FILE_DESCRIPTION.get())
                    .valuePlaceholder(INFO_PATH_PLACEHOLDER.get())
                    .buildAndAddToSubCommand(encodeSubCommand);

            final List<SubCommand> subCommandList = new ArrayList<>(2);
            subCommandList.add(decodeSubCommand);
            subCommandList.add(encodeSubCommand);

            showUsage = showUsageArgument();
            argParser.addGlobalArgument(showUsage);
            argParser.setUsageGroupArgument(showUsage, subCommandList);
            argParser.setUsageArgument(showUsage, getOutputStream());
        } catch (final ArgumentException ae) {
            throw newToolParamException(ae, ERR_CANNOT_INITIALIZE_ARGS.get(ae.getMessage()));
        }

        parseArguments(argParser, getErrStream(), args);
        if (argParser.usageOrVersionDisplayed()) {
            return ResultCode.SUCCESS.intValue();
        }

        try {
            throwIfArgumentsConflict(encodedData, encodedFile);
            throwIfArgumentsConflict(rawData, rawFile);
        } catch (final ArgumentException e) {
            argParser.displayMessageAndUsageReference(getErrStream(), ERR_ERROR_PARSING_ARGS.get(e.getMessage()));
            throw newToolParamException(e, e.getMessageObject());
        }

        final SubCommand subCommand = argParser.getSubCommand();
        if (subCommand == null) {
            argParser.displayMessageAndUsageReference(getErrStream(), ERR_BASE64_NO_SUBCOMMAND_SPECIFIED.get());
            throw newToolExceptionAlreadyPrinted(null, ResultCode.CLIENT_SIDE_PARAM_ERROR);
        }

        if (subCommand.getName().equals(encodeSubCommand.getName())) {
            return encode(rawData, rawFile, toEncodedFile);
        } else if (subCommand.getName().equals(decodeSubCommand.getName())) {
            return decode(encodedData, encodedFile, toRawFile);
        } else {
            argParser.displayMessageAndUsageReference(
                    getErrStream(), ERR_BASE64_UNKNOWN_SUBCOMMAND.get(subCommand.getName()));
            throw newToolExceptionAlreadyPrinted(null, ResultCode.CLIENT_SIDE_PARAM_ERROR);
        }
    }

    private int encode(final StringArgument rawDataArg,
                       final StringArgument rawDataFilePathArg,
                       final StringArgument toEncodeFilePathArg) throws LDAPToolException {
        byte[] dataToEncode;
        if (rawDataArg.isPresent()) {
            try {
                dataToEncode = rawDataArg.getValue().getBytes("UTF-8");
            } catch (final UnsupportedEncodingException e) {
                throw newToolException(e, ResultCode.OPERATIONS_ERROR,
                                       ERR_BASE64_ERROR_DECODING_RAW_DATA.get(e.getMessage()));
            }
        } else {
            final boolean readFromFile = rawDataFilePathArg.isPresent();
            InputStream inputStream = null;
            final String rawDataFilePath = rawDataFilePathArg.getValue();
            try {
                inputStream = readFromFile ? new FileInputStream(rawDataFilePath) : getInputStream();
                final ByteArrayOutputStream baos = new ByteArrayOutputStream();
                byte[] buffer = new byte[8192];
                int bytesRead;
                while ((bytesRead = inputStream.read(buffer)) >= 0) {
                    baos.write(buffer, 0, bytesRead);
                }

                dataToEncode = baos.toByteArray();
            } catch (final FileNotFoundException e) {
                throw newToolParamException(
                        e, ERR_FILEARG_NO_SUCH_FILE.get(rawDataFilePath, rawDataFilePathArg.getLongIdentifier()));
            } catch (final Exception e) {
                throw newToolException(e, ResultCode.OPERATIONS_ERROR,
                                       ERR_BASE64_CANNOT_READ_RAW_DATA.get(getExceptionMessage(e)));
            } finally {
                if (readFromFile) {
                    closeSilently(inputStream);
                }
            }
        }

        final String base64Data = org.forgerock.util.encode.Base64.encode(dataToEncode);
        if (toEncodeFilePathArg.isPresent()) {
            try (final BufferedWriter writer = new BufferedWriter(new FileWriter(toEncodeFilePathArg.getValue()))) {
                writer.write(base64Data);
                writer.newLine();
            } catch (final Exception e) {
                throw newToolException(e, ResultCode.OPERATIONS_ERROR,
                                       ERR_BASE64_CANNOT_WRITE_ENCODED_DATA.get(getExceptionMessage(e)));
            }
        } else {
            getOutputStream().println(base64Data);
        }
        return ResultCode.SUCCESS.intValue();
    }

    private int decode(final StringArgument encodedDataArg,
                       final StringArgument encodedDataFilePathArg,
                       final StringArgument toRawFilePathArg) throws LDAPToolException {
        String dataToDecode = null;
        if (encodedDataArg.isPresent()) {
            dataToDecode = encodedDataArg.getValue();
        } else {
            final boolean readFromFile = encodedDataFilePathArg.isPresent();
            BufferedReader reader = null;
            final String encodedDataFilePath = encodedDataFilePathArg.getValue();
            try {
                reader = new BufferedReader(readFromFile ? new FileReader(encodedDataFilePath)
                                                         : new InputStreamReader(System.in));
                final StringBuilder buffer = new StringBuilder();
                String line;
                while ((line = reader.readLine()) != null) {
                    final StringTokenizer tokenizer = new StringTokenizer(line);
                    while (tokenizer.hasMoreTokens()) {
                        buffer.append(tokenizer.nextToken());
                    }
                }

                dataToDecode = buffer.toString();
            } catch (final FileNotFoundException e) {
                throw newToolParamException(
                        e, ERR_FILEARG_NO_SUCH_FILE.get(encodedDataFilePath,
                                                        encodedDataFilePathArg.getLongIdentifier()));
            } catch (final Exception e) {
                throw newToolException(e, ResultCode.OPERATIONS_ERROR,
                                       ERR_BASE64_CANNOT_READ_ENCODED_DATA.get(getExceptionMessage(e)));
            } finally {
                if (readFromFile) {
                    closeSilently(reader);
                }
            }
        }

        if (dataToDecode.length() % 4 != 0) {
            throw newToolParamException(ERR_BASE64_DECODE_INVALID_LENGTH.get(dataToDecode));
        }

        final byte[] decodedData = org.forgerock.util.encode.Base64.decode(dataToDecode);
        if (decodedData == null) {
            throw newToolParamException(ERR_BASE64_ERROR_DECODING_RAW_DATA.get(dataToDecode));
        }

        try {
            if (toRawFilePathArg.isPresent()) {
                try (final FileOutputStream outputStream = new FileOutputStream(toRawFilePathArg.getValue())) {
                    outputStream.write(decodedData);
                }
            } else {
                try (final PrintStream outputPrintStream = getOutputStream()) {
                    outputPrintStream.write(decodedData);
                }
            }
        } catch (final Exception e) {
            throw newToolException(e, ResultCode.OPERATIONS_ERROR,
                                   ERR_BASE64_CANNOT_WRITE_RAW_DATA.get(getExceptionMessage(e)));
        }
        return ResultCode.SUCCESS.intValue();
    }
}