////////////////////////////////////////////////////////////////////////////////
// Copyright (c) 2005 by Andrei Alexandrescu
// Copyright (c) 2006 Peter Kümmel
// Permission to use, copy, modify, distribute, and sell this software for any
//     purpose is hereby granted without fee, provided that the above copyright
//     notice appear in all copies and that both that copyright notice and this
//     permission notice appear in supporting documentation.
// The author makes no representations about the suitability of this software 
//     for any purpose. It is provided "as is" without express or implied 
//     warranty.
////////////////////////////////////////////////////////////////////////////////
#ifndef LOKI_SAFEFORMAT_INC_
#define LOKI_SAFEFORMAT_INC_

// $Id: SafeFormat.h 911 2008-12-15 20:55:24Z syntheticpp $


////////////////////////////////////////////////////////////////////////////////
// This file contains definitions for SafePrintf. SafeScanf coming soon (the 
//   design is similar). 
// See Alexandrescu, Andrei: Type-safe Formatting, C/C++ Users Journal, Aug 2005
////////////////////////////////////////////////////////////////////////////////

#include <cstdio>
#include <climits>
#include <string>
#include <cstring>
#include <stdexcept>
#include <utility>
#include <cassert>
#include <locale>
#include <iostream>

#include <loki/LokiExport.h>


// long is 32 bit on 64-bit Windows!
// intptr_t used to get 64 bit on Win64
#if defined(_WIN32) || defined(_WIN64)
#  define LOKI_SAFEFORMAT_SIGNED_LONG intptr_t
#  define LOKI_SAFEFORMAT_UNSIGNED_LONG uintptr_t
#else
#  define LOKI_SAFEFORMAT_SIGNED_LONG signed long
#  define LOKI_SAFEFORMAT_UNSIGNED_LONG unsigned long
#endif

// Windows headers could have min/max defined
#ifdef max 
#  undef max 
#endif 
#ifdef min 
#  undef min 
#endif 

namespace Loki
{

    // Crude writing method: writes straight to the file, unbuffered
    // Must be combined with a buffer to work properly (and efficiently)
    LOKI_EXPORT
    void write(std::FILE* f, const char* from, const char* to);

    // Write to an ostream
    LOKI_EXPORT
    void write(std::ostream& f, const char* from, const char* to);

    // Write to a string
    LOKI_EXPORT
    void write(std::string& s, const char* from, const char* to);

    // Write to a fixed-size buffer
    template <class Char>
    void write(std::pair<Char*, std::size_t>& s, const Char* from, const Char* to) {
        assert(from <= to);
        if(from + s.second < to)
            throw std::overflow_error("");
        // s.first: position one past the final copied element 
        s.first = std::copy(from, to, s.first);
        // remaining buffer size
        s.second -= to - from;
    }

    ////////////////////////////////////////////////////////////////////////////////
    // PrintfState class template
    // Holds the formatting state, and implements operator() to format stuff
    // Todo: make sure errors are handled properly
    ////////////////////////////////////////////////////////////////////////////////

    template <class Device, class Char>
    struct PrintfState {
        PrintfState(Device dev, const Char * format) 
                : device_(dev)
                , format_(format)
                , width_(0)
                , prec_(0)
                , flags_(0)
                , result_(0) {
            Advance();
        }
        
        ~PrintfState() {
        }

        #define LOKI_PRINTF_STATE_FORWARD(type) \
            PrintfState& operator()(type par) {\
                return (*this)(static_cast< LOKI_SAFEFORMAT_UNSIGNED_LONG >(par)); \
            }

