import os
import shutil #copy files from current dir to m2cpp_temp
#import re
import matlab2cpp.mwhos
from matlab2cpp.datatype import get_mem

from itertools import takewhile

def lstripped(s):
    return ''.join(takewhile(str.isspace, s))

#def rstripped(s):
#    return ''.join(reversed(tuple(takewhile(str.isspace, reversed(s)))))

#def stripped(s):
#    return lstripped(s), rstripped(s)

def mtypes(builder, args):

    #Current working directory
    src_dir = os.getcwd() + os.path.sep

    dst_dir = src_dir + "m2cpp_data_type_temp" + os.path.sep

    # Delete the temporary folder which the datatype info
    if os.path.isdir(dst_dir):
        shutil.rmtree(dst_dir)
    #if directory m2cpp_data_type_temp does not exist, create it
    if not os.path.isdir(dst_dir):
        os.mkdir(dst_dir)

    #copy file in directory to m2cpp_temp
    #If there are data files in directory, then they have to be copied, or abspath to datafiles in program
    src_file_dir = os.path.dirname(os.path.abspath(args.filename)) + os.path.sep
    src_files = os.listdir(os.path.dirname(os.path.abspath(args.filename)) + os.path.sep)

    for file_name in src_files:
        file_src = src_file_dir + file_name
        if os.path.isfile(file_src):
            if file_src[-2:] != ".m":
                shutil.copy(file_src, dst_dir)

    #write whos_f.m to folder. Similar to matlab whos function,
    #but writes to file
    f = open(dst_dir + "whos_f.m", "w")
    f.write(matlab2cpp.mwhos.code)
    f.close()

    ##Create new matlab file in m2cpp_temp
    #Loop for each script and function .m file
    #print("- Program loop start\n\n")
    for program in builder.project:
        #get program code from matlab file
        f = open(program.name, "r")
        code = f.read()
        f.close()

        #Get name of file after splitting path, set file path "m2cpp_temp/file"
        file_path = dst_dir + program.name.split(os.path.sep)[-1]
        #print(file_path)

        #Program is main script file, add whos_f at end of file
        #program[1][0].cls is Main if script file
        if program[1][0].cls == "Main":
            #Modify the code, main file
            file_name = (program.name.split(os.path.sep)[-1])[:-2]
            code += "\nwhos_f"
        else:
            #Modify the code, funtion file
            code = function_code(program, code)

        #insert whos_f before return statements
        func_name = "whos_f"

        lines = code.splitlines()
        code_temp = []
        for line in lines:
            #lstrip line and compare with "return"
            if line.lstrip()[:6] == "return":
                #Insert left stripped whitespace + func_name
                code_temp.append(lstripped(line) + func_name)
            #Add the "original" code line
            code_temp.append(line)

        #Convert string list to string
        code = "\n".join(code_temp)
        
        #write file to m2cpp_temp/
        #print("writing file: " + file_path)

        f = open(file_path, "w")
        f.write(code)
        f.close()
    try:
        import matlab.engine

        #Set path to -p "setpath.m" before changing current working directory
        if args.paths_file:
            matlab_cmd = "run(\'"+ os.path.abspath(args.paths_file).rstrip(".m") + "\')"

        cwdir = os.getcwd()
        os.chdir(dst_dir)
        engine = matlab.engine.start_matlab()

        if args.paths_file:
            engine.evalc(matlab_cmd, nargout=0)
        engine.evalc(file_name, nargout=0)

        os.chdir(cwdir)
    except:
        print("matlab did not load correctly, check that you have matlab engine API for python installed")

    ##Process .m.txt files to extract data types
    #I could have this under the previous loop,
    #but then the loop becomes so long
    program_number = 0

    for program in builder.project:
        #reset funcs_types dictionary for each iteration
        funcs_types = {}
        file_path = dst_dir + program.name.split(os.path.sep)[-1] + ".txt"
        #print(file_path)
        funcs_types = extract_ftypes(program, funcs_types, file_path)
    
        ##Copy data types to program.ftypes
        funcs = program.ftypes

        for func_key in funcs_types.keys():
            for var_key in funcs_types[func_key].keys():
                funcs[func_key][var_key] = funcs_types[func_key][var_key]
        
        #set ftypes for the current program
        builder[program_number].ftypes = funcs
        program_number += 1

    return builder
        


