#pragma once

#include "mem.h"
#include "output.h"

#include <util/datetime/base.h>
#include <util/generic/strbuf.h>
#include <util/generic/flags.h>
#include <util/memory/tempbuf.h>
#include <util/string/cast.h>

enum ENumberFormatFlag {
    HF_FULL = 0x01, /**< Output number with leading zeros. */
    HF_ADDX = 0x02, /**< Output '0x' or '0b' before hex/bin digits. */
};
Y_DECLARE_FLAGS(ENumberFormat, ENumberFormatFlag);
Y_DECLARE_OPERATORS_FOR_FLAGS(ENumberFormat);

enum ESizeFormat {
    SF_QUANTITY, /**< Base 1000, usual suffixes. 1100 gets turned into "1.1K". */
    SF_BYTES,    /**< Base 1024, byte suffix. 1100 gets turned into "1.07KiB". */
};

namespace NFormatPrivate {
    template <size_t Value>
    struct TLog2: std::integral_constant<size_t, TLog2<Value / 2>::value + 1> {};

    template <>
    struct TLog2<1>: std::integral_constant<size_t, 0> {};

    template <typename T>
    inline void StreamWrite(T& stream, const char* s, size_t size) {
        stream.write(s, size);
    }

    template <>
    inline void StreamWrite(IOutputStream& stream, const char* s, size_t size) {
        stream.Write(s, size);
    }

    template <>
    inline void StreamWrite(TStringStream& stream, const char* s, size_t size) {
        stream.Write(s, size);
    }

    template <typename T>
    static inline void WriteChars(T& os, char c, size_t count) {
        if (count == 0)
            return;
        TTempBuf buf(count);
        memset(buf.Data(), c, count);
        StreamWrite(os, buf.Data(), count);
    }

    template <typename T>
    struct TLeftPad {
        T Value;
        size_t Width;
        char Padc;

        inline TLeftPad(const T& value, size_t width, char padc)
            : Value(value)
            , Width(width)
            , Padc(padc)
        {
        }
    };

    template <typename T>
    IOutputStream& operator<<(IOutputStream& o, const TLeftPad<T>& lp) {
        TTempBuf buf;
        TMemoryOutput ss(buf.Data(), buf.Size());
        ss << lp.Value;
        size_t written = buf.Size() - ss.Avail();
        if (lp.Width > written) {
            WriteChars(o, lp.Padc, lp.Width - written);
        }
        o.Write(buf.Data(), written);
        return o;
    }

    template <typename T>
    struct TRightPad {
        T Value;
        size_t Width;
        char Padc;

        inline TRightPad(const T& value, size_t width, char padc)
            : Value(value)
            , Width(width)
            , Padc(padc)
        {
        }
    };

    template <typename T>
    IOutputStream& operator<<(IOutputStream& o, const TRightPad<T>& lp) {
        TTempBuf buf;
        TMemoryOutput ss(buf.Data(), buf.Size());
        ss << lp.Value;
        size_t written = buf.Size() - ss.Avail();
        o.Write(buf.Data(), written);
        if (lp.Width > written) {
            WriteChars(o, lp.Padc, lp.Width - written);
        }
        return o;
    }

    template <typename T, size_t Base>
    struct TBaseNumber {
        T Value;
        ENumberFormat Flags;

        template <typename OtherT>
        inline TBaseNumber(OtherT value, ENumberFormat flags)
            : Value(value)
            , Flags(flags)
        {
        }
    };

    template <typename T, size_t Base>
    using TUnsignedBaseNumber = TBaseNumber<std::make_unsigned_t<std::remove_cv_t<T>>, Base>;