        LOKI_PRINTF_STATE_FORWARD(bool)
        LOKI_PRINTF_STATE_FORWARD(char)
        LOKI_PRINTF_STATE_FORWARD(signed char)
        LOKI_PRINTF_STATE_FORWARD(unsigned char)
        LOKI_PRINTF_STATE_FORWARD(signed short)
        LOKI_PRINTF_STATE_FORWARD(unsigned short)
        LOKI_PRINTF_STATE_FORWARD(signed int)
        LOKI_PRINTF_STATE_FORWARD(signed long)
#if (defined(_WIN32) || defined(_WIN64))
        LOKI_PRINTF_STATE_FORWARD(unsigned long)
#else
        // on Windows already defined by uintptr_t
        LOKI_PRINTF_STATE_FORWARD(unsigned int)
#endif

        // Print (or gobble in case of the "*" specifier) an int
        PrintfState& operator()(LOKI_SAFEFORMAT_UNSIGNED_LONG i) {
            if (result_ == -1) return *this; // don't even bother
            // % [flags] [width] [.prec] [modifier] type_char
            // Fetch the flags 
            ReadFlags();
            if (*format_ == '*') {
                // read the width and get out
                SetWidth(static_cast<size_t>(i));
                ++format_;
                return *this;
            }
            ReadWidth();
            // precision
            if (*format_ == '.') {
                // deal with precision
                if (format_[1] == '*') {
                    // read the precision and get out
                    SetPrec(static_cast<size_t>(i));
                    format_ += 2;
                    return *this;
                }
                ReadPrecision();
            }
            ReadModifiers();
            // input size modifier
            if (ForceShort()) {
                // short int
                const Char c = *format_;
                if (c == 'x' || c == 'X' || c == 'u' || c == 'o') {
                    i = static_cast<LOKI_SAFEFORMAT_UNSIGNED_LONG>(static_cast<unsigned short>(i));
                }
            }
            FormatWithCurrentFlags(i);
            return *this;
        }

        PrintfState& operator()(void* n) {
            if (result_ == -1) return *this; // don't even bother
            PrintUsing_snprintf(n,"p");
            return *this;
        }
        
        PrintfState& operator()(double n) {
            if (result_ == -1) return *this; // don't even bother
            PrintUsing_snprintf(n,"eEfgG");
            return *this;
        }

        PrintfState& operator()(long double n) {
            if (result_ == -1) return *this; // don't even bother
            PrintUsing_snprintf(n,"eEfgG");
            return *this;
        }

        // Store the number of characters printed so far
        PrintfState& operator()(int * pi) {
            return StoreCountHelper(pi);
        }
        
        // Store the number of characters printed so far
        PrintfState& operator()(short * pi) {
            return StoreCountHelper(pi);
        }
        
        // Store the number of characters printed so far
        PrintfState& operator()(long * pi) {
            return StoreCountHelper(pi);
        }
        
        PrintfState& operator()(const std::string& stdstr) {
            return operator()(stdstr.c_str());
        }

        PrintfState& operator()(const char *const s) {
            if (result_ == -1) return *this;
            ReadLeaders();
            const char fmt = *format_;
            if (fmt == 'p') {
                FormatWithCurrentFlags(reinterpret_cast<LOKI_SAFEFORMAT_UNSIGNED_LONG>(s));
                return *this;
            }
            if (fmt != 's') {
                result_ = -1;
                return *this;
            }
			const size_t len = std::min(std::strlen(s), prec_);
            if (width_ > len) {
                if (LeftJustify()) {
                    Write(s, s + len);
                    Fill(' ', width_ - len);
                } else {
                    Fill(' ', width_ - len);
                    Write(s, s + len);
                }
            } else {
                Write(s, s + len);
            }
            Next();
            return *this;
        }
        
        PrintfState& operator()(const void *const p) {
            return (*this)(reinterpret_cast<LOKI_SAFEFORMAT_UNSIGNED_LONG>(p));
        }
        
        // read the result
        operator int() const {
            return static_cast<int>(result_);
        }
        
