#!/bin/python3
"""
A python script to generate a c++ vector and matrix library for mathematics.
Should work with vectors/matrix up to a length of 9.

The script generates a header (and source) for each container (vector/matrix).
There are overloads for each container which allow convenient usage. 
Eg multiplication with matrix rules is as easy as: (example)
mat3x2 = mat3x3 * mat3x2
n = rvec4 * vec4
To be accurate, there is a differentiation between row and column vector, they are basically the same but each has a separate class which differ only for the matrix multiplication overloads.

To help compile times, the templated definitions of most methods is in the source file (by default).
That means that all templates must be explictly instantiated beforehand. The instantiations are in the tpp file included by the cpp files.
Specify the needed types by adding them to templateInstantiationIntTypes and templateInstantiationFloatTypes respectively (the differentiation is needed for the modulo operator).

All that makes the generated library is not memory efficient, but very fast and convenient.

AS OF NOW, THIS SOFTWARE IS NEARLY UNTESTED AND BOUND TO CONTAIN LOTS OF BUGS.

Copyright  ©  2022  Matthias  Quintern.
This software comes with no warranty.
This software is licensed under the GPL3
"""

from os import path, mkdir
#
# SETTINGS
# 
# generate up to MAX_N (-> vecN, matNxN)
MAX_N = 4
letters_ = {
    2: [ "x", "y" ],
    3: [ "x", "y", "z" ],
    4: [ "x", "y", "z", "w"],
}
directory = "math"
#
# \t or x-spaces
tab = "\t"
# float, double, long double...
float_type = "float"
# string or None
namespace = "gz"
typeShorts = {
    "float": "f",
    "double": "d",
    "int": "i",
    "unsigned int": "u",
}
include_static_asserts = True
include_template_instantiations = True
templateInstantiationIntTypes = [  # these must be usable with %
    # "uint8_t"
    "uint8_t", "uint16_t", "uint32_t", "uint64_t",
    "int8_t", "int16_t", "int32_t", "int64_t",
]
templateInstantiationFloatTypes = [
    # "float",
    "float", "double", "long double"
]
templateInstantiationTypes = templateInstantiationFloatTypes + templateInstantiationIntTypes


headerIncludes = [ "\"concepts.hpp\"", "\"../container/iterator.hpp\"" ]
sourceIncludes = ["<cmath>", "<algorithm>", "<cstdint>"]


# shorthands
Number_N = ("Number", "N")
Class_T = [("Number", "T")]
constexpr = "constexpr"
inline = "inline"


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


class Member:
    def __init__(self, class_:str, name:str, c_temp:list=[], m_temp:list=[], prefixes:list=[], ret_type:str="", args:str="", init:str="", const=False, body:list=[], comment:str=""):
        """
        :param class: class name
        :param name: member name
        :param c_temp: list of templates of the class
        :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 const: True if the method does not change the object
        :param body: method body
        :param comment: a single-line docstring

        template<c_temp>
        class class {
            comment
            template<m_temp>
            prefixes ret_type name(args) const : init {
                body
            }
        }
        """
        self.class_ = class_
        self.name = name
        self.prefixes = prefixes
        self.c_temp = c_temp
        self.m_temp = m_temp
        self.ret_type = ""
        if ret_type: self.ret_type = ret_type + " "
        self.args = args
        self.init = ""
        if init: self.init = f"\n{tab} : {init} "
        self.const = ""
        if const: self.const = " const"
        self.body = body
        self.comment = ""
        if comment: self.comment = "/// " + comment + "\n"

    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 defintionH(self, depth:int=0):
        """
        Return the defition to be used in a header
        """
        s = ""
        s += self.comment
        s += template(self.m_temp)
        for p in self.prefixes:
            s += p + " "
        s += self.ret_type + self.name + f"({self.args}){self.const};\n"
        return transformString(s, depth)

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

        s += template(self.m_temp)
        for p in self.prefixes:
            s += p + " "
        s += f"{self.ret_type}{class_}::{self.name}({self.args}){self.const}{self.init}"
        if self.body:
            s += " {\n"
            body = ""
            for l in self.body: body += l + "\n"
            s += transformString(body, depth)
            s += "}\n"
        else:
            s += "{}"
        return transformString(s, depth)

    def header(self, depth:int=0):
        """
        Return the defition + declarations for a header file
        """
        s = ""
        s += self.comment
        s += template(self.m_temp)
        for p in self.prefixes:
            s += p + " "
        s += f"{self.ret_type}{self.name}({self.args}){self.const}{self.init}"
        if self.body:
            s += " {\n"
            body = ""
            for l in self.body: body += l + "\n"
            s += transformString(body, depth+1)
            s += "}\n"
        else:
            s += "{}\n"
        return transformString(s, depth)

    def isConstructor(self):
        return self.class_ == self.name

    def templateInstantiations(self):
        """
        generate instantiations for all templates
        right now only works with Number concepts
        temp<Number T>
        temp<Number N>
        void Class<T>::operator+(class<N>) {
        ->
        temp<> void Class<float>::operator+(class<float>)
        ...
        """
        if len(self.m_temp) == 0:
            return ""
        class_ = self.class_
        if len(self.c_temp) > 0:
            class_ = self.class_ + "<"
            for t in self.c_temp:
                class_ += f"{t[1]}, "
            class_ = class_.removesuffix(", ") + ">"

        arglist = self.getArgsAsList()
        args = ""
        for arg in arglist:
            args += arg[0] + ", "
        args = args.removesuffix(", ")
        name = self.name.removesuffix(" ")
        if len(self.m_temp) > 0:
            name += " <"
            for type_ in self.m_temp:
                name += type_[1] + ", "
            name = name.removesuffix(", ") + ">"

        method = f"{self.ret_type}{class_}::{name}({args}){self.const}"
        instantiations = []
        if len(self.c_temp) > 0 or len(self.m_temp) > 0:
            if "%" in method: types = templateInstantiationIntTypes
            else: types = templateInstantiationTypes
            getTemplateInsts(method, instantiations, self.c_temp + self.m_temp, types, 0)
        s = ""
        for spec in instantiations:
            s += spec + "\n"
        return s + "\n";


