#!/bin/python3
"""
A python script to generate empty definitions from a header file having declarations
Copyright  ©  2022  Matthias  Quintern.
This software comes with no warranty.
This software is licensed under the GPL3
"""

from typing import Callable
from os import path, listdir, chdir
from sys import argv, exit
import re

print_debug = False

# search in header files for enums 
header_filetypes = [".hpp"]
# definition are written to source file having the same name as the header
source_filetype = ".cpp"

def error(s):
    print(s)
    exit(1)

constexpr = "constexpr"
inline = "inline"
static = "static"

ACC_PUBLIC = 0
ACC_PRIVATE = 1
ACC_PROTECTED = 2
acc_to_uml = [ '+', '-', '#' ]
acc_to_str = [ 'public', 'private', 'protected' ]
uml_style_autoresize = True

def template_str2list(s:str):
    if s:
        templates = s.removeprefix("template<").removesuffix(">").split(", ")
        templates = [ t.split(" ") for t in templates ]
    else:
        templates = []
    return templates

def template_list2str(t:list[tuple[str, str]], req:str=""):
    if len(t) == 0:
        return ""
    s = "template<"
    for temp in t:
        s += temp[0] + " " + temp[1] + ", "
    s = s.removesuffix(", ") + ">\n"
    if req:
        s += "\t" + "requires " + req
    return s

def append_comma_separated(s: str, l: list[str]):
    for e in l:
        s += e + ", "
    return s.removesuffix(", ")
def apply_and_append_comma_separated(s: str, l: list[str], f: Callable[[str], str]):
    for e in l:
        s += f(e) + ", "
    return s.removesuffix(", ")

def transformString(s: str, depth: int):
    """Add tabs after all but the last line break and before the first char.
    Do not add tabs to lines that start with a label"""
    new_s = ""
    for line in s.split("\n"):
        if re.fullmatch(r"\w+:[^:].*", line) is None:
            new_s += depth * "\t";
        new_s += line + "\n"
    new_s = new_s.removesuffix("\n").removesuffix(depth*"\t")
    # return depth * tab + s.replace("\n", "\n" + depth * tab, s.count("\n") - 1)
    return new_s

def firstLetterUppercase(s: str) -> str:
    return s[0].capitalize() + s[1:]

type_to_uml_alias = {
    "unsigned int": "uint",
    "glm::vec2": "vec2",
    "glm::vec3": "vec3",
}
re_templated_type = r"([\w:]+)<(.*)>"

def type_to_uml(t: str) -> str:
    """
    std::vector<T> -> T[]
    std::array<T, N> -> T[N]
    std::map<K, T> -> { K : T }
    std::reference_wrapper<T> -> T&
    """
    if t in type_to_uml_alias.keys():
        return type_to_uml_alias[t]
    # if templated
    match = re.search(re_templated_type, t)
    if match:
        # remove namespaces
        # name of outer template
        t = match.groups()[0].split(":")[-1]
        # the template arguments
        temps = [ "" ]
        scope = 0
        for c in match.groups()[1]:
            if c == "<": scope += 1
            elif c == ">": scope -= 1
            elif c == ",":
                if scope == 0:
                    temps.append("")
                    continue
            temps[-1] += c
        if print_debug: print("type_to_uml", t, temps)

        if len(temps) == 0:
            pass
        elif len(temps) == 1:
            if t in [ "vector" ]:
                return type_to_uml(temps[0]) + "[]"
            elif t in [ "reference_wrapper" ]:
                return type_to_uml(temps[0]) + "&"
        elif len(temps) == 2:
            if "map" in t:
                return "{ " + type_to_uml(temps[0]) + " : " + type_to_uml(temps[1]) + " }"
            elif "pair" in t:
                return "{ " + type_to_uml(temps[0]) + ", " + type_to_uml(temps[1]) + " }"
            elif "array" in t:
                return f"{type_to_uml(temps[0])}[{type_to_uml(temps[1])}]"
        else:
            if t in "tuple":
                return "{ " + apply_and_append_comma_separated(t, temps, type_to_uml) + " }"

        return apply_and_append_comma_separated(t + "<", temps, type_to_uml) + ">"
    return t.strip(" ")


