/*
  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 "options.hpp"
#include "test_utils.hpp"

#include "authentication_type.hpp"
#include "deployment_type.hpp"

#include <algorithm>
#include <iostream>

#define DEFAULT_OPTIONS_CASSSANDRA_VERSION CCM::CassVersion("3.11.6")
#define DEFAULT_OPTIONS_DSE_VERSION CCM::DseVersion("6.7.7")
#define DEFAULT_OPTIONS_DDAC_VERSION CCM::DseVersion("5.1.17")

// Initialize the defaults for all the options
bool Options::is_initialized_ = false;
bool Options::is_help_ = false;
bool Options::is_keep_clusters_ = false;
bool Options::is_log_tests_ = true;
CCM::CassVersion Options::server_version_ = DEFAULT_OPTIONS_CASSSANDRA_VERSION;
bool Options::use_git_ = false;
std::string Options::branch_tag_;
bool Options::use_install_dir_ = false;
std::string Options::install_dir_;
std::string Options::cluster_prefix_ = "cpp-driver";
std::string Options::dse_username_;
std::string Options::dse_password_;
std::string Options::host_ = "127.0.0.1";
short Options::port_ = 22;
std::string Options::username_ = "vagrant";
std::string Options::password_ = "vagrant";
std::string Options::public_key_ = "public.key";
std::string Options::private_key_ = "private.key";
bool Options::is_verbose_ccm_ = false;
bool Options::is_verbose_integration_ = false;

// Static initialization is not guaranteed for the following types
CCM::DseCredentialsType Options::dse_credentials_type_;
CCM::AuthenticationType Options::authentication_type_;
CCM::DeploymentType Options::deployment_type_;
std::set<TestCategory> Options::categories_;
CCM::ServerType Options::server_type_;

bool Options::initialize(int argc, char* argv[]) {
  // Only allow initialization to occur once
  if (!is_initialized_) {
    // Initialize values that may not be assigned during static initialization
    dse_credentials_type_ = CCM::DseCredentialsType::USERNAME_PASSWORD;
    authentication_type_ = CCM::AuthenticationType::USERNAME_PASSWORD;
    deployment_type_ = CCM::DeploymentType::LOCAL;
    server_type_ = CCM::ServerType::CASSANDRA;

    // Check for the help argument first (keeps defaults for help display)
    for (int i = 1; i < argc; ++i) {
      if (std::string(argv[i]) == "--help") {
        print_help();
        is_help_ = true;
        return false;
      }
    }

    // Check for the DSE argument (update default server version)
    for (int i = 1; i < argc; ++i) {
      if (std::string(argv[i]) == "--dse") {
        server_version_ = DEFAULT_OPTIONS_DSE_VERSION;
      } else if (std::string(argv[i]) == "--ddac") {
        server_version_ = DEFAULT_OPTIONS_DDAC_VERSION;
      }
    }

    // Iterate through the command line arguments and parse the options
    for (int i = 1; i < argc; ++i) {
      std::vector<std::string> option = test::Utils::explode(argv[i], '=');
      std::string key(test::Utils::to_lower(option[0]));
      std::string value;
      if (option.size() > 1) {
        value = option[1];
      }
      // Integration test options
      if (key == "--keep-clusters") {
        is_keep_clusters_ = true;
      } else if (key == "--log-tests") {
        if (!value.empty()) {
          is_log_tests_ = bool_value(value);
        } else {
          std::cerr << "Missing Log Tests Boolean: Using default " << is_log_tests_ << std::endl;
        }
      }
      // CCM bridge specific options
      else if (key == "--version") {
        if (!value.empty()) {
          server_version_ = CCM::CassVersion(value);
        } else {
          std::cerr << "Missing Server Version: Using default " << server_version_.to_string()
                    << std::endl;
        }
      } else if (key == "--dse") {
        server_type_ = CCM::ServerType::DSE;
      } else if (key == "--ddac") {
        server_type_ = CCM::ServerType::DDAC;
      } else if (key == "--dse-username") {
        if (!value.empty()) {
          dse_username_ = value;
        }
      } else if (key == "--dse-password") {
        if (!value.empty()) {
          dse_password_ = value;
        }
      } else if (key == "--dse-credentials") {
        CCM::DseCredentialsType type = CCM::DseCredentialsType::from_string(value);
        if (type == CCM::DseCredentialsType::INVALID) {
          std::cerr << "Invalid DSE/DDAC Credentials Type: Using default "
                    << dse_credentials_type_.to_string() << std::endl;
        } else {
          dse_credentials_type_ = type;
        }
      } else if (key == "--git") {
        use_git_ = true;
        if (!value.empty()) {
          branch_tag_ = value;
        }
      } else if (key == "--install-dir") {
        use_install_dir_ = true;
        if (value.empty()) {
          std::cerr << "Disabling the Use of the Installation Directory: Installation directory "
                       "must not be empty"
                    << std::endl;
          use_install_dir_ = false;
        } else {
          install_dir_ = value;
        }
      } else if (key == "--prefix") {
        if (!value.empty()) {
          cluster_prefix_ = value;
        } else {
          std::cerr << "Missing Cluster Prefix: Using default " << cluster_prefix_ << std::endl;
        }
      } else if (key == "--category") {
        if (!value.empty()) {
          std::vector<std::string> categories = test::Utils::explode(value, ':');
          for (std::vector<std::string>::iterator iterator = categories.begin();
               iterator != categories.end(); ++iterator) {
            try {
              categories_.insert(*iterator);
            } catch (TestCategory::Exception& tce) {
              std::cerr << "Invalid Category: " << *iterator << " will be ignored"
                        << " (" << tce.what() << ")" << std::endl;
            }
          }
        } else {
          std::cerr << "Missing Category: All applicable tests will run" << std::endl;
        }
      } else if (key == "--verbose") {
        if (!value.empty() && !bool_value(value)) {
          std::vector<std::string> components = test::Utils::explode(value, ',');
          for (std::vector<std::string>::iterator it = components.begin(), end = components.end();
               it != end; ++it) {
            std::string component = test::Utils::to_lower(*it);
            if (component == "ccm") {
              is_verbose_ccm_ = true;
            } else if (component == "integration") {
              is_verbose_integration_ = true;
            } else {
              std::cerr << "Invalid Component \"" << *it
                        << "\": Available components are [ccm, integration]" << std::endl;
            }
          }
        } else {
          is_verbose_ccm_ = true;
          is_verbose_integration_ = true;
        }
      }
#ifdef CASS_USE_LIBSSH2
      else if (key == "--authentication") {
        CCM::AuthenticationType type = CCM::AuthenticationType::from_string(value);
        if (type == CCM::AuthenticationType::INVALID) {
          std::cerr << "Invalid Authentication Type: Using default "
                    << authentication_type_.to_string() << std::endl;
        } else {
          authentication_type_ = type;
        }
      } else if (key == "--deployment") {
        CCM::DeploymentType type = CCM::DeploymentType::from_string(value);
        if (type == CCM::DeploymentType::INVALID) {
          std::cerr << "Invalid Deployment Type: Using default " << deployment_type_.to_string()
                    << std::endl;
        } else {
          deployment_type_ = type;
        }
      } else if (key == "--host") {
        if (!value.empty()) {
          host_ = value;
        } else {
          std::cerr << "Missing Host: Using default " << host_ << std::endl;
        }
      } else if (key == "--port") {
        // Convert the value
        if (!value.empty()) {
          std::stringstream ss(value);
          if (!(ss >> port_).fail()) {
            continue;
          } else {
            std::cerr << "Invalid Port: Using default [" << port_ << "]";
          }
        }
      } else if (key == "--username") {
        if (!value.empty()) {
          username_ = value;
        } else {
          std::cerr << "Missing Username: Using default " << username_ << std::endl;
        }
      } else if (key == "--password") {
        if (!value.empty()) {
          password_ = value;
        } else {
          std::cerr << "Missing Password: Using default " << password_ << std::endl;
        }
      } else if (key == "--public-key") {
        if (!value.empty()) {
          public_key_ = value;
        } else {
          std::cerr << "Missing Public Key Filename: Using default " << public_key_ << std::endl;
        }
      } else if (key == "--private-key") {
        if (!value.empty()) {
          private_key_ = value;
        } else {
          std::cerr << "Missing Private Key Filename: Using default " << private_key_ << std::endl;
        }
      }
#endif
    }

    // Determine if the options should have their defaults reset
    if (categories_.empty()) {
      for (TestCategory::iterator iterator = TestCategory::begin(); iterator != TestCategory::end();
           ++iterator) {
        // Only add the DSE test category if DSE is enabled
        if (*iterator != TestCategory::DSE || is_dse()) {
          categories_.insert(*iterator);
        } else {
          std::cerr << "DSE Category Will be Ignored: DSE is not enabled [--dse]" << std::endl;
        }
      }
    }
    if (deployment_type_ == CCM::DeploymentType::LOCAL) {
      host_ = "127.0.0.1";
    }
    if (!is_cassandra() && !use_install_dir_) {
      // Determine if the DSE/DDAC credentials type should be updated
      if (dse_credentials_type_ == CCM::DseCredentialsType::USERNAME_PASSWORD) {
        if (dse_username_.empty() || dse_password_.empty()) {
          std::cerr << "Invalid Username and/or Password: Default to INI_FILE DSE/DDAC credentials"
                    << std::endl;
          dse_credentials_type_ = CCM::DseCredentialsType::INI_FILE;
        }
      }
    }

    is_initialized_ = true;
  }

  // Indicate the arguments were parsed successfully
  return true;
}

void Options::print_help() {
  std::cout << std::endl << "Integration Test Options:" << std::endl;
  std::cout << "  --log-tests=(yes|no)" << std::endl
            << "      "
            << "Enable/Disable logging of driver messages per test to a file." << std::endl
            << "      The default is " << (log_tests() ? "yes" : "no") << "." << std::endl;
  std::cout << std::endl << "CCM Options:" << std::endl;
  std::cout << "  --version=[VERSION]" << std::endl
            << "      "
            << "Cassandra/DSE/DDAC version to use." << std::endl
            << "      Default:" << std::endl
            << "        Cassandra Version: " << server_version().to_string() << std::endl
            << "        DSE Version: " << DEFAULT_OPTIONS_DSE_VERSION.to_string() << std::endl
            << "        DDAC Version: " << DEFAULT_OPTIONS_DDAC_VERSION.to_string() << std::endl;
  std::string categories;
  for (TestCategory::iterator iterator = TestCategory::begin(); iterator != TestCategory::end();
       ++iterator) {
    if (iterator != TestCategory::begin()) {
      categories += "|";
    }
    categories += iterator->name();
  }
  std::cout << "  --category=[" << categories << "]" << std::endl
            << "      "
            << "Run only the categories whose name matches one of the available" << std::endl
            << "      categories; ':' separates two categories. The default is all categories"
            << std::endl
            << "      being executed." << std::endl;
  std::cout << "  --dse" << std::endl
            << "      "
            << "Indicate server version supplied is DSE." << std::endl;
  std::cout << "  --ddac" << std::endl
            << "      "
            << "Indicate server version supplied is DDAC." << std::endl;
  std::cout << "  --dse-credentials=(USERNAME_PASSWORD|INI_FILE)" << std::endl
            << "      "
            << "DSE/DDAC credentials to use for download authentication. The default is "
            << std::endl
            << "      " << dse_credentials().to_string() << "." << std::endl;
  std::cout << "  --dse-username=[USERNAME]" << std::endl
            << "      "
            << "Username to use for DSE/DDAC download authentication." << std::endl;
  std::cout << "  --dse-password=[PASSWORD]" << std::endl
            << "      "
            << "Password to use for DSE/DDAC download authentication." << std::endl;
  std::cout << "  --git" << std::endl
            << "      "
            << "Indicate Cassandra/DSE server download should be obtained from" << std::endl
            << "      ASF/GitHub." << std::endl;
  std::cout << "  --git=[BRANCH_OR_TAG]" << std::endl
            << "      "
            << "Indicate Cassandra/DSE server branch/tag should be obtained from" << std::endl
            << "      ASF/GitHub." << std::endl;
  std::cout << "  --install-dir=[INSTALL_DIR]" << std::endl
            << "      "
            << "Indicate Cassandra/DSE installation directory to use." << std::endl;
  std::cout << "  --prefix=[PREFIX]" << std::endl
            << "      "
            << "CCM cluster prefix. The default is " << cluster_prefix() << "." << std::endl;
#ifdef CASS_USE_LIBSSH2
  std::cout << "  --authentication=(USERNAME_PASSWORD|PUBLIC_KEY)" << std::endl
            << "      "
            << "Authentication to use for remote deployment. The default is" << std::endl
            << "      " << authentication_type().to_string() << "." << std::endl;
  std::cout << "  --deployment=(LOCAL|REMOTE)" << std::endl
            << "      "
            << "Deployment to use. The default is " << deployment_type().to_string() << "."
            << std::endl;
  std::cout << "  --host=[IP_ADDRESS]" << std::endl
            << "      "
            << "IP address to use for remote deployment. The default is " << host() << "."
            << std::endl;
  std::cout << "  --port=[PORT]" << std::endl
            << "      "
            << "Port to use for remote deployment. The default is " << port() << "." << std::endl;
  std::cout << "  --username=[USERNAME]" << std::endl
            << "      "
            << "Username to use for remote deployment. The default is " << username() << "."
            << std::endl;
  std::cout << "  --password=[PASSWORD]" << std::endl
            << "      "
            << "Password to use for remote deployment. The default is " << password() << "."
            << std::endl;
  std::cout << "  --public-key=[FILENAME]" << std::endl
            << "      "
            << "Public key filename to use for remote deployment. The default is" << std::endl
            << "      " << public_key() << "." << std::endl;
  std::cout << "  --private-key=[FILENAME]" << std::endl
            << "      "
            << "Private key filename to use for remote deployment. The default is" << std::endl
            << "      " << private_key() << "." << std::endl;
#endif
  std::cout << "  --keep-clusters" << std::endl
            << "      "
            << "Indicate CCM clusters should not be removed after tests terminate." << std::endl;
  std::cout << "  --verbose(=ccm,integration)" << std::endl
            << "      "
            << "Enable verbose output for component(s)." << std::endl;
  std::cout << std::endl;
}

void Options::print_settings() {
  if (keep_clusters()) {
    std::cout << "  Keep clusters" << std::endl;
  }
  if (log_tests()) {
    std::cout << "  Logging driver messages" << std::endl;
  }
  if (!is_cassandra()) {
    std::cout << "  " << server_type_.to_string()
              << " Version: " << CCM::DseVersion(server_version()).to_string() << std::endl;
    if (!use_install_dir()) {
      if (dse_credentials() == CCM::DseCredentialsType::USERNAME_PASSWORD) {
        std::cout << "      Username: " << dse_username() << std::endl;
        std::cout << "      Password: " << dse_password() << std::endl;
      } else {
        std::cout << "      Using INI file for DSE/DDAC download authentication" << std::endl;
      }
    }
  } else {
    std::cout << "  " << server_type_.to_string() << " Version: " << server_version().to_string()
              << std::endl;
  }
  if (use_install_dir()) {
    std::cout << "    Using installation directory [" << install_dir() << "]" << std::endl;
  } else {
    if (use_git()) {
      std::cout << "      Using " << (is_dse() ? "GitHub" : "ASF") << " repository" << std::endl;
      if (!branch_tag_.empty()) {
        std::cout << "          Using branch/tag: " << branch_tag_ << std::endl;
      }
    }
  }
  std::cout << "  CCM Cluster Prefix: " << cluster_prefix() << std::endl;
#ifdef CASS_USE_LIBSSH2
  if (deployment_type() == CCM::DeploymentType::REMOTE) {
    std::cout << "  Remote Deployment:" << std::endl;
    std::cout << "      Host: " << host() << std::endl;
    std::cout << "      Port: " << port() << std::endl;
    if (authentication_type() == CCM::AuthenticationType::USERNAME_PASSWORD) {
      std::cout << "      Username: " << username() << std::endl;
      std::cout << "      Password: " << password() << std::endl;
    } else {
      std::cout << "      Public Key Filename: " << public_key() << std::endl;
      std::cout << "      Private Key Filename: " << private_key() << std::endl;
    }
  }
#endif
}

bool Options::is_help() { return is_help_; }

bool Options::keep_clusters() { return is_keep_clusters_; }

bool Options::log_tests() { return is_log_tests_; }

CCM::CassVersion Options::server_version() { return server_version_; }

CCM::ServerType Options::server_type() { return server_type_; }

bool Options::is_cassandra() { return server_type_ == CCM::ServerType::CASSANDRA; }

bool Options::is_dse() { return server_type_ == CCM::ServerType::DSE; }

bool Options::is_ddac() { return server_type_ == CCM::ServerType::DDAC; }

CCM::DseCredentialsType Options::dse_credentials() {
  // Static initialization cannot be guaranteed
  if (!is_initialized_) {
    return CCM::DseCredentialsType::USERNAME_PASSWORD;
  }
  return dse_credentials_type_;
}

const std::string& Options::dse_username() { return dse_username_; }

const std::string& Options::dse_password() { return dse_password_; }

bool Options::use_git() { return use_git_; }

const std::string& Options::branch_tag() { return branch_tag_; }

bool Options::use_install_dir() { return use_install_dir_; }

const std::string& Options::install_dir() { return install_dir_; }

const std::string& Options::cluster_prefix() { return cluster_prefix_; }

CCM::DeploymentType Options::deployment_type() {
  // Static initialization cannot be guaranteed
  if (!is_initialized_) {
    return CCM::DeploymentType::LOCAL;
  }
  return deployment_type_;
}

CCM::AuthenticationType Options::authentication_type() {
  // Static initialization cannot be guaranteed
  if (!is_initialized_) {
    return CCM::AuthenticationType::USERNAME_PASSWORD;
  }
  return authentication_type_;
}

std::set<TestCategory> Options::categories() { return categories_; }

const std::string& Options::host() { return host_; }

std::string Options::host_prefix() { return host_.substr(0, host_.size() - 1); }

short Options::port() { return port_; }

const std::string& Options::username() { return username_; }

const std::string& Options::password() { return password_; }

const std::string& Options::public_key() { return public_key_; }

const std::string& Options::private_key() { return private_key_; }

SharedPtr<CCM::Bridge, StdDeleter<CCM::Bridge> > Options::ccm() {
  return new CCM::Bridge(Options::server_version(), Options::use_git(), Options::branch_tag(),
                         Options::use_install_dir(), Options::install_dir(), Options::server_type(),
                         CCM::Bridge::DEFAULT_DSE_WORKLOAD, Options::cluster_prefix(),
                         Options::dse_credentials(), Options::dse_username(),
                         Options::dse_password(), Options::deployment_type(),
                         Options::authentication_type(), Options::host(), Options::port(),
                         Options::username(), Options::password(), Options::public_key(),
                         Options::private_key(), Options::is_verbose_ccm());
}

bool Options::is_verbose_ccm() { return is_verbose_ccm_; }

bool Options::is_verbose_integration() { return is_verbose_integration_; }

Options::Options() {}

bool Options::bool_value(const std::string& value) {
  std::string lower_value = test::Utils::to_lower(value);
  if (lower_value == "yes" || lower_value == "true" || lower_value == "on" || lower_value == "0") {
    return true;
  }
  return false;
}