#
# HELPERS
#
def classname(row, col, template=""):
    name = ""
    if template and col == 1 and row == 1:
        return template
    elif col == 1:
        name =  "vec" + str(row)
    elif row == 1:
        name = "rvec" + str(col)
    else:
        name = "mat" + str(row) + "x" + str(col);
    if template:
        name += "<" + template + ">"
    return name


def concept(row, col, template=""):
    name = ""
    if template and col == 1 and row == 1:
        return template
    elif col == 1:
        name =  "ColumnVector" + str(row)
    elif row == 1:
        name = "RowVector" + str(col)
    else:
        name = "Mat" + str(row) + "x" + str(col);
    if template:
        name += "<" + template + ">"
    return name


def classnameFromConcept(concept:str):
    name = ""
    number = ""
    if concept.startswith("ColumnVector"):
        name = "vec"
        number = concept.removeprefix("ColumnVector")
    elif concept.startswith("RowVector"):
        name = "rvec"
        number = concept.removeprefix("RowVector")
    elif concept.startswith("Mat"):
        name = "mat"
        number = concept.removeprefix("Mat")
    return name + number


def varname(r, c, rows, cols):
    """Get the name of the variable in row r and column c"""
    if rows == 1:
        if cols in letters_.keys():
            return letters_[cols][c]
        else:
            return f"x{r+1}"
    elif cols == 1:
        if rows in letters_.keys():
            return letters_[rows][r]
        else:
            return f"x{c+1}"
    else:
        return f"x{r+1}_{c+1}"


def varnameI(i, rows, cols):
    """Get the name of the ith variable"""
    if rows == 1:
        if cols in letters_.keys():
            return letters_[cols][i%cols]
        else:
            return f"x{i+1}"
    elif cols == 1:
        if rows in letters_.keys():
            return letters_[rows][i%rows]
        else:
            return f"x{i+1}"
    else:
        return f"x{i%rows+1}_{i%cols+1}"



def genstring(row: int, col: int, template: str, sep=", "):
    """
    Generate a string from a template for each vector component
    eg genstring(3, "@ + ") -> x + y + z
    @C -> varname(1, c, 1, col)
    @R -> varname(r, 1, row, 1)
    @ -> varname(r, c, row, col)
    @c -> c
    @r -> r

    """
    s = ""
    for r in range(row):
        for c in range(col):
            s += template.replace("@r", str(r)).replace("@c", str(c)).replace("@R", varname(r, c, row, 1)).replace("@C", varname(r, c, 1, col)).replace("@", varname(r, c, row, col)) + sep

    s.removesuffix(sep)
    return s[0:len(s)-len(sep)]


def transformString(s: str, depth: int):
    """Add tabs after all but the last line break and before the first char"""
    return depth * tab + s.replace("\n", "\n" + depth * tab, s.count("\n") - 1)