class Member:
    def __init__(self, name:str, m_temp:list=[], prefixes:list=[], ret_type:str="", args:str="", attributes="", init:str="", requires:str="", suffixes="", defined=False, is_value=False, namespace:str="", accessibility=ACC_PUBLIC):
        """
        :param name: member name
        :param m_temp: list of templates of the member
        :param prefixes:  things like constexpr, inline...
        :param ret_type: return type of the member
        :param args: arguments of the member
        :param init: initializion of the member
        :param attributes: c++11 attributes [[ ... ]]
        :param requires: constraints on template types
        :param suffixes: const noexcept
        :param defined: method defined
        :param is_value: wether the member is a value or a method
        :param accessibility: public, private or protected

        template<c_temp>
        class class {
            comment
            template<m_temp>
            prefixes ret_type name(args) const : init {
                body
            }
        }
        """
        self.name = name
        self.prefixes = prefixes
        self.m_temp = m_temp
        self.ret_type = ""
        if ret_type: self.ret_type = ret_type + " "
        self.args = args
        self.attributes = attributes
        self.init = ""
        if init: self.init = f"\n\t : {init} "
        self.requires = requires
        self.suffixes = suffixes  # have a ' ' in front of them
        self.defined = defined
        self.comment = ""
        self.accessibility = accessibility
        # if comment:
        #     if type(comment) == str:
        #         self.comment = "/// " + comment + "\n"
        #     elif type(comment) == dict:
        #         self.comment = comment_from_dict(comment)
        self.is_value = is_value
        self.namespace = namespace

    def getArgsAsList(self):
        args = []
        const = False
        arglist = self.args.split(", ")
        for i in range(len(arglist)):
            if "const" in arglist[i]:
                arglist[i] = arglist[i].replace("const ", "")
                const = True
            args.append(arglist[i].split(" "))
            if const:
                args[-1][0] = "const " + args[-1][0]
        return args

    def get_source_name(self, c_temp=[], class_=""):
        s = ""
        if class_:
            if len(c_temp) > 0:
                class_ = class_ + "<"
                for t in c_temp:
                    class_ += f"{t[1]}, "
                class_ = class_.removesuffix(", ") + ">"
            class_ += "::"

        s += template_list2str(self.m_temp, self.requires)
        for p in self.prefixes:
            s += p + " "

        if self.is_value:
            if static in self.prefixes and not constexpr in self.prefixes:
                s += f"{self.ret_type}{class_}{self.name};\n"
                return s
            else:
                s += f"{self.ret_type}{class_}{self.name};\n"
                return s
        s += f"{self.ret_type}{class_}{self.name}({self.args}){self.suffixes}"
        return s

    def source(self, c_temp=[], class_="", depth:int=0):
        """
        Return the empty defition + declarations for a source file
        """
        s = ""
        if class_:
            s += template_list2str(c_temp)
            if len(c_temp) > 0:
                class_ = class_ + "<"
                for t in c_temp:
                    class_ += f"{t[1]}, "
                class_ = class_.removesuffix(", ") + ">"
            class_ += "::"

        s += template_list2str(self.m_temp, self.requires)
        for p in self.prefixes:
            if p not in [ "static" ]:
                s += p + " "

        if self.is_value:
            if static in self.prefixes and not constexpr in self.prefixes:
                s += f"{self.ret_type}{class_}{self.name};\n"
                return s
            else:
                return ""

        s += f"{self.ret_type}{class_}{self.name}({self.args}){self.suffixes.replace(' override', '')}{self.init}" + " {\n\t\n}\n"
            # s += " {\n"
            # body = ""
            # for l in self.body: body += l + "\n"
            # s += transformString(body, depth)
            # s += "}\n"
        # else:
            # s += "{}"
        return transformString(s, depth)

    def uml(self):
        """
        Return uml representation of the member
        accessibility
        """
        if not self.ret_type: return ""  # if constructor, ret_type is empty
        s = acc_to_uml[self.accessibility] + " "
        s += self.name
        # if function
        if not self.is_value:
            s += "("
            for arg in self.args.split(','):
                s += type_to_uml(arg.replace("const", "").strip(' ').split(' ')[0]) + ", "
            s = s.strip(", ") + ")"
        s += ": " + type_to_uml(self.ret_type)
        return s + "\n"

    def getter(self, depth:int=0):
        """
        Return a getter
        """
        return transformString(f"inline const {self.ret_type.strip(' ')}& get{firstLetterUppercase(self.name)}() const " + "{ " + f"return {self.name};" + " }\n", depth)

    def lv_setter(self, depth:int=0):
        """
        Return a lvalue setter
        """
        return transformString(f"inline void set{firstLetterUppercase(self.name)}(const {self.ret_type.strip(' ')}& v) " + "{ " + f"{self.name} = v;" + " }\n", depth)

    def rv_setter(self, depth:int=0):
        """
        Return a rvalue setter
        """
        return transformString(f"inline void set{firstLetterUppercase(self.name)}({self.ret_type.strip(' ')}&& v) " + "{ " + f"{self.name} = std::move(v);" + " }\n", depth)

    def __eq__(self, other) -> bool:
        return self.name == other.name and self.args == other.args and self.ret_type == other.ret_type

    def __repr__(self):
        return self.get_source_name([], "")