    template <typename TStream, typename T, size_t Base>
    TStream& ToStreamImpl(TStream& stream, const TBaseNumber<T, Base>& value) {
        char buf[8 * sizeof(T) + 1]; /* Add 1 for sign. */
        TStringBuf str(buf, IntToString<Base>(value.Value, buf, sizeof(buf)));

        if (str[0] == '-') {
            stream << '-';
            str.Skip(1);
        }

        if (value.Flags & HF_ADDX) {
            if (Base == 16) {
                stream << TStringBuf("0x");
            } else if (Base == 2) {
                stream << TStringBuf("0b");
            }
        }

        if (value.Flags & HF_FULL) {
            WriteChars(stream, '0', (8 * sizeof(T) + TLog2<Base>::value - 1) / TLog2<Base>::value - str.size());
        }

        stream << str;
        return stream;
    }

    template <typename T, size_t Base>
    IOutputStream& operator<<(IOutputStream& stream, const TBaseNumber<T, Base>& value) {
        return ToStreamImpl(stream, value);
    }

    template <typename T, size_t Base>
    std::ostream& operator<<(std::ostream& stream, const TBaseNumber<T, Base>& value) {
        return ToStreamImpl(stream, value);
    }

    template <typename Char, size_t Base>
    struct TBaseText {
        TBasicStringBuf<Char> Text;

        inline TBaseText(const TBasicStringBuf<Char> text)
            : Text(text)
        {
        }
    };

    template <typename Char, size_t Base>
    IOutputStream& operator<<(IOutputStream& os, const TBaseText<Char, Base>& text) {
        for (size_t i = 0; i < text.Text.size(); ++i) {
            if (i != 0) {
                os << ' ';
            }
            os << TUnsignedBaseNumber<Char, Base>(text.Text[i], HF_FULL);
        }
        return os;
    }

    template <typename T>
    struct TFloatPrecision {
        using TdVal = std::remove_cv_t<T>;
        static_assert(std::is_floating_point<TdVal>::value, "expect std::is_floating_point<TdVal>::value");

        TdVal Value;
        EFloatToStringMode Mode;
        int NDigits;
    };

    template <typename T>
    IOutputStream& operator<<(IOutputStream& o, const TFloatPrecision<T>& prec) {
        char buf[512];
        size_t count = FloatToString(prec.Value, buf, sizeof(buf), prec.Mode, prec.NDigits);
        o << TStringBuf(buf, count);
        return o;
    }

    struct THumanReadableDuration {
        TDuration Value;

        constexpr THumanReadableDuration(const TDuration& value)
            : Value(value)
        {
        }
    };

    struct THumanReadableSize {
        double Value;
        ESizeFormat Format;
    };
}

/**
 * Output manipulator basically equivalent to `std::setw` and `std::setfill`
 * combined.
 *
 * When written into a `IOutputStream`, writes out padding characters first,
 * and then provided value.
 *
 * Example usage:
 * @code
 * stream << LeftPad(12345, 10, '0'); // Will output "0000012345"
 * @endcode
 *
 * @param value                         Value to output.
 * @param width                         Target total width.
 * @param padc                          Character to use for padding.
 * @see RightPad
 */
template <typename T>
static constexpr ::NFormatPrivate::TLeftPad<T> LeftPad(const T& value, const size_t width, const char padc = ' ') noexcept {
    return ::NFormatPrivate::TLeftPad<T>(value, width, padc);
}

template <typename T, int N>
static constexpr ::NFormatPrivate::TLeftPad<const T*> LeftPad(const T (&value)[N], const size_t width, const char padc = ' ') noexcept {
    return ::NFormatPrivate::TLeftPad<const T*>(value, width, padc);
}

/**
 * Output manipulator similar to `std::setw` and `std::setfill`.
 *
 * When written into a `IOutputStream`, writes provided value first, and then
 * the padding characters.
 *
 * Example usage:
 * @code
 * stream << RightPad("column1", 10, ' '); // Will output "column1   "
 * @endcode
 *
 * @param value                         Value to output.
 * @param width                         Target total width.
 * @param padc                          Character to use for padding.
 * @see LeftPad
 */