    private:
        PrintfState& operator=(const PrintfState&);
        template <typename T>
        PrintfState& StoreCountHelper(T *const pi) {
            if (result_ == -1) return *this; // don't even bother
            ReadLeaders();
            const char fmt = *format_;
            if (fmt == 'p') { // pointer
                FormatWithCurrentFlags(reinterpret_cast<LOKI_SAFEFORMAT_UNSIGNED_LONG>(pi));
                return *this;
            }
            if (fmt != 'n') {
                result_ = -1;
                return *this;
            }
            assert(pi != 0);
            *pi = result_;
            Next();
            return *this;
        }

        void FormatWithCurrentFlags(const LOKI_SAFEFORMAT_UNSIGNED_LONG i) {
            // look at the format character
            Char formatChar = *format_;
            bool isSigned = formatChar == 'd' || formatChar == 'i';
            if (formatChar == 'p') {
                formatChar = 'x'; // pointers go to hex
                SetAlternateForm(); // printed with '0x' in front
                isSigned = true; // that's what gcc does
            }
            if (!strchr("cdiuoxX", formatChar)) {
                result_ = -1;
                return;
            }
            Char buf[
                sizeof(LOKI_SAFEFORMAT_UNSIGNED_LONG) * 3 // digits
                + 1 // sign or ' '
                + 2 // 0x or 0X
                + 1]; // terminating zero
            const Char *const bufEnd = buf + (sizeof(buf) / sizeof(Char));
            Char * bufLast = buf + (sizeof(buf) / sizeof(Char) - 1);
            Char signChar = 0;
            unsigned int base = 10;
            
            if (formatChar == 'c') {
                // Format only one character
                // The 'fill with zeros' flag is ignored
                ResetFillZeros();
                *bufLast = static_cast<char>(i);
            } else {
                // TODO: inefficient code, refactor
                const bool negative = isSigned && static_cast<LOKI_SAFEFORMAT_SIGNED_LONG>(i) < 0;
                if (formatChar == 'o') base = 8;
                else if (formatChar == 'x' || formatChar == 'X') base = 16;
                bufLast = isSigned
                    ? RenderWithoutSign(static_cast<LOKI_SAFEFORMAT_SIGNED_LONG>(i), bufLast, base,
                        formatChar == 'X')
                    : RenderWithoutSign(i, bufLast, base, 
                        formatChar == 'X');
                // Add the sign
                if (isSigned) {
                    negative ? signChar = '-'
                    : ShowSignAlways() ? signChar = '+'
                    : Blank() ? signChar = ' '
                    : 0;
                }
            }
            // precision 
            size_t 
                countDigits = bufEnd - bufLast,
                countZeros = prec_ != size_t(-1) && countDigits < prec_ && 
                        formatChar != 'c'
                    ? prec_ - countDigits 
                    : 0,
                countBase = base != 10 && AlternateForm() && i != 0
                    ? (base == 16 ? 2 : countZeros > 0 ? 0 : 1)
                    : 0,
                countSign = (signChar != 0),
                totalPrintable = countDigits + countZeros + countBase + countSign;
            size_t countPadLeft = 0, countPadRight = 0;
            if (width_ > totalPrintable) {
                if (LeftJustify()) {
                    countPadRight = width_ - totalPrintable;
                    countPadLeft = 0;
                } else {
                    countPadLeft = width_ - totalPrintable;
                    countPadRight = 0;
                }
            }
            if (FillZeros() && prec_ == size_t(-1)) {
                // pad with zeros and no precision - transfer padding to precision
                countZeros = countPadLeft;
                countPadLeft = 0;
            }
            // ok, all computed, ready to print to device
            Fill(' ', countPadLeft);
            if (signChar != 0) Write(&signChar, &signChar + 1);
            if (countBase > 0) Fill('0', 1);
            if (countBase == 2) Fill(formatChar, 1);
            Fill('0', countZeros);
            Write(bufLast, bufEnd);
            Fill(' ', countPadRight);
            // done, advance
            Next();
        }
        
        void Write(const Char* b, const Char* e) {
            if (result_ < 0) return;
            const LOKI_SAFEFORMAT_SIGNED_LONG x = e - b;
            write(device_, b, e);
            result_ += x;
        }