class Class:
    def __init__(self, name: str, c_temp: list[tuple[str, str]]):
        self.member_functions: list[Member] = []
        self.member_variables: list[Member] = []
        self.name = name
        self.c_temp: list[tuple[str, str]] = c_temp

    def __repr__(self) -> str:
        return f"<{self.name}: {self.member_variables}, {self.member_functions}>"

    def uml(self):
        """
        Beginning of uml class
        """
        s = ""
        if self.c_temp:
            s += "template="
            for temp, t in self.c_temp:
                if temp == "typename":
                    s += t + ", "
                else:
                    s += t + ": " + temp + ", "
            s = s.strip(", ") + "\n"
        s += self.name + "\n--\n"
        for member in self.member_variables:
            s += member.uml()
        if self.member_variables: s += "--\n"
        for member in self.member_functions:
            s += member.uml()
        if uml_style_autoresize: s += "style=autoresize"
        return s + "\n"


#
# regex
#
# s must be a string where all indentation was removed
# COMMENTS
def starts_with_normal_comment(s: str) -> bool:
    if re.search(r"^(//|/?\*)[^*/]", s): return True
    else: return False

def starts_with_doxygen_comment(s: str) -> bool:
    if re.search(r"^(///|/\*\*)", s): return True
    else: return False

def starts_with_comment(s: str) -> bool:
    return starts_with_normal_comment(s) or starts_with_doxygen_comment(s);

def starts_with_comment_end(s: str) -> bool:
    if re.search(r"^(\*/)", s): return True
    else: return False

# NAMESPACE
def namespace_open(s: str) -> tuple[bool, str]:
    match = re.search(r"^namespace (\w+) *{", s)
    if match:
        return True, match.groups()[0]
    return False, ""


# TEMPLATE
def template_declaration(s: str) -> bool:
    if re.search(r"^template<(.+)>", s):
        return True
    return False

# CLASS DECLARATION
def class_declaration(s: str) -> tuple[bool, str]:
    match = re.search(r"^(?:(?:class)|(?:struct)) (\w+)", s)
    if match:
        return True, match.groups()[0]
    return False, ""

# VARIABLE/MEMBER DECLARATION
def variable_declaration(s: str, template_str:str = "", namespace:str="") -> tuple[bool, Member]:
    match = re.search(r"^((?:[\w<>:,]+ )+)(\w+)( *= *.+)? *;", s)
    # match = re.search(r"^((?:\w+ )+)(\w+) *(const)? *;", s)  # declration
    if match:
        g = match.groups()
        prefixes = []
        ret_type = ""
        if g[2]: defined = True
        else: defined = False
        # get ret_type and prefixes
        for prefix in g[0].strip(" ").split(" "):
            if prefix in ["const", "constexpr", "inline", "static"]:
                prefixes.append(prefix)
            else:
                ret_type += prefix + " "
        return True, Member(g[1], m_temp=template_str2list(template_str), prefixes=prefixes, ret_type=ret_type, is_value=True, defined=defined, namespace=namespace)
    return False, Member("")