def getPossiblities(i, a, depth=0):
    """
    get all possibilites to get i by addition of numbers lower than i
    eg i=3 -> 3, 2+1, 1+2, 1+1+1
    """
    if i == 0:
        return
    if i == 1:
        a.append(str(1))
        return
    for j in range(1, i):
        b = []
        # print("\t" * depth + "gp: i="+str(i)+" j="+str(j))
        getPossiblities(i-j, b, depth+1)

        for poss in b:
            # print("\t"*depth + f"{i}-{j} returned", b)
            a.append(str(j) + poss)
    a.append(str(i))



#
# GENERATORS
#
def genConstructors(row, col):
    constructors = []
    class_ = classname(row, col)

    # default
    constructors.append(Member(class_, class_, c_temp=Class_T, prefixes=[constexpr], init=genstring(row, col, "@(0)"), comment="Default constructor"))

    # from single scalar
    constructors.append(Member(class_, class_, c_temp=Class_T, prefixes=[constexpr], m_temp=[["Number", "N"]], args="const N n", init=genstring(row, col, "@(static_cast<T>(n))"), comment="Create from scalar, all components will have value n"))

    # generate a constructor for every possible vector initialization
    if row == 1 or col == 1:
        rows_or_cols = max(row, col)  # vec and rvec share same variable names
        size = max(row, col)
        a = []
        getPossiblities(size, a)
        for possiblity in a:
            n_count = 1  # counts how many numbers appear 
            v_count = 1  # counts how many vectors appear
            i = 0  # index the member variable to initialize
            comment = "Create from "
            templates = []
            args = ""
            init = ""

            for nstr in possiblity:
                n = int(nstr)
                if n == 1:  # if number
                    comment += "n "
                    templates.append(("Number", f"N{n_count}"))
                    args += f"N{n_count} n{n_count}, "
                    init += varnameI(i, row, col) + f"(static_cast<T>(n{n_count})), "
                    n_count += 1
                    i += 1
                else:  # if vector
                    comment += f"vec{n} "
                    args += f"const V{v_count}& v{v_count}, "
                    templates.append((f"Vector{rows_or_cols}", f"V{v_count}"))
                    for j in range(n):
                        init += varnameI(i, rows_or_cols, 1) + "(static_cast<T>(v" + str(v_count) + "." + varnameI(j, rows_or_cols, 1) + ")), "
                        i += 1
                    v_count += 1
            args = args.removesuffix(", ")
            init = init.removesuffix(", ")
            constructors.append(Member(class_, class_, c_temp=Class_T, m_temp=templates, prefixes=[constexpr], args=args, init=init, comment=comment))
    # constructor for all matrices
    else:
        # from scalar
        constructors.append(Member(class_, class_, c_temp=Class_T, m_temp=[ t.split(" ") for t in genstring(row, col, f"Number N@r_@c").split(", ")], prefixes=[constexpr],
                                   args=genstring(row, col, "const N@r_@c @"), init=genstring(row, col, "@(static_cast<T>(@))"), comment="Create from scalars"))

        # from row vec
        constructors.append(Member(class_, class_, c_temp=Class_T, m_temp=[ t.split(" ") for t in genstring(row, 1, f"RowVector{col} V@r").split(", ")], prefixes=[constexpr],
                                   args=genstring(row, 1, "const V@r& v@r"), init=genstring(row, col, "@(static_cast<T>(v@r.@C))"), comment="Create from row vectors"))

        # from col vec
        constructors.append(Member(class_, class_, c_temp=Class_T, m_temp=[ t. split(" ") for t in genstring(1, col, f"ColumnVector{row} V@c").split(", ")], prefixes=[constexpr],
                                   args=genstring(1, col, "const V@c& v@c"), init=genstring(row, col, "@(static_cast<T>(v@c.@R))"), comment="Create from column vectors"))

    return constructors


def genValues(row, col):
    s = genstring(row, col, "T @;\n", "")
    return s

def genAssignment(row, col):
    # TODO opt idea: memcpy for component wise assignment when types have same size
    members = []
    members.append(Member(classname(row, col), "operator=", c_temp=Class_T, m_temp=[Number_N], prefixes=[constexpr], ret_type="void",
                          args=f"const {classname(row, col, 'N')}& other", body=genstring(row, col, f"\t@ = static_cast<T>(other.@);\n", "").split("\n"), comment="Component-wise assignment"))

    members.append(Member(classname(row, col), "operator=", c_temp=Class_T, m_temp=[Number_N], prefixes=[constexpr], ret_type="void",
                          args="const N& other", body=genstring(row, col, f"\t@ = static_cast<T>(other);\n", "").split("\n"), comment="Assignment from scalar"))

    return members