        template <class Value>
        void PrintUsing_snprintf(Value n, const char* check_fmt_char) {
            const Char *const fmt = format_ - 1;
            assert(*fmt == '%');
            // enforce format string validity
            ReadLeaders();
            // enforce format spec
            if (!strchr(check_fmt_char, *format_)) {
                result_ = -1;
                return;
            }
            // format char validated, copy it to a temp and use legacy sprintf
            ++format_;
            Char fmtBuf[128], resultBuf[1024];
            if (format_  >= fmt + sizeof(fmtBuf) / sizeof(Char)) {
                result_ = -1;
                return;
            }
            memcpy(fmtBuf, fmt, (format_ - fmt) * sizeof(Char));
            fmtBuf[format_ - fmt] = 0;

            const int stored = 
#ifdef _MSC_VER
#if _MSC_VER < 1400
            _snprintf
#else
            _snprintf_s
#endif
#else
            snprintf 
#endif        
                     (resultBuf, sizeof(resultBuf) / sizeof(Char), fmtBuf, n);
                     
            if (stored < 0) {
                result_ = -1;
                return;
            }
            Write(resultBuf, resultBuf + strlen(resultBuf));
            Advance(); // output stuff to the next format directive
        }

        void Fill(const Char c, size_t n) {
            for (; n > 0; --n) {
                Write(&c, &c + 1);
            }
        }
       
        Char* RenderWithoutSign(LOKI_SAFEFORMAT_UNSIGNED_LONG n, char* bufLast, 
                unsigned int base, bool uppercase) {
            const Char hex1st = uppercase ? 'A' : 'a';
            for (;;) {
                const LOKI_SAFEFORMAT_UNSIGNED_LONG next = n / base;
                Char c = static_cast<Char>(n - next * base);
                c = static_cast<Char>(c + (c <= 9 ? '0' : static_cast<Char>(hex1st - 10)));
                *bufLast = c;
                n = next;
                if (n == 0) break;
                --bufLast;
            }
            return bufLast;
        }

        char* RenderWithoutSign(LOKI_SAFEFORMAT_SIGNED_LONG n, char* bufLast, unsigned int base, 
                bool uppercase) {
            if (n != LONG_MIN) {
                return RenderWithoutSign(static_cast<LOKI_SAFEFORMAT_UNSIGNED_LONG>(n < 0 ? -n : n),
                    bufLast, base, uppercase);            
            }
            // annoying corner case
            char* save = bufLast;
            ++n;
            bufLast = RenderWithoutSign(static_cast<LOKI_SAFEFORMAT_UNSIGNED_LONG>(n),
                bufLast, base, uppercase);
            --(*save);
            return bufLast;
        }
        
        void Next() {
            ++format_;
            Advance();
        }
        
        void Advance() {
            ResetAll();
            const Char* begin = format_;
            for (;;) {
                if (*format_ == '%') { 
                    if (format_[1] != '%') { // It's a format specifier
                        Write(begin, format_);
                        ++format_;
                        break;
                    }
                    // It's a "%%"
                    Write(begin, ++format_);
                    begin = ++format_;
                    continue; 
                }
                if (*format_ == 0) {
                    Write(begin, format_);
                    break;
                }
                ++format_;
            }
        }
        
        void ReadFlags() {
            for (;; ++format_) {
                switch (*format_) {
                    case '-': SetLeftJustify(); break;
                    case '+': SetShowSignAlways(); break;
                    case ' ': SetBlank(); break;
                    case '#': SetAlternateForm(); break;
                    case '0': SetFillZeros(); break;
                    default: return;
                }
            }
        }
        
        void ParseDecimalSizeT(size_t& dest) {
            if (!std::isdigit(*format_, std::locale())) return;
            size_t r = 0;
            do {
                // TODO: inefficient - rewrite
                r *= 10;
                r += *format_ - '0';
                ++format_;
            } while (std::isdigit(*format_, std::locale()));
            dest = r;
        }
        