template <typename T>
static constexpr ::NFormatPrivate::TRightPad<T> RightPad(const T& value, const size_t width, const char padc = ' ') noexcept {
    return ::NFormatPrivate::TRightPad<T>(value, width, padc);
}

template <typename T, int N>
static constexpr ::NFormatPrivate::TRightPad<const T*> RightPad(const T (&value)[N], const size_t width, const char padc = ' ') noexcept {
    return ::NFormatPrivate::TRightPad<const T*>(value, width, padc);
}

/**
 * Output manipulator similar to `std::setbase(16)`.
 *
 * When written into a `IOutputStream`, writes out the provided value in
 * hexadecimal form. The value is treated as unsigned, even if its type is in
 * fact signed.
 *
 * Example usage:
 * @code
 * stream << Hex(-1);   // Will output "0xFFFFFFFF"
 * stream << Hex(1ull); // Will output "0x0000000000000001"
 * @endcode
 *
 * @param value                         Value to output.
 * @param flags                         Output flags.
 */
template <typename T>
static constexpr ::NFormatPrivate::TUnsignedBaseNumber<T, 16> Hex(const T& value, const ENumberFormat flags = HF_FULL | HF_ADDX) noexcept {
    return {value, flags};
}

/**
 * Output manipulator similar to `std::setbase(16)`.
 *
 * When written into a `IOutputStream`, writes out the provided value in
 * hexadecimal form.
 *
 * Example usage:
 * @code
 * stream << SHex(-1);   // Will output "-0x00000001"
 * stream << SHex(1ull); // Will output "0x0000000000000001"
 * @endcode
 *
 * @param value                         Value to output.
 * @param flags                         Output flags.
 */
template <typename T>
static constexpr ::NFormatPrivate::TBaseNumber<T, 16> SHex(const T& value, const ENumberFormat flags = HF_FULL | HF_ADDX) noexcept {
    return {value, flags};
}

/**
 * Output manipulator similar to `std::setbase(2)`.
 *
 * When written into a `IOutputStream`, writes out the provided value in
 * binary form. The value is treated as unsigned, even if its type is in
 * fact signed.
 *
 * Example usage:
 * @code
 * stream << Bin(-1);   // Will output "0b11111111111111111111111111111111"
 * stream << Bin(1);    // Will output "0b00000000000000000000000000000001"
 * @endcode
 *
 * @param value                         Value to output.
 * @param flags                         Output flags.
 */
template <typename T>
static constexpr ::NFormatPrivate::TUnsignedBaseNumber<T, 2> Bin(const T& value, const ENumberFormat flags = HF_FULL | HF_ADDX) noexcept {
    return {value, flags};
}

/**
 * Output manipulator similar to `std::setbase(2)`.
 *
 * When written into a `IOutputStream`, writes out the provided value in
 * binary form.
 *
 * Example usage:
 * @code
 * stream << SBin(-1);   // Will output "-0b00000000000000000000000000000001"
 * stream << SBin(1);    // Will output "0b00000000000000000000000000000001"
 * @endcode
 *
 * @param value                         Value to output.
 * @param flags                         Output flags.
 */
template <typename T>
static constexpr ::NFormatPrivate::TBaseNumber<T, 2> SBin(const T& value, const ENumberFormat flags = HF_FULL | HF_ADDX) noexcept {
    return {value, flags};
}

/**
 * Output manipulator for hexadecimal string output.
 *
 * When written into a `IOutputStream`, writes out the provided characters
 * in hexadecimal form divided by space character.
 *
 * Example usage:
 * @code
 * stream << HexText(TStringBuf("abcи"));  // Will output "61 62 63 D0 B8"
 * stream << HexText(TWtringBuf(u"abcи")); // Will output "0061 0062 0063 0438"
 * @endcode
 *
 * @param value                         String to output.
 */
template <typename TChar>
static inline ::NFormatPrivate::TBaseText<TChar, 16> HexText(const TBasicStringBuf<TChar> value) {
    return ::NFormatPrivate::TBaseText<TChar, 16>(value);
}

