/* @file log_state.hpp */

#pragma once

#include "log_config.hpp"
#include "log_streambuf.hpp"
#include "pad.hpp"
#include "filename.hpp"
#include "code_location.hpp"
#include <ostream>
#include <sstream>
#include <memory>   // for std::unique_ptr

namespace xo {
    enum EntryExit {
        EE_Entry,
        EE_Exit
    };

    // track per-thread state associated with nesting logger
    //
    template <typename CharT, typename Traits>
    class state_impl {
    public:
        using log_streambuf_type = log_streambuf<char, std::char_traits<char>>;

    public:
        state_impl();

        std::uint32_t nesting_level() const { return nesting_level_; }

        void incr_nesting() { ++nesting_level_; }
        void decr_nesting() { --nesting_level_; }

        std::ostream & ss() { return ss_; }

        /* call on entry to new scope */
        void preamble(function_style style, std::string_view name1, std::string_view name2);
        /* call before each new log entry */
        void indent(char pad_char);
        /* call on exit from scope */
        void postamble(function_style style, std::string_view name1, std::string_view name2);

        /* write collected output to *p_sbuf */
        void flush2sbuf(std::streambuf * p_sbuf);

        /* discard output, reset write pointer to beginning of buffer */
        void reset_stream() {
            p_sbuf_phase1_->reset_stream();
            p_sbuf_phase2_->reset_stream();
        }

        void set_location(std::string_view file, std::uint32_t line) {
            this->location_flag_ = true;
            this->file_ = std::move(file);
            this->line_ = line;
        } /*set_location*/

    private:
        /* common implementation for .preamble(), .postamble() */
        void entryexit_aux(function_style style,
                           std::string_view name1,
                           std::string_view name2,
                           EntryExit entryexit);

    private:
        /* current nesting level for this thread */
        std::uint32_t nesting_level_ = 0;

        /* buffer space for logging
         * (before pretty-printing for scope::log() calls that span multiple lines)
         * reused across tos() and scope::log() calls
         */
        std::unique_ptr<log_streambuf_type> p_sbuf_phase1_;

        /* #of characters found in .p_sbuf_phase1 since last \n.
         * this value is established+updated in .flush2sbuf().
         * (in particular ignored by stream .ss())
         */
        std::size_t lpos_ = 0;

        /* whenever .set_location() is called:
         * - capture (file, line)
         * - print them near right margin with next output line
         * - ..and reset .location_flag
         */
        bool location_flag_ = false;
        std::string_view file_;
        std::uint32_t line_ = 0;

        /* buffer space for handling scope::log() calls that span multiple lines;
         * inserts extra characters in effort to indent gracefully
         */
        std::unique_ptr<log_streambuf_type> p_sbuf_phase2_;

        /* output stream -- always attached to .p_sbuf_phase1
         * stream inserters for application datatypes will target this stream
         */
        std::ostream ss_;
    }; /*state_impl*/

    constexpr uint32_t c_default_buf_size = 1024;

    template <typename CharT, typename Traits>
    state_impl<CharT, Traits>::state_impl()
        : p_sbuf_phase1_(new log_streambuf_type(c_default_buf_size)),
          p_sbuf_phase2_(new log_streambuf_type(c_default_buf_size)),
          ss_(p_sbuf_phase1_.get())
    {
        assert(p_sbuf_phase1_.get() == ss_.rdbuf());
    } /*ctor*/

    template <typename CharT, typename Traits>
    void
    state_impl<CharT, Traits>::indent(char pad_char)
    {
        //log_streambuf * sbuf = this->p_sbuf_phase1_.get();

#ifdef NOT_IN_USE
        {
            char buf[80];
            ::snprintf(buf, sizeof(buf), "[%02d] ", this->nesting_level_);

            this->ss_ << buf;
            //this->p_sbuf_->sputn(buf, strlen(buf));
        }
#endif

        /* indent to nesting level */
        this->ss_ << pad(this->nesting_level_ * log_config::indent_width, pad_char);
    } /*indent*/

    template <typename CharT, typename Traits>
    void
    state_impl<CharT, Traits>::entryexit_aux(function_style style,
                                             std::string_view name1,
                                             std::string_view name2,
                                             EntryExit entryexit)
    {
        log_streambuf_type * sbuf = this->p_sbuf_phase1_.get();

        sbuf->reset_stream();
        this->indent(' ');

        char ee_label = '\0';
        std::uint32_t fn_color = 0;

        color_encoding encoding = log_config::encoding;

        /* mnemonic for scope entry/exit */
        switch(entryexit) {
        case EE_Entry:
            ee_label = '+';
            fn_color = log_config::function_entry_color;
            break;
        case EE_Exit:
            ee_label = '-';
            fn_color = log_config::function_exit_color;
            break;
        }

        this->ss_ << ee_label;

        if (log_config::indent_width > 1)
            this->ss_ << ' ';

        /* scope name - note no trailing newline;  expect .preamble()/.postamble() caller to supply */
        this->ss_ << function_name(style, encoding, fn_color, name1) << name2;
    } /*entryexit_aux*/