re_spaces = r"[ \t]*"  # no or more spaces
re_spaces1 = r"[ \t]+"  # at least one space
# each of these regexes captures something in one group
re_ret_type = r"((?:[\w<>:,&*()]+ )+)"  # return type
re_attributes = r"((?:\[\[.+\]\])?)"  # eg [[ nodiscard ]]
re_function_name = r"(\w+(?:(?:\[\])|(?:\(\))|[+\-/%=*&]{0,2})?)"  # function name: eg operator[], operator%=, do_smth
re_function_args = r"\(((?:[\w<>:,&*= ]+,? )*(?:[\w<>:,&*= ]+))?\)"  # function parameters (capture without ()), eg (std::map<std::string, int> map, const Args&&... args)
re_suffixes = r"("  # eg const noexcept
for suffix in [ "const", "noexcept", "override" ]:
    re_suffixes += f"(?:{re_spaces1}{suffix})?"
re_suffixes += ")"

re_constructor = "^" + re_function_name + re_spaces + re_function_args + re_spaces + re_suffixes
re_member_f = "^" + re_attributes + re_spaces + re_ret_type + re_spaces + re_function_name + re_spaces + re_function_args + re_suffixes
re_member_f_declaration = re_member_f + re_spaces + ";"
re_member_f_dec_with_def = re_member_f + re_spaces + r"\{"

if print_debug: print("re_member_f_declaration:", re_member_f_declaration)
if print_debug: print("re_member_f_dec_with_def:", re_member_f_dec_with_def)
if print_debug: print("re_constructor:", re_constructor)

# FUNCTION DECLARATION
def function_declaration(s: str, template_str:str = "", namespace: str="") -> tuple[bool, Member]:
    # match = re.search(r"^((?:[\w<>:,&*]+ )+)(\w+)\(((?:[\w<>:,&*]+,? )*(?:[\w<>:,&*=]+))?\) *((const)?) *;", s)  # declration
    # groups are: attributes, ret_type, name, args, suffixes
    # if print_debug: print("function_declaration:", s.strip())
    match = re.search(re_member_f_declaration, s)  # declaration
    if match is None:
        # match = re.search(r"^((?:[\w<>:,&*]+ )+)(\w+)\(((?:[\w<>:,&*]+,? )*(?:[\w<>:,&*=]+))?\) *((?:const)?) * *{", s)  # declaration with definition
        match = re.search(re_member_f_dec_with_def, s)  # declaration with definition
        defined = True
    else:
        defined = False
    if match:
        g = match.groups()
        prefixes = []
        ret_type = ""
        # get ret_type and prefixes
        for prefix in g[1].strip(" ").split(" "):
            if prefix in ["const", "constexpr", "inline", "static"]:
                prefixes.append(prefix)
            else:
                ret_type += prefix + " "
        ret_type = ret_type.strip(" ")
        args = ""
        if g[3]:
            for arg in g[3].split(","):
                if "=" in arg:
                    args += arg[:arg.find("=")].strip(" ") + ", "
                else:
                    args += arg.strip(" ") + ", "
            args = args[:-2]
        else: args = ""
        if print_debug: print("function_declaration:", match.groups())

        return True, Member(g[2], template_str2list(template_str), prefixes=prefixes, ret_type=ret_type, args=args, attributes=g[0], defined=defined, suffixes=g[4], namespace=namespace)
    return False, Member("")

# constructor
def constructor_declaration(s: str, template_str:str = "", namespace: str="") -> tuple[bool, Member]:
    # match = re.search(r"^((?:[\w<>:,&*]+ )+)(\w+)\(((?:[\w<>:,&*]+,? )*(?:[\w<>:,&*=]+))?\) *((const)?) *;", s)  # declration
    # groups are: name, args, suffixes
    match = re.search(re_constructor, s)  # declaration
    if match:
        g = match.groups()
        args = ""
        if g[1]:
            for arg in g[1].split(","):
                if "=" in arg:
                    args += arg[:arg.find("=")].strip(" ") + ", "
                else:
                    args += arg.strip(" ") + ", "
            args = args[:-2]
        else: args = ""
        if print_debug: print("constructor_declaration:", match.groups())

        return True, Member(g[0], template_str2list(template_str), prefixes=[], ret_type="", args=args, defined=False, suffixes=g[2], namespace=namespace)
    return False, Member("")


