import datetime
from functools import reduce
import json
from operator import getitem
import sys
import os
import itertools

# /home/pakin/Codes/coffCfg/cofffeemachineConfig/coffeethai02_1550.json


def GetDateTimeString():
    now = datetime.datetime.now() # current date and time
    date_time = now.strftime("%d-%b-%Y, %H:%M:%S")
    return date_time

HomeDirectory = "/home/pakin"
CoffeeRecipeDirectory = "/home/pakin/Codes/coffCfg/cofffeemachineConfig"
valid_len_product_code = len("12-01-02-0001")

# events - save any action done by merge
events = []
events_json = []
# last_change - current value of "LastChange"
last_change = ""
# last_change_path - key mapping to "LastChange" key, joined by '.' and could be splitted to access value in nested map
last_change_path = ""
# master_json - main dictionary(map) for another json to merge into.
master_json = {}
# config_ver - target main dictionary's "configNumber"
global config_ver
config_ver = -1
# holdonPD = the current product code that has been holding
holdonPD = ""

# output config
global isJson
isJson = False


# Keys to be removed
removed_keylist = [
    "RemainingCups",
    "RemainingCupsWithTopping"
]


# Set value of nested map (target - master_json) by using keys from 'key_list' and assigned value to it.
def set_value_in_nested_map(key_list: list, value):
    reduce(getitem, key_list[:-1], master_json)[key_list[-1]] = value

def get_value_in_nested_map(target_json: dict, key_list: list, isMaster=False):
    if "Recipe01" in key_list:
        if isMaster:
            key_list[1] += shared_master_position

    if "SubMenu" in key_list:
        if len(reduce(getitem, key_list[:3], target_json)) <= 0:
            return "-"
    
    # Handle no key case
    result = None
    try:
        result = reduce(getitem, key_list[:-1], target_json)[key_list[-1]]
    except:
        print(key_list, "->",result)
        pass
    return result

# Decode key that was in form of String to the list
def decode_path(str_with_dot: str) -> list:
    path_map = str_with_dot.split('.')
    keylist = []
    for keyi in path_map:
        if keyi.isdigit():
            keyi = int(keyi)
        elif keyi[1:].isdigit():
            pass
        keylist.append(keyi)
    return keylist

def fetch_pd(str_path: str, target_dict: dict) -> str:
    keyList = decode_path(str_with_dot=str_path)
    keyList.append("productCode" if "Recipe01" in str_path else "id")
    # print("decode and append get : ",keyList)
    return get_value_in_nested_map(target_json=target_dict, key_list=keyList)

def fetch_matId(str_path: str, target_dict:dict) -> str:
    keyList = decode_path(str_with_dot=str_path)
    keyList.append("materialPathId")
    # print(keyList)
    return get_value_in_nested_map(target_json=target_dict, key_list=keyList)

def fetch_defaultId(str_path: str, target_dict:dict) -> str:
    keyList = decode_path(str_with_dot=str_path)
    keyList.append("defaultIDSelect")
    # print(keyList)
    return get_value_in_nested_map(target_json=target_dict, key_list=keyList)

def fetch_onlyMainMenuPath(str_with_dot: str):
    mainpath = decode_path(str_with_dot)[:2]
    # '.'.join(mainpath)
    return ".".join(str(p) for p in mainpath)

def create_map(events_action: str, log: str, additional=[]) -> str:
    return {
        "timestamp": GetDateTimeString(),
        "event": events_action,
        "log": log,
        "addition": additional
    }


def flatten(x, parent='', sep='.') -> dict:
    flattened = {}
    for key, value in x.items():
        current_key = f"{parent}{sep}{key}" if parent else key
        if isinstance(value, dict):
            flattened.update(flatten(value, current_key, sep))
        elif isinstance(value, list):
            for index, item in enumerate(value):
                list_key = f"{current_key}{sep}{index}"

                if isinstance(item, dict):
                    flattened.update(flatten(item, list_key, sep))
                else: 
                    flattened.update({list_key: item})
        else:
            flattened[current_key] = value
    return flattened