/**
 * Output manipulator for binary string output.
 *
 * When written into a `IOutputStream`, writes out the provided characters
 * in binary form divided by space character.
 *
 * Example usage:
 * @code
 * stream << BinText(TStringBuf("aaa"));  // Will output "01100001 01100001 01100001"
 * @endcode
 *
 * @param value                         String to output.
 */
template <typename TChar>
static inline ::NFormatPrivate::TBaseText<TChar, 2> BinText(const TBasicStringBuf<TChar> value) {
    return ::NFormatPrivate::TBaseText<TChar, 2>(value);
}

/**
 * Output manipulator for printing `TDuration` values.
 *
 * When written into a `IOutputStream`, writes out the provided `TDuration`
 * in auto-adjusted human-readable format.
 *
 * Example usage:
 * @code
 * stream << HumanReadable(TDuration::MicroSeconds(100));   // Will output "100us"
 * stream << HumanReadable(TDuration::Seconds(3672));       // Will output "1h 1m 12s"
 * @endcode
 *
 * @param value                         Value to output.
 */
static constexpr ::NFormatPrivate::THumanReadableDuration HumanReadable(const TDuration duration) noexcept {
    return ::NFormatPrivate::THumanReadableDuration(duration);
}

/**
 * Output manipulator for writing out human-readable number of elements / memory
 * amount in `ls -h` style.
 *
 * When written into a `IOutputStream`, writes out the provided unsigned integer
 * variable with small precision and a suffix (like 'K', 'M', 'G' for numbers, or
 * 'B', 'KiB', 'MiB', 'GiB' for bytes).
 *
 * For quantities, base 1000 is used. For bytes, base is 1024.
 *
 * Example usage:
 * @code
 * stream <<  HumanReadableSize(1024, SF_QUANTITY);                          // Will output    "1.02K"
 * stream <<  HumanReadableSize(1024, SF_BYTES);                             // Will output    "1KiB"
 * stream << "average usage " << HumanReadableSize(100 / 3., SF_BYTES);     // Will output    "average usage "33.3B""
 * @endcode
 *
 * @param value                         Value to output.
 * @param format                        Format to use.
 */
static constexpr ::NFormatPrivate::THumanReadableSize HumanReadableSize(const double size, ESizeFormat format) noexcept {
    return {size, format};
}

void Time(IOutputStream& l);
void TimeHumanReadable(IOutputStream& l);

/**
 * Output manipulator for adjusting precision of floating point values.
 *
 * When written into a `IOutputStream`, writes out the provided floating point
 * variable with given precision. The behavior depends on provided `mode`.
 *
 * Example usage:
 * @code
 * stream <<  Prec(1.2345678901234567, PREC_AUTO);   // Will output "1.2345678901234567"
 * @endcode
 *
 * @param value                         float or double to output.
 * @param mode                          Output mode.
 * @param ndigits                       Number of significant digits (in `PREC_NDIGITS` and `PREC_POINT_DIGITS` mode).
 * @see EFloatToStringMode
 */
template <typename T>
static constexpr ::NFormatPrivate::TFloatPrecision<T> Prec(const T& value, const EFloatToStringMode mode, const int ndigits = 0) noexcept {
    return {value, mode, ndigits};
}

/**
 * Output manipulator for adjusting precision of floating point values.
 *
 * When written into a `IOutputStream`, writes out the provided floating point
 * variable with given precision. The behavior is equivalent to `Prec(value, PREC_NDIGITS, ndigits)`.
 *
 * Example usage:
 * @code
 * stream <<  Prec(1.2345678901234567, 3);   // Will output "1.23"
 * @endcode
 *
 * @param value                         float or double to output.
 * @param ndigits                       Number of significant digits.
 */
template <typename T>
static constexpr ::NFormatPrivate::TFloatPrecision<T> Prec(const T& value, const int ndigits) noexcept {
    return {value, PREC_NDIGITS, ndigits};
}