ops = {
    "+": "operator+",
    "-": "operator-",
    "%": "operator%",
    "*": "compWiseMult",
    "/": "compWiseDiv",
}
as_ops = {
    "+=": "operator+=",
    "-=": "operator-=",
    "%=": "operator%=",
    "*=": "compWiseAssMult",
    "/=": "compWiseAssDiv",
}
def genArithmeticVectorial(row, col):
    operators = []
    for op, opname in ops.items():
        body = "return " + classname(row, col, "T") + "(" + genstring(row, col, f"@ {op} static_cast<T>(other.@)") + ");"
        operators.append(Member(classname(row, col), opname, c_temp=Class_T, m_temp=[(concept(row, col), concept(row, col)[0])], prefixes=[constexpr], ret_type=classname(row, col, "T"),
                                args=f"const {concept(row, col)[0]}& other", const=True, body=[body], comment=f"Component-wise {op}"))

    for op, opname in as_ops.items():
        body = genstring(row, col, f"\t@ {op} static_cast<T>(other.@);", "\n")
        operators.append(Member(classname(row, col), opname, c_temp=Class_T, m_temp=[(concept(row, col), concept(row, col)[0])], prefixes=[constexpr], ret_type="void",
                                args=f"const {concept(row, col)[0]}& other", body=body.split("\n"), comment=f"Component-wise assignment {op}"))
    return operators

def genArithmeticScalar(row, col):
    operators = []
    for op, opname in ops.items():
        body = "return " + classname(row, col, "T") + "(" + genstring(row, col, f"@ {op} static_cast<T>(other)") + ");"
        operators.append(Member(classname(row, col), opname, c_temp=Class_T, m_temp=[Number_N], prefixes=[constexpr], ret_type=classname(row, col, "T"),
                                args=f"const N& other", const=True, body=[body], comment=f"Component-wise {op} with scalar"))
    for op, opname in as_ops.items():
        body = genstring(row, col, f"\t@ {op} static_cast<T>(other);", "\n")
        operators.append(Member(classname(row, col), opname, c_temp=Class_T, m_temp=[Number_N], prefixes=[constexpr], ret_type="void",
                                args=f"const N& other", body=body.split("\n"), comment=f"Component-wise assignment {op} from scalar"))
    return operators


def genComparisonVectorial(row, col):
    operators = []
    for op in ["==", "<", ">"]:
        body = "return " + genstring(row, col, f"@ {op} other.@", " and ") + ";"
        operators.append(Member(classname(row, col), f"operator{op}", c_temp=Class_T, m_temp=[(concept(row, col), concept(row, col)[0])], prefixes=[constexpr], ret_type="bool",
                                args=f"const {concept(row, col)[0]}& other", const=True, body=[body], comment=f"Component-wise comparison {op} (and)"))
    for op, antiop in { "!=": "==", "<=": ">", ">=": "<" }.items():
        body = "return " + genstring(row, col, f"@ {antiop} other.@", " and ") + ";"
        operators.append(Member(classname(row, col), f"operator{op}", c_temp=Class_T, m_temp=[(concept(row, col), concept(row, col)[0])], prefixes=[constexpr], ret_type="bool",
                                args=f"const {concept(row, col)[0]}& other", const=True, body=[body], comment=f"Component-wise comparison {op} (and)"))
    return operators

def genComparisonScalar(row, col):
    operators = []
    for op in ["==", "<", ">"]:
        body = "return " + genstring(row, col, f"@ {op} other", " and ") + ";"
        operators.append(Member(classname(row, col), f"operator{op}", c_temp=Class_T, m_temp=[Number_N], prefixes=[constexpr], ret_type="bool",
                                args=f"const N& other", const=True, body=[body], comment=f"Component-wise comparison {op} (and)"))
    for op, antiop in { "!=": "==", "<=": ">", ">=": "<" }.items():
        body = "return " + genstring(row, col, f"@ {antiop} other", " and ") + ";"
        operators.append(Member(classname(row, col), f"operator{op}", c_temp=Class_T, m_temp=[Number_N], prefixes=[constexpr], ret_type="bool",
                                args=f"const N& other", const=True, body=[body], comment=f"Component-wise comparison {op} (and)"))
    return operators



def getDependecyClasses(row, col):
    """
    Get all class names that row,col class depends on for matrix multplication and the .row() and .column() methods
    The dependencies will be forward declared in the header and included in the source
    """
    deps = []
    # for .row(), .column()
    if row > 1 and col > 1:
        deps.append(classname(row, 1))
        deps.append(classname(1, col))

    # for matrix mult
    for i in range(1, MAX_N + 1):
        # results from matrix calculations
        deps.append(classname(row, i))

        # operands from matrix calculations
        deps.append(classname(col, i))

    deps = list(dict.fromkeys(deps))
    # remove vec1
    if classname(1, 1) in deps:
        deps.remove(classname(1, 1))
    if classname(row, col) in deps:
        deps.remove(classname(row, col))
    deps.sort()
    return deps