def unflatten(dictionary):
    result_dict = {}
    for key, value in dictionary.items():
        parts = key.split('.')
        d = result_dict
        for part in parts[:-1]:
            if part.isdigit():
                part = int(part)
                if isinstance(d, list):
                    while len(d) <= part:
                        d.append({})
                    d = d[part]
                else:
                    if part not in d:
                        d[part] = []
                    d = d[part]
            else:
                if part not in d:
                    d[part] = {}
                d = d[part]
        if parts[-1].isdigit():
            parts[-1] = int(parts[-1])
            while len(d) <= parts[-1]:
                d.append(None)
            d[parts[-1]] = value
        else:
            d[parts[-1]] = value
    return result_dict


def diff(dict1, dict2):
    exist_in_dict1 = set(dict1.keys()) - set(dict2.keys())
    exist_in_dict2 = set(dict2.keys()) - set(dict1.keys())

    keydiff = {
        key for key in set(dict1.keys()) & set(dict2.keys()) if dict1[key] != dict2[key]
    }
    keydiff = sorted(keydiff)

    # diff
    diff1 = {key: dict1[key] for key in exist_in_dict1}
    diff2 = {key: dict2[key] for key in exist_in_dict2}

    diffval = {key: (dict1[key], dict2[key]) for key in keydiff}

    return diff1, diff2, diffval

def get_key(d, target) -> str:
    for key, value in d.items():
        if value == target:
            return key
    return None

def remove_key(d, key):
    if isinstance(d, dict):
        for key1 in list(d.keys()):
            if key1 == key:
                del d[key1]
            else:
                remove_key(d[key1], key)
    elif isinstance(d, list):
        for index, item in enumerate(d):
            if isinstance(item, dict):
                if key in list(item.keys()):
                    del item[key]
                
                if "SubMenu" in list(item.keys()):

                    for j, itemSub in enumerate(item["SubMenu"]):
                        if key in list(itemSub.keys()):
                            del itemSub[key]

def string_to_date(str_date: str):
    time_obj = datetime.datetime.strptime(str_date, "%d-%b-%Y, %H:%M:%S").time() if "," in str_date else datetime.datetime.strptime(str_date, "%d-%b-%Y %H:%M:%S").time()
    return time_obj

def CompareDate(master_lastchange, dev_lastchange) -> str:
    if master_lastchange > dev_lastchange:
        return "DevLegacy"
    elif master_lastchange == dev_lastchange:
        return "NoChange"
    elif master_lastchange < dev_lastchange:
        return "DevRelease"

def GetMasterDevCompare(key_list: list, dev_date: any) -> bool:
    master_date = string_to_date(get_value_in_nested_map(master_json, decode_path(key_list), True))

    comp = CompareDate(master_date, string_to_date(dev_date))

    if comp == "DevLegacy" or comp == "NoChange":
        return False
    elif comp == "DevRelease":
        return True

# ------------------------------------ HMTL --------------------------------------

def blinking_text():
    return """
        <style>
            .blink {
                animation: blink-animation .25s linear infinite alternate;
                -webkit-animation: blink-animation .25s linear infinite alternate;
            }
            @keyframes blink-animation {
                0% {
                    opacity: 100%
                }
                25% {
                    opacity: 75%
                }
                50% {
                    opacity: 50%
                }
                75% {
                    opacity: 25%
                }
                100% {
                    opacity: 0%
                }
            }
            @-webkit-keyframes blink-animation {
                0% {
                    opacity: 100%
                }
                25% {
                    opacity: 75%
                }
                50% {
                    opacity: 50%
                }
                75% {
                    opacity: 25%
                }
                100% {
                    opacity: 0%
                }
            }
        </style>
    """

def p(content:str, isAction: bool) -> str:
    pclass = ""
    style = "style=\"float: left; margin: 15; padding: 10px; "

    # style
    if isAction:

        if "CHANGE" in content:

            style += """
                background: greenyellow; 
            """
        elif "INSERT" in content:
            style += """
                background: orange; 
            """
    else:
        if "VER" in content:
            style += """
                background: aliceblue;
            """
        elif "COUNT" in content or "OUTPUT" in content or "LOG" in content:
            style += """
                background: aquamarine;
            """
        elif "master" in content or "dev" in content:
            style += """
                box-shadow: 2px 2px;
            """
            if "master" in content:
                style += "background: lightgray; margin-right: -20px;"
            else:
                style += "background: lightblue;"
        elif "New key" in content or "New value" in content:
            style += """
                border-radius: 25px;
            """
            pclass = "class=\"blink\" "
            if "New key" in content:
                style += "background: lightgreen;"
            else:
                style += "background: gold;"

    
    style += "\">"

    return "\t\t<p "+pclass+style+content+"</p>\n"


