/*
 * Copyright (C) 2016 The Android Open Source Project
 *
 * Licensed 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.
 */

#ifndef FORMATTER_H_

#define FORMATTER_H_

#include <functional>
#include <string>
#include <vector>

namespace android {

struct Formatter;

struct WrappedOutput {
    WrappedOutput(size_t lineLength);

    void group(const std::function<void(void)>& block);
    WrappedOutput& operator<<(const std::string& str);
    WrappedOutput& printUnlessWrapped(const std::string& str);

  private:
    struct Block {
        Block(const std::string& content, Block* const parent);

        // populated helps indicate if we are done filling up the Block.
        // this allows WrappedOutput to keep adding content to this block
        // till it is determined that it is full.
        bool populated = false;
        bool printUnlessWrapped = false;

        // Only one of content or blocks can have content.
        std::string content;
        std::vector<Block> blocks;

        Block* const parent;

        size_t computeSize(bool wrapped) const;
        void print(Formatter& out, bool wrapped) const;
    };

    size_t mLineLength;

    Block mRootBlock;
    Block* mCurrentBlock;

    friend struct Formatter;
};

// Two styles to use a Formatter.
// One is with .indent() calls and operator<<.
//     out << "if (good) {\n"; out.indent(); out << "blah\nblah\n"; out.unindent(); out << "}\n";
// The other is with chain calls and lambda functions
//     out.sIf("good", [&] { out("blah").endl()("blah").endl(); }).endl();
struct Formatter {
    static Formatter invalid() { return Formatter(); }

    // Assumes ownership of file. Directed to stdout if file == NULL.
    Formatter(FILE* file, size_t spacesPerIndent = 4);
    Formatter(Formatter&&) = default;
    ~Formatter();

    void indent(size_t level = 1);
    void unindent(size_t level = 1);

    // Note that The last \n after the last line is NOT added automatically.
    // out.indent(2, [&] {
    //     out << "Meow\n";
    // });
    Formatter& indent(size_t level, const std::function<void(void)>& func);

    // Note that The last \n after the last line is NOT added automatically.
    // out.indent([&] {
    //     out << "Meow\n";
    // });
    Formatter& indent(const std::function<void(void)>& func);

    // A block inside braces.
    // * No space will be added before the opening brace.
    // * The last \n before the closing brace is added automatically.
    // * There will NOT be a \n after the closing brace.
    // out.block([&] {
    //     out << "one();\n"
    //         << "two();\n";
    // });
    // is equivalent to
    // out << "{\n"
    //     << "one();\ntwo();\n" // func()
    //     << "}";
    Formatter& block(const std::function<void(void)>& func);

    // A synonym to (*this) << "\n";
    Formatter &endl();

    // out.sIf("z == 1", [&] {
    //     out << "doGoodStuff();\n";
    // }).sElseIf("z == 2", [&] {
    //     out << "doBadStuff();\n";
    // }).sElse([&] {
    //     out << "logFatal();\n";
    // }).endl();
    // note that there will be a space before the "else"-s.
    Formatter& sIf(const std::string& cond, const std::function<void(void)>& block);
    Formatter& sElseIf(const std::string& cond, const std::function<void(void)>& block);
    Formatter& sElse(const std::function<void(void)>& block);

    // out.sFor("int i = 0; i < 10; i++", [&] {
    //     out << "printf(\"%d\", i);\n";
    // }).endl();
    Formatter& sFor(const std::string& stmts, const std::function<void(void)>& block);

    // out.sTry([&] {
    //     out << "throw RemoteException();\n"
    // }).sCatch("RemoteException ex", [&] {
    //     out << "ex.printStackTrace();\n"
    // }).sFinally([&] {
    //     // cleanup
    // }).endl();
    // note that there will be a space before the "catch"-s.
    Formatter& sTry(const std::function<void(void)>& block);
    Formatter& sCatch(const std::string& exception, const std::function<void(void)>& block);
    Formatter& sFinally(const std::function<void(void)>& block);

    // out.sWhile("z < 10", [&] {
    //     out << "z++;\n";
    // }).endl();
    Formatter& sWhile(const std::string& cond, const std::function<void(void)>& block);

    // out.join(v.begin(), v.end(), ",", [&](const auto &e) {
    //     out << toString(e);
    // });
    template <typename I>
    Formatter& join(
        const I begin, const I end, const std::string& separator,
        const std::function<void(const typename std::iterator_traits<I>::value_type&)>& func);

    Formatter &operator<<(const std::string &out);

    Formatter &operator<<(char c);
    Formatter &operator<<(signed char c);
    Formatter &operator<<(unsigned char c);

    Formatter &operator<<(short c);
    Formatter &operator<<(unsigned short c);
    Formatter &operator<<(int c);
    Formatter &operator<<(unsigned int c);
    Formatter &operator<<(long c);
    Formatter &operator<<(unsigned long c);
    Formatter &operator<<(long long c);
    Formatter &operator<<(unsigned long long c);
    Formatter &operator<<(float c);
    Formatter &operator<<(double c);
    Formatter &operator<<(long double c);
    Formatter& operator<<(const WrappedOutput& wrappedOutput);

    // Puts a prefix before each line. This is useful if
    // you want to start a // comment block, for example.
    // The prefix will be put before the indentation.
    // Will be effective the next time cursor is at the start of line.
    // Adding two prefixes will output them in the order they were added
    void pushLinePrefix(const std::string& prefix);
    // Remove the last line prefix.
    void popLinePrefix();

    bool isValid() const;
    size_t getIndentation() const;

  private:
    // Creates an invalid formatter object.
    Formatter();

    FILE* mFile;  // invalid if nullptr
    size_t mIndentDepth;
    size_t mSpacesPerIndent;
    size_t mCurrentPosition;

    std::vector<std::string> mLinePrefix;

    void printBlock(const WrappedOutput::Block& block, size_t lineLength);
    void output(const std::string &text) const;

    Formatter(const Formatter&) = delete;
    void operator=(const Formatter&) = delete;
};

template <typename I>
Formatter& Formatter::join(
    const I begin, const I end, const std::string& separator,
    const std::function<void(const typename std::iterator_traits<I>::value_type&)>& func) {
    for (I iter = begin; iter != end; ++iter) {
        if (iter != begin) {
            (*this) << separator;
        }
        func(*iter);
    }
    return (*this);
}

}  // namespace android

#endif  // FORMATTER_H_