def extract_ftypes(program, funcs_types, file_path):
    
    #Check if file exists, if not return
    if not os.path.isfile(file_path):
        return funcs_types

    #Read file
    f = open(file_path, "r")
    lines = f.read().splitlines() #change to read, and then splitlines
    f.close()

    #while line
    j = 0
    while j < len(lines):
        line = lines[j]

        #print(str(j) + ":" + line)
        #When function is found, loop over variables and
        cols = line.split(":")
        #add them to dict funcs_types
        if cols[0] == "#function_name":
            #print(line)
            #funcs_name = cols[1].split(",")[0]

            f_names = cols[1].split(",")

            #funcs_name = f_names[0].lstrip() if not len(f_names) == 2 else f_names[1].lstrip()
            funcs_name = f_names[0].lstrip() if program[1][0].cls != "Main" else f_names[1].lstrip()
            
            #skip next line
            j += 2

            #make double indexed dictionary
            if not funcs_types.get(funcs_name):
                funcs_types[funcs_name] = {}
            while j < len(lines) and lines[j] != "":
                cols = lines[j].split(", ")

                #cols contain: name, size, class, complex, integer
                #extract variables to be more readable
                var_name = cols[0]
                
                #print(lines[j])
                #extract the type in string format
                data_type = datatype_string(cols)

                #print(var_name + ": " + data_type)

                #insert in dictionary
                #check if entry in dictionary exist
                data_type_old = funcs_types[funcs_name].get(var_name)

                #complex type should stay complex type
                if data_type_old:
                    #get if datatype is comples, then mem_value should be 4
                    #mem_value_old = get_mem(data_type_old)
                    mem_value_new = get_mem(data_type)
                    #print("mem_value_new: ")
                    #print(mem_value_new)
                    if mem_value_new == 4:
                        funcs_types[funcs_name][var_name] = data_type
                else:
                    funcs_types[funcs_name][var_name] = data_type

                j += 1
                
        j += 1
    
    return funcs_types

def datatype_string(cols):
    #Convert data from cols to a string, representing the datatype
    M, N = [int(s) for s in cols[1].split("x")]
    var_type = cols[2]
    complex_number = int(cols[3])
    integer = int(cols[4])

    data_type = ""
    if var_type == "double":
        #non complex
        if not complex_number:
            #scalar
            if M == 1 and N == 1:
                if integer:
                    data_type = "int"
                else:
                    data_type = "double"
                    
            #vec
            if M > 1 and N == 1:
                #data_type = "mat"
                data_type = "vec"
                    
            #rowvec
            if M == 1 and N > 1:
                #data_type = "mat"
                data_type = "rowvec"
                    
            #matrix
            if (M > 1 and N > 1) or M == 0 or N == 0: #if empty matrix, set to mat
                data_type = "mat"
                    
        #complex value
        elif complex_number:
            #scalar
            if M == 1 and N == 1:
                data_type = "cx_double"

            #vec
            if M > 1 and N == 1:
                #data_type = "cx_mat"
                data_type = "cx_vec"
                
            #rowvec
            if M == 1 and N > 1:
                #data_type = "cx_mat"
                data_type = "cx_rowvec"
                
            #matrix
            if M > 1 and N > 1 or M == 0 or N == 0: #if empty matrix, set to mat:
                data_type = "cx_mat"
                
    return data_type
    
def detect_string(code, k):

    import string

    if code[k] != "'":
        syntaxerror(k, "start of string character (')")

    if code[k-1] == ".":
        return False

    j = k-1
    while code[j] in " \t":
        j -= 1

    if code[j] in string.letters+string.digits+")]}_":

        # special cases
        if code[j-3:j+1] == "case":
            return True

        return False

    return True