def searchFnForHtml():
    return """
        <script>
            function searchLog(){
                var input, filter, logBody, logRow, logP, logContent;
                input = document.getElementById("searchInput");
                filter = input.value;
                logBody = document.getElementById("logBody");
                logRow = logBody.getElementsByTagName("div");


                for(let i = 0; i < logRow.length; i++){
                    p = logRow[i].getElementsByTagName("p");
                    console.log("Total P = ", logRow[i].getElementsByTagName("p").length);

                    for(let p_i = 0; p_i < p.length; p_i++){
                        pcontent = p[p_i].textContent || p[p_i].innerText;

                        if(pcontent.includes(filter)){
                            logRow[i].style.display = "";
                            break;
                        } else {
                            logRow[i].style.display = "none";
                        }
                    }
                }
            }
        </script>
    """

def searchInputForHTML():
    return """
        <input type="text" id="searchInput" onkeyup="searchLog()" placeholder="Search logs ... " style="top: 0; position: fixed; width: 100%; font-size: 16px; padding: 20px; margin: 10px; border: 1px solid">
    """

def mergeV3pre(flat_dict_base:dict, flat_dict_dev:dict) -> dict:
    """
    `version 3 preview`
    
    Merge 2 dictionary files together. Given that the dict must be flattened.

    `Warning` This will overwrite the exist key with new value.
    """
    merged = flat_dict_base.copy()
    merged.update(flat_dict_dev)
    return merged


