#pragma once

#include "json_binder.hpp"
#include "json/json_common.hpp"

#include <iosfwd>
#include <sstream>

namespace json { namespace binder {
  template <typename T, typename S = T>
  class visitor {
  public:
    visitor(S& o, binder_impl<T>& b) : obj(o), b(b) {}

    void parse(char const* data, parser::options opts) {
      b.parse(obj, data, opts);
      if ( json::helper::get_next_element(data)
          && opts & parser::disable_concatenated_json_bodies ) {
        throw malformed_json_exception{
          "Config set to require json input be terminated"
        };
      }
    }

    void write(std::ostream & data) const {
      b.write(obj, data);
    }

    private:
      S& obj;
      binder_impl<T>& b;
  };

  template <typename T, typename S>
  visitor<T, S> bind(S& object, binder_impl<T>& b) {
    return {object, b};
  }
} }

namespace json { namespace parser {
  template <typename T>
  void parse(binder::visitor<T>& visitor, char const* data,
             options opts = allow_all) {
    visitor.parse(data, opts);
  }

  template <typename T, typename S>
  void write(binder::visitor<T, S> const & visitor, std::ostream & out) {
    visitor.write(out);
  }

  template <typename T, typename S>
  void write(binder::visitor<T, S> const & visitor, std::string & data) {
    std::stringstream ss;
    visitor.write(ss);
    data = ss.str();
  }
} }