#
# INDENTATION
# 
def get_indentation(s_indentation: str) -> int:
    """
    returns number of spaces
    """
    return s_indentation.replace("\t", "    ").count(" ")

def get_string_and_indent(s: str) -> tuple[str, int]:
    """
    returns the string without indentation and the number of spaces in the indentation
    """
    match = re.search("^([ \t]*)", s)
    if match:
        return s[len(match.groups()[0]):], get_indentation(match.groups()[0])
    return s, 0


# SCOPE END
def scope_end(s: str) -> bool:
    if re.search(r"^}", s):
        return True
    return False

def parse_header(header_file:str):
    with open(header_file, "r") as file:
        header = file.readlines()

    declarations: list[Class | Member] = []

    template_str = ""
    scopes : list[tuple[str, str, int, int]] = []   # type (eg class, namespace...), name, indentation, line
    in_class = ""
    namespace = ""
    accessibility = ACC_PUBLIC

    for i in range(len(header)):
        line, indent = get_string_and_indent(header[i])
        if starts_with_normal_comment(line): continue
        if starts_with_doxygen_comment(line):
            pass
        if starts_with_comment_end(line):
            pass

        if template_declaration(line):
            template_str = line.strip("\n")

        # check begin namespace
        match, name = namespace_open(line)
        if match:
            scopes.append(("namespace", name, indent, i))
            namespace += "::" + name
            namespace = namespace.strip("::")

        # check accessibility
        if in_class:
            for i in range(len(acc_to_str)):
                if acc_to_str[i] in line:
                    accessibility = i
        else:
            accessibility = ACC_PUBLIC

        # check class begin
        match, name = class_declaration(line)
        if match:
            # print("class in", i, "-", name)
            scopes.append(("class", name, indent, i))
            declarations.append(Class(name, c_temp=template_str2list(template_str)))
            in_class = name
            # declarations[-1].members.append(member_from_str(line, template_str))
            template_str = ""
        # check constructor
        match, member = constructor_declaration(line, template_str, namespace)
        if match:
            # print("function in", i, "-", member.get_source_name([], ""))
            member.accessibility = accessibility
            if in_class:
                declarations[-1].member_functions.append(member)
            else:
                declarations.append(member)
            template_str = ""
        # check function dec
        match, member = function_declaration(line, template_str, namespace)
        if match:
            # print("function in", i, "-", member.get_source_name([], ""))
            member.accessibility = accessibility
            if in_class:
                declarations[-1].member_functions.append(member)
            else:
                declarations.append(member)
            template_str = ""
        # check variable dec
        match, member = variable_declaration(line, template_str, namespace)
        if match:
            # print("variable in", i, "-", member.get_source_name([], ""))
            member.accessibility = accessibility
            if in_class:
                declarations[-1].member_variables.append(member)
            else:
                declarations.append(member)
            template_str = ""

        # check scope end
        if scope_end(line):
            if len(scopes) > 0 and scopes[-1][2] == indent:
                if (scopes[-1][0] == "namespace"):
                    for i in range(len(namespace)):
                        if namespace[-i-1] == ":":
                            namespace = namespace[:-i-2]
                            break;
                scopes.pop()
            else:
                # print("WARNING: Found scope end but no scope was opened at this indentaiton. line:", i)
                pass
    return declarations


def get_definition(declarations: list[Class | Member], target: (str | Member)):
    for dec in declarations:
        if type(dec) == Class:
            for mem in dec.member_functions + dec.member_variables:
                # print("mem", mem)
                if (type(target) == str and target in mem.name) or (type(target) == Member and target == mem):
                    return mem.source(dec.c_temp, dec.name, len(mem.namespace.split("::")))
        elif type(dec) == Member:
            if (type(target) == str and target in dec.name) or (type(target) == Member and target == dec):
                return dec.source([], "", len(dec.namespace.split("::")))

    return ""