# Merge diff value or append it to the main file.
# 0 - master_path = master.json / to be merged
# 1 - dev_path = dev.json / to merge into another
# 2 - outfile = output
# 3 - changefile = track log
# 4 - debug = enable debug
def merge(args):
    """
    `version 2`

    Merge the 2 json files together with input of target paths, output path and changefile
    
    :param args: A list of arguments. list[]
    :type args: list
        where each element position;
            0 - master_path = master.json / to be merged

            1 - dev_path = dev.json / to merge into another

            2 - outfile = merged json output 

            3 - changefile = track log (json) --- generate by merge to html,log,json

            4 - debug = enable debug
            
            5 - requester = requester's name sent by client

    :return: None
    :rtype: None
    """
    print("ARGS: => ",args)
    
    master_path = args[0]; dev_path = args[1]; outfile_path = args[2]; changefile_path = args[3]; 

    file_path, out_ext = os.path.splitext(changefile_path)

    if "json" in out_ext:
        global isJson
        isJson = True


    if len(args) > 4:
        global debug
        debug = args[4] if args[4] != None else False

    if len(args) > 5:
        global requester
        requester = args[5] if args[5] != None else ""

    # 
    if (os.path.exists(master_path) == False) and str(master_path).isdigit():
        if "/coffeethai02" not in master_path:
            master_path = CoffeeRecipeDirectory + "/coffeethai02_" + str(master_path) + ".json"

    
    master_file = open(master_path, 'rb')

    if (os.path.exists(dev_path) == False) and str(dev_path).isdigit():
        if "/coffeethai02" not in dev_path:
            dev_path = CoffeeRecipeDirectory + "/coffeethai02_" + str(dev_path) + ".json"
    
    dev_file = open(dev_path, 'rb')
    
    masterName = master_file.name; devName = dev_file.name
    
    master_file = master_file.raw.readall()
    dev_file = dev_file.raw.readall()
    print("Master file size => ",os.stat(master_path).st_size)
    print("Dev file size => ",os.stat(dev_path).st_size)
    # 

    # Requester
    events_json.append(create_map(
        events_action="REQUESTER", 
        log="GetRequestFrom", 
        additional=[{
            "timestamp": GetDateTimeString(),
            "requester": requester
            }]))
    events.append(GetDateTimeString()+"\t[REQUEST]\t\tget request from \""+requester+"\"\n")

    events_json.append(create_map(events_action="MERGE", log=devName.split("/")[-1]+" into "+masterName.split("/")[-1]))
    events.append(GetDateTimeString()+"\t[MERGE]\t\tMerging "+devName.split("/")[-1]+" into "+masterName.split("/")[-1]+"\n")
    # print(GetDateTimeString()+"\tMerging "+dev_file.name.split("/")[-1]+" into "+master_file.name.split("/")[-1]+"\n")
    print(events[len(events) - 1])

    # print("Test maintain => ", MaintianUnicodeEscapeDecoder.decoder(s=master_file))
    
    global master_json
    global dev_json
    master_json_file:dict = json.loads(master_file)
    master_json = master_json_file.copy()
    dev_json_file:dict = json.loads(dev_file)
    dev_json = dev_json_file.copy()

    config_ver = master_json["MachineSetting"]["configNumber"]
    print(config_ver)

    global pdchange
    pdchange = 0
    global pdadd
    pdadd = 0
    # global holdonPD
    holdonPD = ""

    # Step 1: Flatten the dictionary
    flattened_master = flatten(master_json)
    flattened_dev = flatten(dev_json)

    # Step 2: Check key size of flattens
    try:
        if debug == "debug":
            print("master keys = ", len(flattened_master.keys()), ", dev keys = ", len(flattened_dev.keys()))
    except:
        pass

    # Step 3: Diff
    diff1, diff2, diffvals = diff(flattened_master, flattened_dev)
    # print("Exist in master = ", len(diff1))
    # print("Exist in dev = ", len(diff2))
    # print("Unmatched values = ", len(diffvals))

    # m_pre = mergeV3pre(flat_dict_base=flattened_master, flat_dict_dev=flattened_dev)
    # final_m = unflatten(m_pre)
    
    # with open("./output/mergev3.json", "w+", encoding="utf-8") as testfile:
    #     json.dump(final_m, testfile, indent=2, ensure_ascii=False)

    # Clean unused key
    for i, remove_item in enumerate(removed_keylist):
        remove_key(master_json, remove_item)
    
    merge_dicts(master_json, dev_json_file)

    try:
        if debug == "debug":
            print("/".join(changefile_path.split("/")[:-1]))
    except:
        pass
    if (os.path.exists("/".join(outfile_path.split("/")[:-1])) == False):
        os.makedirs("/".join(outfile_path.split("/")[:-1]))

    if (os.path.exists("/".join(changefile_path.split("/")[:-1])) == False):
        os.makedirs("/".join(changefile_path.split("/")[:-1]))

    with open(outfile_path, "w", encoding="utf-8") as outfile:
        json.dump(master_json, outfile, indent=2, ensure_ascii=False)
    

    # Create new filename by outfile_path
    outfile_path, outfile_ext = os.path.splitext(outfile_path)
    # ignore ext, get the last 
    outfile_path_spl = str(outfile_path).split("/")
    path_version = outfile_path_spl[len(outfile_path_spl) - 1]

    pv = path_version.split("_")[1]


    # Include counts

    events_json.append(create_map(events_action="COUNT", log="Total="+str(pdchange)))
    events_json.append(create_map(events_action="COUNT", log="Total="+str(pdadd)))
    events_json.append(create_map(events_action="OUTPUT", log="Finished! write output to "+outfile_path))
    events_json.append(create_map(events_action="LOG", log="Log is saved to "+file_path+"_"+pv+".json"))
    events.append(GetDateTimeString()+"\t[COUNT]\t\tTotal Change: "+str(pdchange)+"\n")
    events.append(GetDateTimeString()+"\t[COUNT]\t\tTotal Insert: "+str(pdadd)+"\n")

    events.append(GetDateTimeString()+"\t[OUTPUT]\t\tFinished! write output to "+outfile_path+"\n")
    events.append(GetDateTimeString()+"\t[LOG]\t\tLog is saved to "+file_path+"_"+pv+".json"+"\n")
    
    # log json file

    if not os.path.exists(file_path+"_"+pv+".json") or os.stat(file_path+"_"+pv+".json").st_size == 0:
        with open(file_path+"_"+pv+".json", "w",encoding="utf-8") as outlogfile:
                json.dump({"logs"+GetDateTimeString()+"*": events_json}, outlogfile, indent=2, ensure_ascii=False)
    else:
        print(file_path+"_"+pv+".json")
        logjs:dict = json.loads(open(file_path+"_"+pv+".json", encoding="utf-8").read())
        logjs["logs"+GetDateTimeString()+"*"] = events_json
        json.dump(logjs, open(file_path+"_"+pv+".json", "w+", encoding="utf-8"), indent=2, ensure_ascii=False)
    
    # log file
    with open(file_path+"_"+pv+".log", "a+") as outlogfile2:
        try:
                
            for event in events:
                outlogfile2.write(event)
        except:
            raise Exception(event)

    # Create html version

    # add version of master to before extension

    html_string = ""
    if os.path.exists(file_path+"_"+pv+".html"):
        html_string = ""
    else:
        html_string = blinking_text()+searchFnForHtml()+"\n"+searchInputForHTML()+"\n"

    with open(file_path+"_"+pv+".html", "a+") as outlogHtml:
        html_string += "<div id=\"logBody\" style=\"display: flex; flex-direction: column; margin-top: 100\">\n"
        for event in events:
            # Create div
            html_string += "\t<div id=\"logRow\" style=\"display: inline-block; "
            if "REQUEST" in event:
                html_string += "background: burlywoord\">\n"
            elif "INSERT" in event:
                html_string += "background: darkkhaki\">\n"
            elif "CHANGE" in event:
                html_string += "background: beige\">\n"
            else:
                html_string += "background: antiquewhite\">\n"
            event_fraction = str(event).split("\t")
            for i in event_fraction:
                if i != "" and i != "\n" and i != "---":
                    if "|" in i and not i.endswith("|"):
                        # CHANGE
                        spl_text = i.split("|")
                        html_string += p(spl_text[0], False)
                        html_string += p(spl_text[1].replace("\n",""), False)
                    elif ">>>" in i:
                        # INSERT
                        spl_text = i.split(">>>")
                        html_string += p(spl_text[0], False)
                        html_string += p(spl_text[1].replace("\n",""), False)
                    elif i.endswith("|"):

                        # Last change
                        html_string += p(i[:-1], False)
                    else:
                        # print("Default = ", i)
                        # Either version, status or others

                        if "CHANGE" in i or "INSERT" in i:
                            html_string += p(i.replace("\n",""), True)
                        else:
                            html_string += p(i.replace("\n",""), False)


            html_string += "\t</div>\n"
        html_string += "</div>\n"
        outlogHtml.write(html_string)