def genArithmeticMatrix(row, col):
    """
    Generate all matrix multiplications.
    dimensions of result = mat(row, other.col) where col = other.row
    """
    operators = []
    other_row = col
    other_cols = [ i for i in range(1, MAX_N + 1) ]
    for other_col in other_cols:
        if (row == 1 and other_col == 1) or (other_row == 1 and other_col == 1):  # if ret_type or arg is a scalar
            continue
        body = classname(row, other_col, "T") + " new_;\n"
        for r in range(row):
            for o_c in range(other_col):
                body += "new_." + varname(r, o_c, row, other_col) + " = "
                for i in range(col):
                    # print(f"genArithmeticMatrix: {row}x{col} * {other_row}x{other_col}", r, o_c, "->", c)
                    body += varname(r, i, row, col) + " * other." + varname(i, o_c, other_row, other_col) + " + "
                body = body.removesuffix(" + ") + ";\n"
        # if scalar, put ret_type creation and assignment in same line
        body = body.replace("new_;\nnew_." + varname(0, 0, 1, 1) + " =", "new_ =") + "return new_;"
        arg_concept = concept(other_row, other_col)
        operators.append(Member(classname(row, col), "operator*", c_temp=Class_T, m_temp=[(arg_concept, arg_concept[0])], prefixes=[constexpr], ret_type=classname(row, other_col, "T"), const=True,
                                args=f"const {arg_concept[0]}& other", body=body.split("\n"), comment=f"Matrix multiplication with {classname(other_row, other_col)} -> {classname(row, other_col)}"))

    return operators


def genSubscription(row, col):
    operators = []
    # [i]
    operators.append(Member(classname(row, col), "operator[]", c_temp=Class_T, prefixes=[constexpr], ret_type="T",
                            args="std::size_t i", const=True, body=[f"return *(&{varname(0, 0, row, col)} + sizeof(T) * i);"], comment="Get the ith element. i starts at 0"))

    if row > 1 and col > 1:
        # at(row, col)
        body = f"return *(&{varname(0, 0, row, col)} + (row * {row} + col * {col}) * sizeof(T));"
        operators.append(Member(classname(row, col), "at", c_temp=Class_T, prefixes=[constexpr], ret_type="T",
                                args="std::size_t row, std::size_t col", const=True, body=[body], comment="Get the element at row and col. row and col start at 0"))

        # row()
        body = f"return {classname(1, col, 'T')}(" + genstring(1, col, f"*(&{varname(0, 0, row, col)} + ({row} * @c + i) * sizeof(T))") + ");"
        operators.append(Member(classname(row, col), "row", c_temp=Class_T, prefixes=[constexpr], ret_type=classname(1, col, 'T'),
                                args="std::size_t i", const=True, body=[body], comment="Get the ith row as column vector. i starts at 0"))

        # column()
        body = f"return {classname(row, 1, 'T')}(" + genstring(row, 1, f"*(&{varname(0, 0, row, col)} + ({col} * @r + i) * sizeof(T))") + ");"
        operators.append(Member(classname(row, col), "column", c_temp=Class_T, prefixes=[constexpr], ret_type=classname(row, 1, 'T'),
                                args="std::size_t i", const=True, body=[body], comment="Get the ith column as row vector. i starts at 0"))

    return operators


def genIterator(row, col):
    members = []
    its = [
        ("cbegin", "return Iterator(const_cast<T*>(&" + varname(0, 0, row, col) + "));", "Return an Iterator to the first element"),
        ("cend", "return Iterator(const_cast<T*>(&" + varname(row-1, col-1, row, col) + " + sizeof(T)));", "Return an Iterator past the last element"),
        ("begin", "return Iterator(const_cast<T*>(&" + varname(0, 0, row, col) + "));", "Return an Iterator to the first element"),
        ("end", "return Iterator(const_cast<T*>(&" + varname(row-1, col-1, row, col) + " + sizeof(T)));", "Return an Iterator past the last element"),
    ]
    for name, body, comment in its:
        members.append(Member(classname(row, col), name, c_temp=Class_T, prefixes=[constexpr], ret_type="Iterator<T>", const=True, body=[body], comment=comment))
    return members


