//
//  json_direct_scalar_binder.hpp
//  json
//
//  Created by Sam Jaffe on 4/23/16.
//

#pragma once

#include "json_binder.hpp"
#include "json_direct_binder.hpp"

#include <string>

namespace json { namespace binder {
  template <typename T> class direct_binder<T, bool> : public binder_impl<T> {
  public:
    explicit direct_binder(bool T::*p) : ptr(p) {}
    virtual binder_impl<T> * clone() const override {
      return new direct_binder(*this);
    }

    virtual void parse(T & val, char const *& data,
                       parser::options) const override {
      if (!strncmp(data, "true", 4)) {
        val.*ptr = true;
        data += 4;
      } else if (!strncmp(data, "false", 5)) {
        val.*ptr = false;
        data += 5;
      } else {
        throw json::malformed_json_exception("Expected a boolean type here");
      }
    }

    virtual void write(T const & val, std::ostream & data) const override {
      data << (val.*ptr ? "true" : "false");
    }

  private:
    bool T::*ptr;
  };

#define JSON_IS_INTEGRAL_T(Type)                                               \
  typename std::enable_if<std::is_integral<Type>::value>::type
  template <typename T, typename N>
  class direct_binder<T, N, JSON_IS_INTEGRAL_T(N)> : public binder_impl<T> {
  public:
    explicit direct_binder(N T::*p) : ptr(p) {}
    virtual binder_impl<T> * clone() const override {
      return new direct_binder(*this);
    }

    virtual void parse(T & val, char const *& data,
                       parser::options) const override {
      json::helper::parse_numeric(val.*ptr, data);
    }

    virtual void write(T const & val, std::ostream & data) const override {
      data << val.*ptr;
    }

  private:
    N T::*ptr;
  };

#define JSON_IS_FLOATING_T(Type)                                               \
  typename std::enable_if<std::is_floating_point<Type>::value>::type
  template <typename T, typename N>
  class direct_binder<T, N, JSON_IS_FLOATING_T(N)> : public binder_impl<T> {
  public:
    explicit direct_binder(N T::*p) : ptr(p) {}
    virtual binder_impl<T> * clone() const override {
      return new direct_binder(*this);
    }

    virtual void parse(T & val, char const *& data,
                       parser::options) const override {
      json::helper::parse_double(val.*ptr, data);
    }

    virtual void write(T const & val, std::ostream & data) const override {
      data << std::fixed << val.*ptr;
    }

  private:
    N T::*ptr;
  };

  template <typename T>
  class direct_binder<T, std::string> : public binder_impl<T> {
  public:
    explicit direct_binder(std::string T::*p) : ptr(p) {}
    virtual binder_impl<T> * clone() const override {
      return new direct_binder(*this);
    }

    virtual void parse(T & val, char const *& data,
                       parser::options) const override {
      json::helper::parse_string(val.*ptr, data);
    }

    virtual void write(T const & val, std::ostream & data) const override {
      data << "\"" << json::helper::replace_all(val.*ptr, "\"", "\\\"") << "\"";
    }

  private:
    std::string T::*ptr;
  };
}}