# Merge dictionary - called by `merge`, using when the value is `dict` type
# original - main file to merge/append value into
# updated - source of new value (must be in the same structure)
# path - default = "". This variable is used for saving keys as path for accessing nested map
def merge_dicts(original:dict, updated:dict, path=""):
    for key, value in updated.items():
        current_path = f"{path}.{key}" if path else key
        
        if key in original:
            # 
            if key == "Timestamp":
                global pre_timestamp
                pre_timestamp = value
                # change timestamp
                # original["Timestamp"] = GetDateTimeString()
                cfgnum = ""
                # events.append(GetDateTimeString()+"\t[TIMESTMP]\tLast Generated: "+value+cfgnum+"\tNew Generated at "+original["Timestamp"]+" \n")
                # print(events[len(events) - 1])
            else:
                if key == "LastChange":
                    global last_change
                    global last_change_path
                    last_change = value
                    last_change_path = current_path
                    # print("[LastChange] LastChange: ",last_change_path, " value = ",value)
                
                if isinstance(value, dict) and isinstance(original[key], dict):
                    merge_dicts(original[key], value, current_path)
                elif isinstance(value, list) and isinstance(original[key], list):
                    merge_lists(original[key], value, current_path)
                else:
                    # Detect diff and "LastChange must diff"
                    if original[key] != value:
                        if key == "configNumber":
                            # use master version
                            global config_ver
                            config_ver = master_json["MachineSetting"]["configNumber"]
                            # original[key] = config_ver
                            cfgnum = "\t[VER."+str(config_ver)+"]" if config_ver != -1 else "\t[...]"
                            try:
                                if debug == "debug":
                                    print("Config number ", config_ver)
                            except:
                                pass
                            
                            events_json.append(
                                create_map(events_action="MERGE_TARGETS", log="Found `configNumber` => master version "+str(config_ver)+", merged with "+str(value)))
                            
                            events.append(GetDateTimeString()+cfgnum+"\tFound `configNumber` => master version "+str(config_ver)+", merged with "+str(value)+" \n")
                        elif last_change_path != "" and GetMasterDevCompare(last_change_path, last_change):
                            lc = last_change if last_change != "" else pre_timestamp
                            try:
                                if debug == "debug":
                                    print("Encounter path --> "+current_path, " | master: ",original[key]," dev: ", value)
                            except:
                                pass
                            if "Recipe01" in current_path and not "recipes" in current_path:
                                global holdonPD
                                global pdchange
                                if "productCode" in original and holdonPD != original["productCode"]:
                                    holdonPD = original["productCode"]
                                    pdchange += 1
                                    events_json.append(create_map(
                                                events_action="CHANGE",
                                                log="",
                                                additional=[
                                                    {
                                                        "version": config_ver,
                                                        "master_last_change": (get_value_in_nested_map(master_json, decode_path(last_change_path), isMaster=True)),
                                                        "dev_last_change": last_change,
                                                        "pd": holdonPD,
                                                        "name": original["name"] if "name" in original else "",
                                                        "fullpath": current_path
                                                    }
                                                ]
                                            ))

                                    events.append(GetDateTimeString()+"\t[VER."+str(config_ver)+"]\t[CHANGE]\t"+" LastChange: "+(get_value_in_nested_map(master_json, decode_path(last_change_path), isMaster=True))+" (master) |\t"+last_change+" (dev)\t"+"---\t \""+holdonPD+"\"\n")
                            # elif "Recipe01" not in current_path:
                            #     # reset holded pd
                            #     holdonPD = None
                            # override original value by value from updated(dev)
                            # if GetMasterDevCompare(last_change_path, last_change):
                            original[key] = value
                        elif "Recipe01" not in current_path and "Topping" not in current_path and "configNumber" not in current_path:
                            holdonPD = None
                            # Increase change tracking number
                            pdchange += 1
                            # Enable this for more logs

                            try:
                                if debug == "all":


                                    events.append(
                                        GetDateTimeString()+
                                        "\t[VER."+(str(config_ver) if config_ver != -1 else "Detecting...")+
                                        "]\t[CHANGE]\t"+"\""+current_path+"\"\n")
                                    
                                    events_json.append(create_map(
                                        events_action="CHANGE",
                                        log="",
                                        additional=[
                                            {
                                                "version": config_ver,
                                                "fullpath": current_path,
                                            }
                                        ]
                                    ))
                            except:
                                pass

                            try:
                                if debug == "debug":
                                    print(events[len(events) - 1])
                            except:
                                pass
                            original[key] = value
                            
        else:
            events_json.append(create_map(
                    events_action="INSERT+",
                    log="NewKeyValue",
                    additional=[{
                        "version": config_ver,
                        "pd": holdonPD if holdonPD != None else current_path,
                        "new_value": value,
                        "fullpath": current_path
                    }]
                ))
            events.append(GetDateTimeString()+"\t[VER."+str(config_ver)+"]\t\t\t[INSERT]\t"+"\tNew key & value >>> \""+(holdonPD if holdonPD != None else current_path)+"\" @ "+str(current_path)+("\t\t\t")+"\n")
            try:
                if debug == "debug":
                    print("Add path --> "+path, " | master: "," dev: ", str(value))
            except:
                pass
            global pdadd
            pdadd += 1

            original[key] = value