def genFunctional(row, col):
    members = []
    # abs
    members.append(Member(classname(row, col), "abs", c_temp=Class_T, prefixes=[constexpr, inline], ret_type=float_type,
                          const=True, body=["return std::sqrt(" + genstring(row, col, f"static_cast<{float_type}>(@ * @)", " + ") + ");"], comment="Returns the absolute value of the vector (sqrt of scalar product with itself)"))

    if (row == 2 and col == 1) or (col == 2 and row == 1):
        # ratio
        members.append(Member(classname(row, col), "ratio", c_temp=Class_T, prefixes=[constexpr, inline], ret_type=float_type,
                              const=True, body=["return static_cast<" + float_type + f">({varnameI(0, row, col)}) / {varnameI(1, row, col)};"], comment=f"Returns x/y"))

        # inverse ratio
        members.append(Member(classname(row, col), "invereseRatio", c_temp=Class_T, prefixes=[constexpr, inline], ret_type=float_type,
                              const=True, body=["return static_cast<" + float_type + f">({varnameI(1, row, col)}) / {varnameI(0, row, col)};"], comment=f"Returns y/x"))


    # min
    members.append(Member(classname(row, col), "min", c_temp=Class_T, prefixes=[constexpr, inline], ret_type="T", const=True,
                          body=["return *std::min_element(cbegin(), cend());"], comment="Returns the min of the components"))

    # max
    members.append(Member(classname(row, col), "max", c_temp=Class_T, prefixes=[constexpr, inline], ret_type="T", const=True,
                          body=["return *std::max_element(cbegin(), cend());"], comment="Returns the max of the components"))

    # dot
    body = f"return " + genstring(row, col, "@ * static_cast<T>(other.@)", " + ") + ";"
    members.append(Member(classname(row, col), "dot", c_temp=Class_T, m_temp=[Number_N], prefixes=[constexpr, inline], ret_type="T", const=True,
                          args=f"const {classname(row, col, 'N')}& other", body=[body], comment="Scalar product (x1 * other.x1 +  x2 * other.x2 ...)"))
    return members


def genUtility(row, col):
    s = "\n"
    # s = "std::string to_string() const { return \"(\" + " + genstring(row, col, "std::to_string(@)", " + \", \" + ") + " + \")\"; };\n"
    return s


def genUsing(row, col):
    global typeShorts
    s = ""
    for t, c in typeShorts.items():
        s += f"using {classname(row, col)}{c} = {classname(row, col)}<{t}>;\n"
    return s



#
# TEMPLATE INSTANTIATION
#
def getTemplateInsts(method_name, instantiations, templates, types, depth=0):
    """ method name must be like this:
    constexpr ret_type Class<T>::name<U>(int, U) const;"""
    if depth < len(templates):
        if templates[depth][0] == "Number":
            for n in types:
                newmethod = method_name.replace(
                    f"<{templates[depth][1]}>", f"<{n}>").replace(
                    f"{templates[depth][1]} ", f"{n} ").replace(
                    f"{templates[depth][1]})", f"{n})").replace(
                    f"{templates[depth][1]},", f"{n},").replace(
                    f"{templates[depth][1]}& ", f"{n}& ").replace(
                    f"{templates[depth][1]}&)", f"{n}&)").replace(
                    f"{templates[depth][1]}&,", f"{n}&,")
                getTemplateInsts(newmethod, instantiations, templates, types, depth+1)
        else:
            for n in types:
                newmethod = method_name.replace(
                    f"<{templates[depth][1]}>", f"<{classnameFromConcept(templates[depth][0])}<{n}>>").replace(
                    f"{templates[depth][1]} ", f"{classnameFromConcept(templates[depth][0])}<{n}> ").replace(
                    f"{templates[depth][1]})", f"{classnameFromConcept(templates[depth][0])}<{n}> ").replace(
                    f"{templates[depth][1]},", f"{classnameFromConcept(templates[depth][0])}<{n}> ").replace(
                    f"{templates[depth][1]}& ", f"{classnameFromConcept(templates[depth][0])}<{n}>& ").replace(
                    f"{templates[depth][1]}&)", f"{classnameFromConcept(templates[depth][0])}<{n}>&)").replace(
                    f"{templates[depth][1]}&,", f"{classnameFromConcept(templates[depth][0])}<{n}>&,")
                getTemplateInsts(newmethod, instantiations, templates, types, depth+1)
    elif depth == len(templates) and len(templates)> 0:
        instantiations.append("template " + method_name + ";")


