classdef.hpp

#pragma once

#include "context.hpp"  

#include <regex>
#include <string>
#include <vector>
#include <algorithm>



std::string strip_function_bodies(const std::string& input) {
    std::string output;
    int brace_level = 0;
    bool in_body = false;
    bool first_brace_skipped = false;

    for (char c : input) {
        
        // 1. Handle opening brace
        if (c == '{') {
            brace_level++;
            
            // Skip the very first opening brace (the class body start)
            if (brace_level == 1 && !first_brace_skipped) {
                first_brace_skipped = true;
                output += c; // Keep the class brace
                continue;
            }
            
            // If we are now entering a function/block body (level > 1, as 1 is the class scope)
            if (brace_level > 1) { 
                in_body = true;
                output += ';'; // Replace opening brace of the function body with a semicolon
                continue;      // Skip the actual brace
            }
        } 
        
        // 2. Handle closing brace
        else if (c == '}') {
            brace_level--;
            
            // If we just exited a function body (brace_level is 1, meaning we're back in class scope)
            if (brace_level == 1 && in_body) {
                in_body = false;
                continue; // Skip the closing brace of the stripped body
            }
            
            // If we reached the closing brace of the whole class definition (brace_level 0)
            if (brace_level == 0) {
                output += c; // Keep the class closing brace
                continue;
            }
        }
        
        // 3. Append content
        // Only append character if we are NOT inside a stripped function body
        if (!in_body) {
            output += c;
        }
    }

    // replace multiple consecutive semicolons with a single semicolon
    std::string::size_type pos = 0;
    while ((pos = output.find(";;", pos)) != std::string::npos) {
        output.replace(pos, 2, ";");
    }

    return output;
}
 
std::vector<std::string> split_args(const std::string& full_args) {
    // trim whitespaces and parentheses
    std::string trimmed = full_args;
    trimmed.erase(0, trimmed.find_first_not_of(" \t\n\r\f\v("));
    trimmed.erase(trimmed.find_last_not_of(" \t\n\r\f\v)") + 1);

 
    trimmed.erase(std::remove_if(trimmed.begin(), trimmed.end(), [](char c) {
        return c == '\n' || c == '\r' || c == '\t';
    }), trimmed.end());


    std::regex space_regex(R"(\s+)");
    trimmed = std::regex_replace(trimmed, space_regex, " ");

    std::vector<std::string> args;
    if (trimmed.empty() || trimmed == "()") 
        return args;

    const std::regex arg_regex(R"(([^\s,<>]*<[^\,]*?(?:<.*?>[^\,]*?)*>[^,]*|[^,]+))");
    auto it_begin = std::sregex_iterator(trimmed.begin(), trimmed.end(), arg_regex);
    auto it_end = std::sregex_iterator();

    for (std::sregex_iterator i = it_begin; i != it_end; ++i) {
        std::smatch match = *i;
        std::string full_arg = match.str();

        // Trim leading/trailing whitespace
        full_arg.erase(0, full_arg.find_first_not_of(' '));
        full_arg.erase(full_arg.find_last_not_of(' ') + 1);


        std::string final_arg = full_arg;
        size_t last_space = final_arg.find_last_of(' ');
        
        if (last_space != std::string::npos) {
             std::string possible_name = final_arg.substr(last_space + 1);
             if (possible_name.find('*') == std::string::npos && 
                 possible_name.find('&') == std::string::npos) {
                // If the token after the last space doesn't contain * or &, it's likely the variable name.
                final_arg = final_arg.substr(0, last_space);
             }
        }

        final_arg.erase(final_arg.find_last_not_of(' ') + 1);
        
        if (!final_arg.empty()) {
            args.push_back(final_arg);
        }
    }

    return args;
}

enum class FuncType {
    Member,
    Static,
    Virtual,
    PureVirtual,
    Templated
};

const char* FuncTypeToString(FuncType type) {
    switch (type) {
        case FuncType::Member: return "Member";
        case FuncType::Static: return "Static";
        case FuncType::Virtual: return "Virtual";
        case FuncType::PureVirtual: return "PureVirtual";
        case FuncType::Templated: return "Templated";
        default: return "Unknown";
    }
}

enum class AccessLevel {
    Private,
    Protected,
    Public
};

std::string AccessLevelToString(AccessLevel level) {
    switch (level) {
        case AccessLevel::Private: return "Private";
        case AccessLevel::Protected: return "Protected";
        case AccessLevel::Public: return "Public";
        default: return "Unknown";
    }
}


struct FuncSpec {
    FuncType type;
    AccessLevel access_level;
    bool is_const;
    std::string return_type;
    std::string name;
    std::vector<std::string> arg_types;
};