# Merge list - called by `merge_dict`, using when the value is `dict` type
# original - main file to merge/append value into
# updated - source of new value (must be in the same structure)
# path - default = "". This variable is used for saving keys as path for accessing nested map
# 
# Update v2:    Fix bug where index matched but replacing unrelated
# Update v2.1:  Fix unrelated & new log format
def merge_lists(original, updated, path=""):

    for i, item in enumerate(updated):
        current_path = f"{path}.{i}"
        if isinstance(item, dict):
            if i <= len(original)-1 and isinstance(original[i], dict):
                # events.append("Merge dictionary: "+current_path)
                if path == "Recipe01":
                    j = 0
                    if "productCode" not in original[i].keys():
                        key = "name"
                    else:
                        key = "productCode"
                    while original[j][key] != item["productCode"] and j < len(original) - 1:
                        j += 1
                    
                    # override index; share index to other functions
                    global shared_master_position
                    shared_master_position = j - i
                    
                    # print("Found target index: ", j," (master) ",i," (dev) " ," check matched? ", original[j][key] == item[key], " use key: ", key, " path: ", current_path )
                    merge_dicts(original[j], item, current_path)
                elif path == "MaterialSetting":
                    k = 0
                    key = "id"

                    while original[k][key] != item[key] and k < len(original) - 1:
                        k += 1

                    shared_master_position = k - i
                    merge_dicts(original[k], item, current_path)        
                else:
                    # found what
                    merge_dicts(original[i], item, current_path)
            elif item not in original:
                try:
                    if debug == "debug":
                        print("Append dict@ i=",i, " path: ", current_path)
                except:
                    pass
                events_json.append(create_map(
                        events_action="INSERT",
                        log="AppendDict",
                        additional=[{
                            "version": config_ver,
                            "pd": fetch_pd(current_path, dev_json) if "Topping" not in current_path else current_path,
                            "fullpath": current_path
                        }]
                    ))
                events.append(
                    GetDateTimeString()+
                    "\t[VER."+str(config_ver)+
                    "]\t\t\t[INSERT]\t"+
                    "\tNew value >>> "+
                    (fetch_pd(fetch_onlyMainMenuPath(current_path), dev_json) if "Topping" not in current_path else current_path)
                    +("@"+current_path if "Topping" not in current_path else "")+
                    (" -> "+fetch_pd(current_path, dev_json) if fetch_pd(current_path, dev_json) != None else "")+
                    ("\t\t\t")+"\n")
                global pdadd
                pdadd += 1
                original.append(item)
        elif item not in original:
            try:
                if debug == "debug":
                    print("Append list@ i=",i, " path: ", current_path)
            except:
                pass
            events_json.append(create_map(
                    events_action="INSERT",
                    log="AppendList",
                    additional=[{
                        "version": config_ver,
                        "pd": fetch_pd(fetch_onlyMainMenuPath(current_path), master_json),
                        "fullpath": current_path
                    }]
                ))
            events.append(GetDateTimeString()+"\t[VER."+str(config_ver)+"]\t\t\t[INSERT]\t"+"\tNew value >>> "+str(fetch_pd(fetch_onlyMainMenuPath(current_path), master_json))+", "+current_path+("\t\t\t")+"\n")
            pdadd += 1
            original.append(item)