#
# GENERATION
#
def generateFiles(row, col):
    hd = 0  # header depth
    sd = 0  # source and template depth

    # header
    h = "#pragma once\n\n"
    # source
    s = "#include \"" + classname(row, col) + ".hpp\"\n\n"
    # template instantiations
    t = f"// template instantiations for {classname(row, col)}\n\n"

    dependencies = getDependecyClasses(row, col)
    for dep in dependencies:
        s += "#include \"" + dep + ".hpp\"\n"
    s += "\n"
    for i in headerIncludes:
        h += "#include " + i + "\n"
    h += "\n"
    for i in sourceIncludes:
        s += "#include " + i + "\n"
    s += "\n"
    if namespace:
        h += "namespace " + namespace + " {\n\n"
        s += "namespace " + namespace + " {\n\n"
        t += "namespace " + namespace + " {\n\n"
        hd += 1
        sd += 1

    # template instantiations
    if include_template_instantiations:
        for typ in templateInstantiationTypes:
            t += transformString("template class " + classname(row, col, typ) + ";\n", 0)
            t += "\n"

    # forward declarations
    h += transformString("// Forward declarations\n", hd)
    for dep in dependencies:
        h += transformString("template<Number T>\nclass " + dep + ";\n", hd)
    h += "\n"

    header, source, templates = generateMatrix(row, col, hd, sd)
    h += header + "\n"
    s += source + "\n"
    t += templates + "\n"

    if include_static_asserts:
        h += transformString("static_assert(" + concept(row, col, classname(row, col, "int")) +", \"" + classname(row, col, "int") + " does not satisfy the concept " + concept(row, col) + "\");\n", hd)

    if namespace:
        hd -= 1
        sd -= 1
        h += transformString("} // namespace " + namespace + "\n", hd)
        s += transformString("} // namespace " + namespace + "\n", hd)
        t += transformString("} // namespace " + namespace + "\n", hd)

    for i in range(1, 5):
        h = h.replace("\n" + i * tab + "\n", "\n\n")
        s = s.replace("\n" + i * tab + "\n", "\n\n")

    return h, s, t


def append(header:str, source:str, templates:str, members:list[Member], hdepth:int, sdepth:int):
    for m in members:
        split = True
        if m.isConstructor() or (len(m.body) < 2 and len(m.m_temp) > 1):
            split = False

        if split:
            header += m.defintionH(hdepth)
            source += m.source(sdepth)
            templates += m.templateInstantiations()
        else:
            header += m.header(hdepth)
    return header, source, templates




def generateMatrix(r, c, hd, sd):
    h = transformString(
"""/**
 * @brief Class containing $ numbers
 */
 """.replace("$", str(r*c)), hd)
    h += transformString("""template<Number T>
class $ {
    public:
""".replace("$", classname(r, c)), hd)

    s = transformString("""//
// CLASS $
//
""".replace("$", classname(r, c)), sd)


    t = ""

    hd += 1  # header depth
    # sd += 1  # source depth

    if classname(r, c).startswith("vec"):
        h += transformString("/// just to satisfy concept ColumnVector\nusing isColumnVector = T;\n", hd + 1)
    elif classname(r, c).startswith("rvec"):
        h += transformString("/// just to satisfy concept RowVector\nusing isRowVector = T;\n", hd + 1)

    h += transformString("// Constructors\n", hd)
    h, s, t = append(h, s, t, genConstructors(r, c), hd+1, sd)

    h += transformString("// Values\n", hd)
    h += transformString(genValues(r, c), hd+1)

    h += transformString("// Assignment\n", hd)
    h, s, t = append(h, s, t, genAssignment(r, c), hd+1, sd)

    h += transformString("// Arithmetic\n", hd-1)
    h += transformString("// Vectorial\n", hd)
    h, s, t = append(h, s, t, genArithmeticVectorial(r, c), hd+1, sd)
    h += transformString("// Scalar\n", hd)
    h, s, t = append(h, s, t, genArithmeticScalar(r, c),hd+1, sd)
    h += transformString("// Matrix Multiplication\n", hd)
    h, s, t = append(h, s, t, genArithmeticMatrix(r, c), hd+1, sd)

    h += transformString("// Comparison\n", hd-1)
    h += transformString("// Vectorial\n", hd)
    h, s, t = append(h, s, t, genComparisonVectorial(r, c),hd+1, sd)
    h += transformString("// Scalar\n", hd)
    h, s, t = append(h, s, t, genComparisonScalar(r, c), hd+1, sd)


    h += transformString("// Functional\n", hd - 1)
    h, s, t = append(h, s, t, genFunctional(r, c), hd+1, sd)

    h += transformString("// Utility\n", hd-1)
    h, s, t = append(h, s, t, genSubscription(r, c), hd+1, sd)
    h, s, t = append(h, s, t, genIterator(r, c), hd + 1, sd)

    h += transformString("}; // " + classname(r, c) + "\n\n", hd - 1)
    h += transformString(genUsing(r, c), hd - 1)
    h += "\n"
    s += "\n"
    t += "\n"

    return h, s, t


