#include "parse_args.h"
#include "build_info.h"
#include "input_help.h"

#include <cstdlib>
#include <iostream>
#include <iomanip>
#include <string>

#include "module_parameter/read_input.h"
#include "source_base/version.h"

#if defined(COMMIT_INFO)
#include "commit.h"
#endif

namespace ModuleIO
{

/**
 * @brief Format description for brief display in search results.
 *
 * Converts multi-line descriptions with list markers to single-line format:
 * - Replaces newlines with spaces
 * - Converts * list markers to -
 * - Collapses multiple spaces
 * - Truncates to max_length characters
 */
static std::string format_brief_description(const std::string& desc, size_t max_length = 60) {
 std::string result;
 result.reserve(desc.length());

 bool prev_space = false;
 bool at_line_start = true;

 for (size_t i = 0; i < desc.length(); ++i) {
 char c = desc[i];

 if (c == '\n') {
 // Replace newline with space (collapse multiple)
 if (!prev_space && !result.empty()) {
 result += ' ';
 prev_space = true;
 }
 at_line_start = true;
 } else if (c == '*' && at_line_start) {
 // Convert * list marker to -
 result += '-';
 prev_space = false;
 at_line_start = false;
 } else if (c == ' ' || c == '\t') {
 if (!prev_space && !result.empty()) {
 result += ' ';
 prev_space = true;
 }
 // Don't clear at_line_start for leading spaces
 } else {
 result += c;
 prev_space = false;
 at_line_start = false;
 }
 }

 // Trim trailing spaces
 while (!result.empty() && result.back() == ' ') {
 result.pop_back();
 }

 // Truncate if needed
 if (result.length() > max_length) {
 result = result.substr(0, max_length) + "...";
 }

 return result;
}

void print_build_info()
{
 const int label_width = 30;

 auto print_section = [](const std::string& title) {
 std::cout << std::endl;
 std::cout << "----------------- " << title << " -----------------" << std::endl;
 };

 auto print_info = [label_width](const std::string& label, const std::string& value) {
 std::cout << std::left << std::setw(label_width) << (label + ":") << " " << value << std::endl;
 };

 // --- 1. Core & Platform Info ---
 print_section("ABACUS Core & Platform");
 print_info("ABACUS Version", VERSION);
#if defined(COMMIT)
 print_info("Git Commit", COMMIT);
#else
 print_info("Git Commit", "N/A");
#endif
 print_info("Target Platform", ABACUS_PLATFORM_NAME);
 print_info("Build Type", ABACUS_BUILD_TYPE);

 // --- 2. Build Environment ---
 print_section("Build Environment");
 print_info("Built By", ABACUS_BUILD_USER);
 print_info("Built On", ABACUS_BUILD_HOST);
 print_info("Built At", std::string(__DATE__) + " " + __TIME__);

 // --- 3. Compiler Info ---
 print_section("Compiler & Flags");
 print_info("C++ Compiler", std::string(ABACUS_CXX_COMPILER_ID) + " (" + ABACUS_CXX_COMPILER_PATH + ")");
 print_info("C++ Compiler Ver", ABACUS_CXX_COMPILER_VERSION);
 print_info("C++ Flags", ABACUS_CXX_FLAGS);
 print_info("Linker Flags", ABACUS_LINKER_FLAGS);
 print_info("CUDA Flags", ABACUS_CUDA_FLAGS);

 // --- 4. Sanitizers & Debugging ---
 print_section("Sanitizers & Debugging");
 print_info("AddressSanitizer", ABACUS_ASAN_STATUS);
 print_info("Debug Symbols", ABACUS_DEBUG_SYMBOLS);

 // --- 5. CMake Configuration Summary ---
 print_section("CMake Configuration Summary");
 std::cout << ABACUS_CMAKE_OPTIONS << std::endl;
 std::cout << std::endl;
 std::cout << ABACUS_CMAKE_FIND_PACKAGES << std::endl;

 // --- 6. Parallelism & Communication ---
 print_section("Parallelism & Communication");
 print_info("MPI Implementation", ABACUS_MPI_IMPLEMENTATION);
 print_info("MPI Version", ABACUS_MPI_VERSION);
 print_info("CUDA-aware MPI", ABACUS_CUDA_AWARE_MPI);
 print_info("OpenMP Support", ABACUS_OPENMP_VERSION);

 // --- 7. Core Math Libraries ---
 print_section("Core Math Libraries");
#if defined(__LCAO)
 print_info("LCAO Algorithm", "yes");
#else
 print_info("LCAO Algorithm", "no");
#endif
 print_info("ELPA Support", ABACUS_ELPA_VERSION);
 print_info("MKL Support", ABACUS_MKL_SUPPORT);
 print_info("LibXC Support", ABACUS_LIBXC_VERSION);
 print_info("FFTW Support", ABACUS_FFTW_VERSION);

 // --- 8. Accelerators & Specific Hardware ---
 print_section("Accelerators & Hardware");
 print_info("NVIDIA CUDA Support", ABACUS_CUDA_VERSION);
 print_info("AMD ROCm Support", ABACUS_ROCM_VERSION);
 print_info("CUSOLVERMP Support", ABACUS_CUSOLVERMP_VERSION);

 // --- 9. Hybrid Functional Libraries ---
 print_section("Hybrid Functional Libraries");
 print_info("Cereal Serialization", ABACUS_CEREAL_VERSION);
 print_info("LibRI Support", ABACUS_LIBRI_VERSION);
 print_info("LibComm Support", ABACUS_LIBCOMM_VERSION);

 // --- 10. AI & Machine Learning ---
 print_section("AI & Machine Learning");
 print_info("LibTorch Support", ABACUS_LIBTORCH_VERSION);
 print_info("Libnpy Support", ABACUS_LIBNPY_VERSION);
 print_info("DeePMD-kit Support", ABACUS_DEEPMD_VERSION);
 print_info("NEP Support", ABACUS_NEP_VERSION);
 print_info("TensorFlow Support", ABACUS_TENSORFLOW_VERSION);

 // --- 11. Testing & Other Libraries ---
 print_section("Testing & Other Libraries");
 print_info("GTest Support", ABACUS_GTEST_VERSION);
 print_info("Google Benchmark", ABACUS_GOOGLEBENCH_VERSION);
 print_info("RapidJSON Support", ABACUS_RAPIDJSON_VERSION);
 print_info("PEXSI Support", ABACUS_PEXSI_VERSION);
 print_info("cnpy Support", ABACUS_CNPY_VERSION);

 std::cout << "----------------------------------------------------" << std::endl;
 std::cout << std::endl;
}

void parse_args(int argc, char** argv)
{
 for (int i = 1; i < argc; ++i) // Start from 1 to skip the program name
 {
 std::string arg = argv[i];
 if (arg == "--version" || arg == "-v" || arg == "-V")
 {
#if defined(VERSION)
 const char* version = VERSION;
#else
 const char* version = "unknown";
#endif
 std::cout << "ABACUS version " << version << std::endl;
 std::exit(0);
 }
 else if (arg == "--info" || arg == "-i" || arg == "-I")
 {
 print_build_info();
 std::exit(0);
 }
 else if (arg == "-h" || arg == "--help")
 {
 // Handle -h or -h <key>
 if (i + 1 < argc) {
 // Next argument exists - check if it's a parameter key
 std::string next_arg = argv[i + 1];
 if (!next_arg.empty() && next_arg[0] != '-') {
 // Not another flag - treat as parameter key
 ParameterHelp::initialize();
 // When parameter is found, output to stdout; when not found, output to stderr
 if (!ParameterHelp::show_parameter_help(next_arg, std::cout)) {
 std::cerr << "Error: Unknown parameter '" << next_arg << "'" << std::endl;

 // Try to find similar parameters (fuzzy matching)
 auto suggestions = ParameterHelp::find_similar_parameters(next_arg, 5, 3);
 if (!suggestions.empty()) {
 std::cerr << "\nDid you mean one of these?" << std::endl;
 for (const auto& suggestion : suggestions) {
 std::cerr << " - " << suggestion << std::endl;
 }
 }

 std::cerr << "\nUse 'abacus -s <keyword>' to search for parameters." << std::endl;
 std::exit(1);
 }
 std::exit(0);
 }
 }
 // No argument or next is a flag - show general help
 ParameterHelp::show_general_help();
 std::exit(0);
 }
 else if (arg == "-s" || arg == "--search")
 {
 // Require search query
 if (i + 1 >= argc || argv[i + 1][0] == '-') {
 std::cerr << "Error: -s requires a search query" << std::endl;
 std::exit(1);
 }

 std::string query = argv[++i];

 // Initialize help system
 ParameterHelp::initialize();

 auto results = ParameterHelp::search_parameters(query);
 if (results.empty()) {
 std::cerr << "No parameters found matching '" << query << "'" << std::endl;
 std::exit(1);
 }

 // Display results
 std::cout << "\nFound " << results.size() << " parameter(s) matching '" << query << "':\n\n";
 for (const auto& param : results) {
 auto metadata = ParameterHelp::get_metadata(param);
 std::cout << " " << std::left << std::setw(30) << param;
 if (!metadata.name.empty() && !metadata.description.empty()) {
 // Format description for brief display
 std::string desc = format_brief_description(metadata.description, 60);
 std::cout << " - " << desc;
 }
 std::cout << std::endl;
 }
 std::cout << "\nUse 'abacus -h <parameter>' for detailed help." << std::endl;
 std::exit(0);
 }
 else if (arg == "--generate-parameters-yaml")
 {
 ParameterHelp::generate_yaml(std::cout);
 std::exit(0);
 }
 else if (arg == "--check-input")
 {
 ModuleIO::ReadInput::check_mode = true;
 }
 else
 {
 // Error message goes to stderr
 std::cerr << "Error: Unknown argument: " << arg << std::endl;
 std::cerr << std::endl;

 // Display help information to stderr
 ParameterHelp::show_general_help(std::cerr);
 std::exit(1);
 }
 }
}

} // namespace ModuleIO