# Diff recipe = interactive diff
# diff_recipe(master, "v1-v2-v3")
# {"key_diff": [master_value, dev_value]}
def diff_recipe(args, **kwargs):
    '    `version 1`'
    
    master_path = args[0]; versions_to_diff = args[1]
    vs = versions_to_diff.split("-")

    default_dir = "../server/cofffeemachineConfig/"
    default_name = "coffeethai02_"
    
    m_json = open(default_dir+default_name+master_path+".json", "r", encoding="utf-8").read()
    master_json_diff = json.loads(m_json)

    # flag settings
    is_flat = None
    is_nooutput = None

    for key, value in kwargs.items():
        if key == "flatten":
            is_flat = True if str(value).lower() == "true" else False
            if args[2] == "debug":
                print("Flatten: ", is_flat)
        elif key == "out":
            is_nooutput = True if str(value).lower() == "false" else False
            if args[2] == "debug":
                print("No output: ", is_nooutput)
    results = []


    if is_nooutput:
        print("Guide: {key: (master, dev)}")

    try:
        for v in vs:
            if is_nooutput:
                
                if is_flat:
                    print("\n----------------------",master_path+"-"+v,"----------------------\n",diff(flatten(master_json_diff), flatten(json.loads(open(default_dir+default_name+v+".json", "r", encoding="utf-8").read())),)[2], "\n")
                else:
                    print(diff("\n----------------------",master_path+"-"+v,"----------------------\n",master_json_diff, json.loads(open(default_dir+default_name+v+".json", "r", encoding="utf-8").read()),)[2])
                continue

            if is_flat:
                results.append({
                    "diff_between": master_path+"-"+v,
                    "result": diff(flatten(master_json_diff), flatten(json.loads(open(default_dir+default_name+v+".json", "r", encoding="utf-8").read())),)[2]
                })
            else:
                results.append({
                    "diff_between": master_path+"-"+v,
                    "result": diff(master_json_diff, json.loads(open(default_dir+default_name+v+".json", "r", encoding="utf-8").read()),)[2]
                })
    except:
        print("Error diffing file")

    for r in results:
        if len(args) > 2 and args[2] == "debug":
            print(r["diff_between"], " | diff len = ",len(r["result"]))
        
        # write to file
        with open(default_dir+"/diff/"+r["diff_between"]+".json", "w", encoding="utf-8") as f:
            json.dump(r["result"], f, indent=2, ensure_ascii=False)
    
    
    if is_nooutput:
        print("Guide: {key: (master, dev)}")

    print("OK")



def main():
    command_line = sys.argv[1]
    print(sys.argv)
    if command_line == "merge":
        merge(sys.argv[2:])

    elif command_line == "diff":
        diff_recipe(sys.argv[2:], **dict(arg.split("=") for arg in sys.argv[5:]))

if __name__ == "__main__":
    main()