def function_code(program, code):
    #print(program.summary())

    #count number of if, while, for, switch and number of end

    #Flatten nodes, count number of nodes of type if, while for
    #num_if = 0 #num_while = 0 #num_for = 0 #num_switch = 0
    import re
    iwfs_ends = 0
    
    nodes = program.flatten(False, True, False)

    for node in nodes: 
        if node.cls in ["If", "While", "For", "Switch"]:
            iwfs_ends += 1

    #print("iwfs_ends: " + str(iwfs_ends))
    
    #Get number of 'end' on separate lines
    

    iquote = [i for i in range(len(code)) if code[i] == '\'']
    istring = [i for i in iquote if detect_string(code, i)]
    string_ends = []
    
    #for i in istring:
    #    k = next(j for j in range(i + 1,len(code)) if code[j] == '\'' and (j + 1 == len(code) or code[j + 1] != '\''))
    #    string_ends.append(k)
    #    #code = code[:i + 1] + code[k:]

    #if len(istring) > 0:
    #    ncode = code[:istring[0] + 1]
    #    for i in range(len(istring) - 1):
    #        ncode += code[string_ends[i]:istring[i + 1] + 1]

    #    #if (string_ends[-1] + 1 < len(code)):
    #    ncode += code[string_ends[-1]:]
    #    code = ncode
    
    #lines = code.splitlines()
    #for i in range(0,len(lines)):
    #    #lines[i] = re.sub(r'\'(.+)\'',"''", lines[i])
    #    #lines[i] = re.sub(r'\"(.+)\"',"''", lines[i])
    #    lines[i] = lines[i].split('%')[0]
    #code = '\n'.join(lines)
    
    #esplit = code.replace(';', '\n').replace(',','\n').split()
    ##elines = esplit.splitlines()
    #num_end = 0
    #for t in esplit:
    #    if t == "end":
    #        num_end += 1
    #for line in elines:
    #    if line.strip() == "end":
    #        num_end += 1
        #print(line)

    
   
    

    #print("num_end: " + str(num_end))


    #insert whos_f before return and before function ..... (here)end (next fun)
    #Comparing num_end with num_if, num_while, num_for and switch case find if
    #functions are ending with "end" keyword or not.

    #flag set to true if functions end with end keyword
    #function_end = num_end > iwfs_ends

    #get number of functions in .m function file
    num_funcs = len(program[1])

    #insert whos_f before end of function or before new function
    func_name = "whos_f\n"

    ids = []

    for func in program[1]:
        block = func[3]
        block_end = block.cur + len(block.code)
        
        if block.is_end_terminated:
            fs = code.rfind("end", block.cur, block_end)
            ids.append(fs)
        else:
            ids.append(block_end)

    ids.sort()

    ncode = code[:ids[0]]

    for i in range(len(ids) - 1):
        ncode = ncode + func_name + code[ids[i]:ids[i+1]]
    ncode = ncode + func_name + code[ids[-1]:]
    code = ncode
    #functions end with end keyword
    #index = len(code)
    
    #index = len(lines)
    ##print(code)
    #if function_end:
    #    #should stop when num_funcs becomes zero
    #    while num_funcs:
    #        #search for keyword end
    #        #index = code.rfind("end", 0, index)
    #        index = next(i for i in range(index - 1,-1,-1) if lines[i].strip() == 'end')

    #        #add function name to code
    #        lines = lines[:index] + [func_name] + lines[index:]
    #        #index += len(func_name)

    #        #Search for previous function
    #        if num_funcs != 1:
    #            #index = code.rfind("\nfunction", 0, index)
    #            index = next(i for i in range(index - 1,-1,-1) if len(lines[i].split()) > 0 and lines[i].split()[0] == 'function')
    #        num_funcs -= 1
    #else:
    #    #function does not end with end keyword
    #    while num_funcs:
    #        #code = code[:index] + func_name + code[index:]
    #        lines = lines[:index] + [func_name] + lines[index:]

    #        if num_funcs != 1:
    #            #index = code.rfind("\nfunction", 0, index)
    #            index = next(i for i in range(index - 1,-1,-1) if len(lines[i].split()) > 0 and lines[i].split()[0] == 'function')
    #        num_funcs -= 1
        

    #print(code)
    #code = '\n'.join(lines)
    return code