// Glaze Library

// For the license information refer to glaze.hpp

#pragma once

#include <algorithm>

#include <optional>

#include <string>

#include "glaze/core/write_chars.hpp"

#include "glaze/util/dump.hpp"

namespace glz

{

   namespace detail

   {

      struct source_info final

      {

         size_t line{};

         size_t column{};

         std::string context{};

         size_t index{};

         size_t front_truncation{};

         size_t rear_truncation{};

      };

      // We convert to only single spaces for error messages in order to keep the source info

      // calculation more efficient and avoid needing to allocate more memory.

      inline void convert_tabs_to_single_spaces(std::string& input) noexcept

      {

         for (auto& c : input) {

            if (c == '\t') {

               c = ' ';

            }

         }

      }

      inline source_info get_source_info(const has_size auto& buffer, const size_t index)

      {

         using V = std::decay_t<decltype(buffer[0])>;

         if constexpr (std::same_as<V, std::byte>) {

            return {.context = "", .index = index};

         }

         else {

            if (index >= buffer.size()) {

               return {.context = "", .index = index};

            }

            const auto start = std::begin(buffer) + index;

            const auto line = size_t(std::count(std::begin(buffer), start, static_cast<V>('\n')) + 1);

            const auto rstart = std::rbegin(buffer) + buffer.size() - index - 1;

            const auto prev_new_line =

               std::find((std::min)(rstart + 1, std::rend(buffer)), std::rend(buffer), static_cast<V>('\n'));

            const auto column = size_t(std::distance(rstart, prev_new_line));

            const auto next_new_line =

               std::find((std::min)(start + 1, std::end(buffer)), std::end(buffer), static_cast<V>('\n'));

            const auto offset = (prev_new_line == std::rend(buffer) ? 0 : index - column + 1);

            auto context_begin = std::begin(buffer) + offset;

            auto context_end = next_new_line;

            size_t front_truncation = 0;

            size_t rear_truncation = 0;

            if (std::distance(context_begin, context_end) > 64) {

               // reduce the context length so that we can more easily see errors, especially for non-prettified buffers

               if (column <= 32) {

                  rear_truncation = 64;

                  context_end = context_begin + rear_truncation;

               }

               else {

                  front_truncation = column - 32;

                  context_begin += front_truncation;

                  if (std::distance(context_begin, context_end) > 64) {

                     rear_truncation = front_truncation + 64;

                     context_end = std::begin(buffer) + offset + rear_truncation;

                  }

               }

            }

            std::string context{context_begin, context_end};

            convert_tabs_to_single_spaces(context);

            return {line, column, context, index, front_truncation, rear_truncation};

         }

      }

      template <class B>

         requires(!has_size<B>)

      inline source_info get_source_info(const B* buffer, const size_t index)

      {

         return get_source_info(sv{buffer}, index);

      }

      inline std::string generate_error_string(const std::string_view error, const source_info& info,

                                               const std::string_view filename = "")

      {

         std::string b{};

         b.resize(error.size() + info.context.size() + filename.size() + 128);

         size_t ix{};

         if (not filename.empty()) {

            dump_not_empty(filename, b, ix);

            dump(':', b, ix);

         }

         glz::context ctx{};

         if (info.context.empty()) {

            dump<"index ">(b, ix);

            write_chars::op<opts{}>(info.index, ctx, b, ix);

            dump<": ">(b, ix);

            dump_maybe_empty(error, b, ix);

         }

         else {

            write_chars::op<opts{}>(info.line, ctx, b, ix);

            dump(':', b, ix);

            write_chars::op<opts{}>(info.column, ctx, b, ix);

            dump<": ">(b, ix);

            dump_maybe_empty(error, b, ix);

            dump('\n', b, ix);

            if (info.front_truncation) {

               if (info.rear_truncation) {

                  dump<"...">(b, ix);

                  dump_maybe_empty(info.context, b, ix);

                  dump<"...\n   ">(b, ix);

               }

               else {

                  dump<"...">(b, ix);

                  dump_maybe_empty(info.context, b, ix);

                  dump<"\n   ">(b, ix);

               }

            }

            else {

               dump<"   ">(b, ix);

               dump_maybe_empty(info.context, b, ix);

               dump<"\n   ">(b, ix);

            }

            dumpn<' '>(info.column - 1 - info.front_truncation, b, ix);

            dump('^', b, ix);

         }

         b.resize(ix);

         return b;

      }

   }

}