// Licensed to the Apache Software Foundation (ASF) under one
// or more contributor license agreements.  See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership.  The ASF licenses this file
// to you under the Apache License, Version 2.0 (the
// "License"); you may not use this file except in compliance
// with the License.  You may obtain a copy of the License at
//
//   http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing,
// software distributed under the License is distributed on an
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied.  See the License for the
// specific language governing permissions and limitations
// under the License.

#include "kudu/util/easy_json.h"

#include <ostream>
#include <string>
#include <utility>

#include <glog/logging.h>
#include <rapidjson/document.h>
#include <rapidjson/rapidjson.h>
#include <rapidjson/stringbuffer.h>
#include <rapidjson/writer.h>
// IWYU pragma: no_include <rapidjson/encodings.h>

using rapidjson::SizeType;
using rapidjson::Value;
using std::string;

namespace kudu {

EasyJson::EasyJson() : alloc_(new EasyJsonAllocator), value_(&alloc_->value()) {}

EasyJson::EasyJson(EasyJson::ComplexTypeInitializer type)
    : alloc_(new EasyJsonAllocator), value_(&alloc_->value()) {
  if (type == kObject) {
    value_->SetObject();
  } else if (type == kArray) {
    value_->SetArray();
  }
}

EasyJson EasyJson::Get(const string& key) {
  if (!value_->IsObject()) {
    value_->SetObject();
  }
  if (!value_->HasMember(key.c_str())) {
    Value key_val(key.c_str(), alloc_->allocator());
    value_->AddMember(key_val, Value().SetNull(), alloc_->allocator());
  }
  return EasyJson(&(*value_)[key.c_str()], alloc_);
}

EasyJson EasyJson::Get(int index) {
  if (!value_->IsArray()) {
    value_->SetArray();
  }
  while (SizeType(index) >= value_->Size()) {
    value_->PushBack(Value().SetNull(), alloc_->allocator());
  }
  return EasyJson(&(*value_)[index], alloc_);
}

EasyJson EasyJson::operator[](const string& key) {
  return Get(key);
}

EasyJson EasyJson::operator[](int index) {
  return Get(index);
}

EasyJson& EasyJson::operator=(const string& val) {
  value_->SetString(val.c_str(), alloc_->allocator());
  return *this;
}
template<typename T>
EasyJson& EasyJson::operator=(T val) {
  *value_ = val;
  return *this;
}
template EasyJson& EasyJson::operator=(bool val);
template EasyJson& EasyJson::operator=(int32_t val);
template EasyJson& EasyJson::operator=(int64_t val);
template EasyJson& EasyJson::operator=(uint32_t val);
template EasyJson& EasyJson::operator=(uint64_t val);
template EasyJson& EasyJson::operator=(double val);
template<> EasyJson& EasyJson::operator=(const char* val) {
  value_->SetString(val, alloc_->allocator());
  return *this;
}
template<> EasyJson& EasyJson::operator=(EasyJson::ComplexTypeInitializer val) {
  if (val == kObject) {
    value_->SetObject();
  } else if (val == kArray) {
    value_->SetArray();
  }
  return (*this);
}

EasyJson& EasyJson::SetObject() {
  if (!value_->IsObject()) {
    value_->SetObject();
  }
  return *this;
}

EasyJson& EasyJson::SetArray() {
  if (!value_->IsArray()) {
    value_->SetArray();
  }
  return *this;
}

EasyJson EasyJson::Set(const string& key, const string& val) {
  return (Get(key) = val);
}
template<typename T>
EasyJson EasyJson::Set(const string& key, T val) {
  return (Get(key) = val);
}
template EasyJson EasyJson::Set(const string& key, bool val);
template EasyJson EasyJson::Set(const string& key, int32_t val);
template EasyJson EasyJson::Set(const string& key, int64_t val);
template EasyJson EasyJson::Set(const string& key, uint32_t val);
template EasyJson EasyJson::Set(const string& key, uint64_t val);
template EasyJson EasyJson::Set(const string& key, double val);
template EasyJson EasyJson::Set(const string& key, const char* val);
template EasyJson EasyJson::Set(const string& key,
                                EasyJson::ComplexTypeInitializer val);

EasyJson EasyJson::Set(int index, const string& val) {
  return (Get(index) = val);
}
template<typename T>
EasyJson EasyJson::Set(int index, T val) {
  return (Get(index) = val);
}
template EasyJson EasyJson::Set(int index, bool val);
template EasyJson EasyJson::Set(int index, int32_t val);
template EasyJson EasyJson::Set(int index, int64_t val);
template EasyJson EasyJson::Set(int index, uint32_t val);
template EasyJson EasyJson::Set(int index, uint64_t val);
template EasyJson EasyJson::Set(int index, double val);
template EasyJson EasyJson::Set(int index, const char* val);
template EasyJson EasyJson::Set(int index,
                                EasyJson::ComplexTypeInitializer val);

EasyJson EasyJson::PushBack(const string& val) {
  if (!value_->IsArray()) {
    value_->SetArray();
  }
  Value push_val(val.c_str(), alloc_->allocator());
  value_->PushBack(push_val, alloc_->allocator());
  return EasyJson(&(*value_)[value_->Size() - 1], alloc_);
}
template<typename T>
EasyJson EasyJson::PushBack(T val) {
  if (!value_->IsArray()) {
    value_->SetArray();
  }
  value_->PushBack(val, alloc_->allocator());
  return EasyJson(&(*value_)[value_->Size() - 1], alloc_);
}
template EasyJson EasyJson::PushBack(bool val);
template EasyJson EasyJson::PushBack(int32_t val);
template EasyJson EasyJson::PushBack(int64_t val);
template EasyJson EasyJson::PushBack(uint32_t val);
template EasyJson EasyJson::PushBack(uint64_t val);
template EasyJson EasyJson::PushBack(double val);
template<> EasyJson EasyJson::PushBack(const char* val) {
  if (!value_->IsArray()) {
    value_->SetArray();
  }
  Value push_val(val, alloc_->allocator());
  value_->PushBack(push_val, alloc_->allocator());
  return EasyJson(&(*value_)[value_->Size() - 1], alloc_);
}
template<> EasyJson EasyJson::PushBack(EasyJson::ComplexTypeInitializer val) {
  if (!value_->IsArray()) {
    value_->SetArray();
  }
  Value push_val;
  if (val == kObject) {
    push_val.SetObject();
  } else if (val == kArray) {
    push_val.SetArray();
  } else {
    LOG(FATAL) << "Unknown initializer type";
  }
  value_->PushBack(push_val, alloc_->allocator());
  return EasyJson(&(*value_)[value_->Size() - 1], alloc_);
}

string EasyJson::ToString() const {
  rapidjson::StringBuffer buffer;
  rapidjson::Writer<rapidjson::StringBuffer> writer(buffer);
  value_->Accept(writer);
  return buffer.GetString();
}

EasyJson::EasyJson(Value* value, scoped_refptr<EasyJsonAllocator> alloc)
    : alloc_(std::move(alloc)), value_(value) {}

} // namespace kudu