        void ReadWidth() {
            ParseDecimalSizeT(width_);
        }    
        
        void ReadPrecision() {
            assert(*format_ == '.');
            ++format_;
            ParseDecimalSizeT(prec_);
        }    
        
        void ReadModifiers() {
            switch (*format_) {
                case 'h': SetForceShort(); ++format_; break;
                case 'l': ++format_; break;
                // more (C99 and platform-specific modifiers) to come
            }
        }
        
        void ReadLeaders() {
            ReadFlags();
            ReadWidth();
            if (*format_ == '.') ReadPrecision();
            ReadModifiers();
        }
        
        enum { 
            leftJustify = 1,
            showSignAlways = 2,
            blank = 4,
            alternateForm = 8,
            fillZeros = 16,
            forceShort = 32
        };
        
        bool LeftJustify() const { return (flags_ & leftJustify) != 0; }
        bool ShowSignAlways() const { return (flags_ & showSignAlways) != 0; }
        void SetWidth(size_t w) { width_  = w; }
        void SetLeftJustify() { flags_  |= leftJustify; }
        void SetShowSignAlways() { flags_ |= showSignAlways; }
        bool Blank() const { return (flags_ & blank) != 0; }
        bool AlternateForm() const { return (flags_ & alternateForm) != 0; }
        bool FillZeros() const { return (flags_ & fillZeros) != 0; }
        bool ForceShort() const { return (flags_ & forceShort) != 0; }

        void SetPrec(size_t p) { prec_ = p; }
        void SetBlank() { flags_ |= blank; }
        void SetAlternateForm() { flags_ |=  alternateForm; }
        void SetFillZeros() { flags_ |= fillZeros; }
        void ResetFillZeros() { flags_ &= ~fillZeros; }
        void SetForceShort() { flags_ |= forceShort; }
        
        void ResetAll() {
            assert(result_ != EOF);
            width_ = 0;
            prec_ = size_t(-1);
            flags_ = 0;
        }

        // state
        Device device_;
        const Char* format_;
        size_t width_;
        size_t prec_;
        unsigned int flags_;
        LOKI_SAFEFORMAT_SIGNED_LONG result_;
    };

    LOKI_EXPORT
    PrintfState<std::FILE*, char> Printf(const char* format);

    LOKI_EXPORT
    PrintfState<std::FILE*, char> Printf(const std::string& format);

    LOKI_EXPORT
    PrintfState<std::FILE*, char> FPrintf(std::FILE* f, const char* format);

    LOKI_EXPORT
    PrintfState<std::FILE*, char> FPrintf(std::FILE* f, const std::string& format);

    LOKI_EXPORT
    PrintfState<std::ostream&, char> FPrintf(std::ostream& f, const char* format);

    LOKI_EXPORT
    PrintfState<std::ostream&, char> FPrintf(std::ostream& f, const std::string& format);

    LOKI_EXPORT
    PrintfState<std::string&, char> SPrintf(std::string& s, const char* format);

    LOKI_EXPORT
    PrintfState<std::string&, char> SPrintf(std::string& s, const std::string& format);

    template <class T, class Char>
    PrintfState<T&, Char> XPrintf(T& device, const Char* format) {
        return PrintfState<T&, Char>(device, format);
    }

    template <class T>
    PrintfState<T&, char> XPrintf(T& device, const std::string& format) {
        return PrintfState<T&, char>(device, format.c_str());
    }

    template <class Char, std::size_t N>
    PrintfState<std::pair<Char*, std::size_t>, Char> 
    BufPrintf(Char (&buf)[N], const Char* format) {
        std::pair<Char*, std::size_t> temp(buf, N);
        return PrintfState<std::pair<Char*, std::size_t>, Char>(temp, format);
    }

}// namespace Loki


#endif // end file guardian