/*
 *     .============.
 *    //  M A K E  / \
 *   //  C++ DEV  /   \
 *  //  E A S Y  /  \/ \
 * ++ ----------.  \/\  .
 *  \\     \     \ /\  /
 *   \\     \     \   /
 *    \\     \     \ /
 *     -============'
 *
 * Copyright (c) 2018 Hevake and contributors, all rights reserved.
 *
 * This file is part of cpp-tbox (https://github.com/cpp-main/cpp-tbox)
 * Use of this source code is governed by MIT license that can be found
 * in the LICENSE file in the root of the source tree. All contributing
 * project authors may be found in the CONTRIBUTORS.md file in the root
 * of the source tree.
 */
#include "json_deep_loader.h"
#include <fstream>

#include <tbox/base/log.h>
#include <tbox/base/json.hpp>
#include "json.h"
#include "string.h"
#include "fs.h"

namespace {
    const std::string kInclude = "__include__";
}

namespace tbox {
namespace util {
namespace json {

Json DeepLoader::load(const std::string &filename) {
    if (checkDuplicateInclude(filename))
        throw DuplicateIncludeError(filename);

    files_.push_back(filename);
    Json js = Load(filename);
    traverse(js);
    files_.pop_back();
    return js;
}

void DeepLoader::traverse(Json &js) {
    if (js.is_object()) {
        Json js_patch;
        for (auto &item : js.items()) {
            auto &js_value = item.value();
            if (item.key() == kInclude) {
                handleInclude(js_value, js_patch);
            } else {
                traverse(js_value);
            }
        }
        js.erase(kInclude);

        if (!js_patch.is_null())
            js.merge_patch(js_patch);

    } else if (js.is_array()) {
        for (auto &js_item : js) {
            traverse(js_item);
        }
    }
}

void DeepLoader::handleInclude(const Json &js_include, Json &js_parent) {
    if (js_include.is_string()) {
        includeByDescriptor(js_include.get<std::string>(), js_parent);
    } else if (js_include.is_array()) {
        for (auto &js_item : js_include) {
            if (js_item.is_string())
                includeByDescriptor(js_item.get<std::string>(), js_parent);
            else
                throw IncludeDescriptorTypeInvalid();
        }
    } else {
        throw IncludeDescriptorTypeInvalid();
    }
}

void DeepLoader::includeByDescriptor(const std::string &descriptor, Json &js) {
    std::vector<std::string> str_vec;
    string::Split(descriptor, "=>", str_vec);
    std::string filename = string::Strip(str_vec.at(0));

    std::string real_filename;
    if (filename.front() != '/') {
        auto dirname = fs::Dirname(files_.back());
        real_filename = dirname + '/' + filename;
    } else {
        real_filename = filename;
    }
 
    auto js_load = load(real_filename);

    if (str_vec.size() >= 2) {
        auto keyname = string::Strip(str_vec.at(1));
        js[keyname] = std::move(js_load);
    } else {
        js.merge_patch(std::move(js_load));
    }
}

bool DeepLoader::checkDuplicateInclude(const std::string &filename) const {
    return std::find(files_.begin(), files_.end(), filename) != files_.end();
}

Json LoadDeeply(const std::string &filename) {
    return DeepLoader().load(filename);
}

bool LoadDeeply(const std::string &filename, Json &js) noexcept {
    try {
        js = DeepLoader().load(filename);
        return true;

    } catch (const std::exception &e) {
        LogWarn("load json deeply fail, catch: %s", e.what());
    }

    return false;
}

}
}
}