    template <typename CharT, typename Traits>
    void
    state_impl<CharT, Traits>::preamble(function_style style,
                                        std::string_view name1,
                                        std::string_view name2)
    {
        this->entryexit_aux(style, name1, name2, EE_Entry);
    } /*preamble*/

    template <typename CharT, typename Traits>
    void
    state_impl<CharT, Traits>::postamble(function_style style,
                                         std::string_view name1,
                                         std::string_view name2)
    {
        this->entryexit_aux(style, name1, name2, EE_Exit);
    }  /*postamble*/

    template <typename CharT, typename Traits>
    void
    state_impl<CharT, Traits>::flush2sbuf(std::streambuf * p_sbuf)
    {
        log_streambuf_type * sbuf1 = this->p_sbuf_phase1_.get();
        log_streambuf_type * sbuf2 = this->p_sbuf_phase2_.get();

        /* generally expecting sbuf to contain one line of output.
         * if it contains multiple newlines,  need to indent
         * after each one.
         *
         * will scan output in *sbuf1,  post-process to *sbuf2,
         * then write *sbuf2 to output stream
         *
         * note: we inherit .lpos from prec call to .flush2sbuf(),
         *       in the unlikely event that it's non-zero
         */
        char const * s = sbuf1->lo();
        char const * e = s + sbuf1->pos();

        char const * p = s;

        /* point to first space following a non-space character.
         * will indent to just after this space
         */
        char const * space_after_nonspace = nullptr;

        while(true) {
            bool have_nonspace = false;

            /* invariant: s<=p<=e */

            /* for indenting,  looking for first 'space following non-space, on first line', if any */

            std::size_t lpos_on_newline = 0;

            while(p < e) {
                if(space_after_nonspace) {
                    ;
                } else {
                    if(*p != ' ')
                        have_nonspace = true;

                    if(have_nonspace && (*p == ' ')) {
                        space_after_nonspace = p;
                    }
                }

                if(*p == '\n') {
                    ++p;
                    /* reset .pos on newline */
                    lpos_on_newline = this->lpos_;
                    this->lpos_ = 0;

                    break;
                } else {
                    ++p;

                    /* increment .lpos on non-newline */
                    ++(this->lpos_);
                }
            }

            /* p=e or *p=\n */

            /* charseq [s,p) does not contain any newlines,  print it */
            if (lpos_on_newline > 0) {
                /* charseq [s,p) does not contain any newlines,  print it */
                sbuf2->sputn(s, p - s - 1);

                if (this->location_flag_) {
                    /* 'tab' to position 80 */
                    sbuf2->sputc(' ');
                    for (std::uint32_t i = lpos_on_newline + 1; i < log_config::location_tab; ++i)
                       sbuf2->sputc(' ');

                    std::stringstream ss;
                    ss << code_location(this->file_, this->line_,
                                        log_config::encoding, log_config::code_location_color);

                    std::string ss_str = std::move(ss.str()); /*c++20*/
                    sbuf2->sputn(ss_str.c_str(), ss_str.size());

                    this->location_flag_ = false;
                    this->file_ = "";
                    this->line_ = 0;
                }

                sbuf2->sputc('\n');
            } else {
                /* control here if .flush2sbuf() called without trailing newline in .p_sbuf_phase1 */
                sbuf2->sputn(s, p - s);
            }

            if (p == e) {
                break;
            }

            // {
            //   char buf[80];
            //   snprintf(buf, sizeof(buf), "*** indent=[%d] next=[%c]", this->nesting_level_, *(p+1));
            //
            //   std::clog.rdbuf()->sputn(buf, strlen(buf));
            //}

            /* at least 1 char following newline,  need to indent for it
             * - minimum indent = nesting level;
             * - however if space_after_nonspace defined, indent to that
             */
            uint32_t n_indent = this->nesting_level_;

            if(space_after_nonspace)
                n_indent += (space_after_nonspace - s);

            for(uint32_t i = 0; i < n_indent; ++i)
                sbuf2->sputc(' ');

            s = p;
        }

        /* now write entire contents of *sbuf2 to clog */
        p_sbuf->sputn(sbuf2->lo(), sbuf2->pos());

        /* reset streams for next message */
        this->reset_stream();
    } /*flush2sbuf*/
} /*namespace xo*/

/* end log_state.hpp */