// Copyright 2016 Etix Labs
//
// Licensed 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 "opt_parse.h"
#include <iostream>

namespace etix {

namespace tool {

opt_parse::opt_parse(int argc, char* argv[]) : argc(argc), argv(argv) {}

opt_parse::~opt_parse() {}

void
opt_parse::required(const std::string& name, const std::string& desc, bool need_arg) {
    this->params.emplace(name, opt_param(true, need_arg, name, desc));
}

void
opt_parse::optional(const std::string& name, const std::string& desc, bool need_arg) {
    this->params.emplace(name, opt_param(false, need_arg, name, desc));
}

bool
opt_parse::execute() {
    int i = 1;

    // if params are invalid
    if (this->argc < 1 || not this->argv) { return false; }

    while (i != this->argc) {
        // there is less argument than argc
        if (not this->argv[i]) { return false; }
        auto params = this->params.find(std::string(this->argv[i]));
        if (params != this->params.end()) {
            this->params_cnt += 1;
            (*params).second.is_passed = true;
            if ((*params).second.need_arg == true && (i + 1) != this->argc) {
                (*params).second.argument = this->argv[i + 1];
                i += 1;
            }
        }
        i += 1;
    }
    return true;
}

opt_parse::iterator
opt_parse::begin() const {
    std::vector<std::pair<std::string, std::string>> p;

    for (auto entry : this->params) {
        p.push_back(std::make_pair(entry.second.name, entry.second.argument));
    }
    return iterator(p, 0);
}

opt_parse::iterator
opt_parse::end() const {
    return iterator(std::vector<std::pair<std::string, std::string>>(), this->params_cnt);
}

void
opt_parse::print_usage() const {
    std::cout << "Usage: " << this->argv[0];

    for (auto entry : this->params) {
        if (entry.second.required == true) {
            if (entry.second.need_arg == true) { std::cout << " <arg>"; }
        }
    }
    std::cout << std::endl;
}

void
opt_parse::print_help() const {
    std::cout << "help: " << this->argv[0] << std::endl;

    for (auto entry : this->params) {
        std::cout << entry.second.name << "    " << entry.second.desc << std::endl;
    }
}

bool
opt_parse::has_error() const {
    for (auto entry : this->params) {
        // is the parameter required ?
        // the parameter need arguement ?
        if ((entry.second.required == true && entry.second.is_passed == false) ||
            (entry.second.is_passed == true && entry.second.need_arg == true &&
             entry.second.argument == "")) {
            return true;
        }
    }

    return false;
}

bool
opt_parse::exist(const std::string& opt) const {
    auto params = this->params.find(opt);

    if (params == this->params.end()) { return false; }

    return (*params).second.is_passed;
}

std::string opt_parse::operator[](const std::string& opt) const {
    std::string param("");

    auto opt_param = this->params.find(opt);
    if (opt_param != this->params.end()) { param = (*opt_param).second.argument; }

    return param;
}

} // tool

} // etix