def apply_on_target_member(f: Callable[[Member, int], str], declarations: list[Class | Member], target_name: (str | Member)):
    for dec in declarations:
        if type(dec) == Class:
            for mem in dec.member_variables + dec.member_functions:
                # print("mem", mem)
                if (type(target_name) == str and target_name in mem.name) or (type(target_name) == Member and target_name == mem):
                    return f(mem, len(mem.namespace.split("::"))+2)

    return ""

def apply_on_every_class_member(f: Callable[[Member], str], declarations: list[Class | Member], class_name: str):
    s = ""
    for dec in declarations:
        if type(dec) == Class and dec.name == class_name:
            for mem in dec.member_functions + dec.member_variables:
                s += f(mem)
                # print("mem", mem)

    return s

def apply_on_class(f: Callable[[Class], str], declarations: list[Class | Member], class_name: str):
    for dec in declarations:
        if type(dec) == Class and dec.name == class_name:
            return f(dec)
    return ""

def apply_on_all_classes(f: Callable[[Class], str], declarations: list[Class | Member]):
    s = ""
    for dec in declarations:
        if type(dec) == Class:
            s += f(dec)
    return s 

def print_help():
    print("""
Synposis:           gen_definitions.py <Options>... --file <file> --name <name>
General:
    -h --help           help
    --no-docs           turn off docstring generation
    --file <file>
Target:
    --name <name>
    --line <number>
Output:
    --getter
    --lv_setter
    --rv_setter
    --setters
    --getter-and-setter
    --def
    --uml
""")

# def missing_arg(arg):
#     print("Missing argument for", arg)
#     exit(1)

if __name__ == "__main__":
    docs = True
    getter = False
    rv_setter = False
    lv_setter = False
    definition = False
    uml = False
    file = ""
    target_name = ""
    target_line_nr = -1
    i = 1
    while i in range(1, len(argv)):
        if  argv[i] == "--help" or argv[i] == "-h":
            print_help()
            exit(0)
        elif argv[i] == "--no-docs":
            docs = False
        elif argv[i-1] == "--file":
            file = argv[i]
        elif argv[i] == "--getter-and-setter":
            getter = True
            lv_setter = True
            rv_setter = True
        elif argv[i] == "--lv_setter":
            lv_setter = True
        elif argv[i] == "--rv_setter":
            rv_setter = True
        elif argv[i] == "--setters":
            lv_setter = True
            rv_setter = True
        elif argv[i] == "--getter":
            getter = True
        elif argv[i] == "--def":
            definition = True
            interactive = True
        elif argv[i] == "--uml":
            uml = True
        elif argv[i-1] == "--name":
            target_name = argv[i]
        elif argv[i-1] == "--line":
            target_line_nr = int(argv[i])
        i += 1

    ret = ""
    declarations = []
    if file:
        if path.isfile(file):
            declarations = parse_header(file)
            if print_debug: print("found declartions:", declarations)
        else:
            print("Not a file:", file)
            exit(1)
    if target_line_nr > 0:
        with open(file) as file_:
            line, indent = get_string_and_indent(file_.readlines()[target_line_nr-1])
        if print_debug: print("line", target_line_nr, line)
        match, member = constructor_declaration(line, "", "")
        if match:
            target_name = member
        match, member = function_declaration(line, "", "")
        if match:
            target_name = member
        match, member = variable_declaration(line, "", "")
        if match:
            target_name = member
        if not target_name:
            error(f"Could not find target in line {target_line_nr}")

    s = ""
    if print_debug: print("target:", target_name)
    if getter:
        s += apply_on_target_member(Member.getter, declarations, target_name)
    if lv_setter:
        s += apply_on_target_member(Member.lv_setter, declarations, target_name)
    if rv_setter:
        s += apply_on_target_member(Member.rv_setter, declarations, target_name)
    if definition:
        s = get_definition(declarations, target_name).strip("\n")
    if uml:
        if target_name:
            s += apply_on_class(Class.uml, declarations, target_name)
        else:
            s += apply_on_all_classes(Class.uml, declarations)
        # s += apply_on_every_class_member(Member.uml, declarations, target_name)

    print(s, end='\n')