#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();
  }
}}