#
# CONCEPTS
#
def generateConceptsFile(row, col):
    # Number
    s = "#pragma once\n\n"
    s += "#include <concepts>\n\n"
    s += "// Number\n"
    s += "template<typename T>\n"
    s += "concept Number = std::integral<T> or std::floating_point<T>;\n\n"

    s += "// VectorX\n"
    for i in range(2, max(row, col)):
        s += "template<typename T>\n"
        # s += "concept Vector" + str(i) + " = requires(T t) { " + genstring(i, 1, "{ t.@ } -> Number; ", "") + "};\n\n"
        s += "concept Vector" + str(i) + " = requires(T t) {\n" + genstring(i, 1, tab + "requires Number<decltype(t.@)>;\n", "") + "} and requires(T t) { sizeof(t." + varname(0, 0, i, 1) + ") == (sizeof(T) * " + str(i) + "); };\n\n"
    s += "// RowVectorX\n"
    for i in range(2, max(row, col)):
        s += "template<typename T>\n"
        s += "concept RowVector" + str(i) + " = Vector" + str(i) + "<T> and Number<typename T::isRowVector>;\n\n"
    s += "// ColumnVectorX\n"
    for i in range(2, max(row, col)):
        s += "template<typename T>\n"
        s += "concept ColumnVector" + str(i) + " = Vector" + str(i) + "<T> and Number<typename T::isColumnVector>;\n\n"
    s += "// Matrices\n"
    for r in range(2, row):
        for c in range(2, col):
            s += "template<typename T>\n"
            # s += "concept " + concept(r, c) + " = requires(T t) { t -> template " + classname(r, c) + "; };\n"
            s += "concept " + concept(r, c) + " = requires(T t) {\n" + genstring(r, c, tab + "requires Number<decltype(t.@)>;\n", "") + "};\n" # and requires(T t) { sizeof(t." + varname(0, 0, r, c) + ") == (sizeof(T) * " + str(r*c) + "); };\n\n"
    return s


##
## ITERATORS
##
#def generateIteratorFile():
#    i = "#pragma once\n"
#    if namespace:
#        i += f"namespace {namespace} " + "{\n"

#    i += """

#template<typename T>
#struct Iterator {
#    public:
#        using value_type = T;
#        Iterator() : ptr(nullptr) {};
#        Iterator(T* ptr) : ptr(ptr) {};
#        T& operator*() const { return *ptr; };
#        Iterator& operator=(const Iterator& other) {
#            ptr = other.ptr;
#            return *this;
#        };
#        Iterator& operator++() { ptr += sizeof(T); return *this; };
#        Iterator operator++(int) { auto copy = *this; ptr += sizeof(T); return copy; };
#        friend int operator-(Iterator lhs, Iterator rhs) {
#            return lhs.ptr - rhs.ptr;
#        };
#        bool operator==(const Iterator& other) const { return ptr == other.ptr; };
#        // bool operator!=(const Iterator& other) const { return ptr != other.ptr; };
#    private:
#        T* ptr;
#}; // Iterator
#"""

#    if include_static_asserts:
#        i += 'static_assert(std::forward_iterator<Iterator<int>>, "Iterator not a forward range.");'
#    if namespace:
#        i += "} // namespace " + namespace + "\n"
#    return i



#
# MAIN
#
def write_file(s, filename):
    if path.exists(filename):
        answer = "y"
        # answer = input("File " + filename + "already exists. Overwrite? (y/n): ")
        if answer not in "yY":
            return

    with open(filename, "w") as file:
        file.write(s)


if __name__ == "__main__":
    if not path.isdir(directory):
        mkdir(directory)
    todo = [ [i, j] for i in range(1, MAX_N + 1) for j in range(1, MAX_N + 1)]
    todo.remove([1, 1])  # remove [1, 1]
    for r, c in todo:
        filename = directory + "/" + classname(r, c)
        header, source, templates = generateFiles(r, c)
        if include_template_instantiations:
            write_file(templates, filename + ".tpp")
            source += "\n#include \"" + classname(r, c) + ".tpp\""
        write_file(header, filename + ".hpp")
        write_file(source, filename + ".cpp")

    write_file(generateConceptsFile(MAX_N + 1, MAX_N + 1), directory + "/" + "concepts.hpp")
    # write_file(generateIteratorFile(), directory + "/" + "iterator.hpp")