std::vector<FuncSpec> analyze_class_def(const std::string& class_def) {
    std::map<size_t, AccessLevel> access_map;
    
    // Default access for a 'class' is Private. 
    // (If parsing a 'struct', change this to Public).
    AccessLevel current_default = AccessLevel::Private; 

    // Regex to find access specifiers (e.g., "public:", "private:")
    const std::regex access_regex(R"(\b(public|protected|private)\s*:)");
    
    auto access_begin = std::sregex_iterator(class_def.begin(), class_def.end(), access_regex);
    auto access_end = std::sregex_iterator();

    for (std::sregex_iterator i = access_begin; i != access_end; ++i) {
        std::smatch match = *i;
        std::string label = match[1].str();
        size_t position = match.position();

        if (label == "public") access_map[position] = AccessLevel::Public;
        else if (label == "protected") access_map[position] = AccessLevel::Protected;
        else if (label == "private") access_map[position] = AccessLevel::Private;
    }

    std::vector<FuncSpec> functions;


    


    // --- Primary Regex (Non-Templated, Non-Destructor Functions) ---
    // This pattern is now robust because function bodies have been stripped.
    // 
    // New Capture Groups:
    // Group 1: virtual
    // Group 2: static
    // Group 3: The entire Return Type string
    // Group 4: Function Name
    // Group 5: The entire Argument List (inside parentheses)
    // Group 6: const qualifier
    // Group 7: = 0 (Pure Virtual marker)
    //
    // Note: The logic for getting the return type is simplified by matching the entire prefix
    // const std::regex function_regex(
    //     R"(\s*(?:(virtual)\s*)?(?:(static)\s*)?(?!(template|~))\s*(.*?)\s+(\w+)\s*(\([^(]*?\))\s*(const)?\s*(=\s*0)?\s*[;{])",
    //     std::regex::optimize
    // );

    const std::regex function_regex(
        // Group 1: Optional Template Declaration (e.g., "template <typename T>")
        // Group 2: Virtual
        // Group 3: Static
        // Group 4: Return Type
        // Group 5: Function Name
        // Group 6: Args
        // Group 7: Const
        // Group 8: Pure Virtual (= 0)
        R"(\s*(?:(template\s*<[^>]*>)\s*)?(?:(virtual)\s*)?(?:(static)\s*)?(?!~)\s*(.*?)\s+(\w+)\s*(\([^(]*?\))\s*(const)?\s*(=\s*0)?\s*[;{])",
        std::regex::optimize
    );

    // // --- Template Regex ---
    // // Group 1: The entire Return Type string
    // // Group 2: Function Name
    // // Group 3: The entire Argument List (inside parentheses)
    // const std::regex template_regex(
    //     R"(\s*template\s+[^>]+>\s*(.*?)\s+(\w+)\s*(\([^(]*?\))\s*[;{])",
    //     std::regex::optimize
    // );

    std::sregex_iterator current_match(class_def.begin(), class_def.end(), function_regex);
    std::sregex_iterator last_match; 

    while (current_match != last_match) {
        std::smatch match = *current_match;

        // FIX: If Group 1 (template declaration) matched, ignore this function 
        // because it is a template, not a standard member function.
        if (match[1].matched) {
            current_match++;
            continue;
        }

        FuncSpec spec;
        // Indices 4, 5, 6, 7, 8 remain mostly consistent with your logic
        // provided the lookahead group #3 was removed/adjusted.
        spec.return_type = match[4].str();
        spec.name        = match[5].str();
        spec.is_const    = match[7].matched;   
        spec.arg_types   = split_args(match[6].str());

        // Adjusted indices for virtual/static
        if (match[2].matched) { // virtual is now Group 2
            if (match[8].matched) { // = 0
                spec.type = FuncType::PureVirtual;
            } else {
                spec.type = FuncType::Virtual;
            }
        } else if (match[3].matched) { // static is now Group 3
            spec.type = FuncType::Static;
        } else {
            spec.type = FuncType::Member;
        }

        size_t func_pos = match.position();
        auto access_it = access_map.upper_bound(func_pos);
        if (access_it == access_map.begin()) {
            spec.access_level = current_default;
        } else {
            --access_it;
            spec.access_level = access_it->second;
        }

        functions.push_back(spec);
        current_match++;
    }

    // // --- Handle Templated Functions ---
    // std::sregex_iterator template_match(class_def.begin(), class_def.end(), template_regex);
    // while (template_match != last_match) {
    //     std::smatch match = *template_match;
        
    //     std::string return_type = match[1].str(); // Group 1
    //     std::string func_name = match[2].str();   // Group 2
    //     std::string full_args = match[3].str();   // Group 3

    //     std::string cleaned_args = "not supported";
    //     // std::string cleaned_args = clean_arg_list(full_args);
        
    //     std::cout << "**Templated** | " << return_type << " | " << func_name << " | " << cleaned_args << "\n";
    //     template_match++;
    // }

    return functions;
}