# TODO:
# required: check obsolete methods
# -- generate mappings from buttons or .rewasd file - rethink whole idea
# fix: config generating and saving (adjust to new Button class)


import json,os
from Classes.KeysAssignment.KeyButtonClass import *

root_dir = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
dik_codes_file_path = os.path.join(root_dir,"corefiles","DIK","dik_codes_nodoubles.json")

# https://community.bistudio.com/wiki/DIK_KeyCodes
# https://gist.github.com/tracend/912308
class DIKClass:
    def __init__(self):

        self.dik_codes_file_path = dik_codes_file_path

        self.parse_dik_codes()


    def parse_dik_codes(self):
        f = open(self.dik_codes_file_path)
        self.dik_dict = json.load(f)
        f.close()

        self.dik_dict_reversed = {} # id : LETTER
        for dik_key,dik_value in self.dik_dict.items():
            self.dik_dict_reversed[dik_value] = dik_key



class RewasdFileClass:

    def __init__(self,file_path, device_obj):

        self.dik_obj = DIKClass()

        self.file_path = file_path

        self.rewasd_file_dict = {}

        self.device_obj = device_obj # to get metadata info from it set by placement application ()


    # def is_key_assigned(self,assigned_key):                     # these functions are to keep _keysassignments_dict_reversed protected
    #     return (assigned_key in self._keys_assignments_dict_reversed)
    def get_file_path(self):
        return self.file_path


    def set_file_path(self,file_path: str):
        self.file_path = file_path


    def is_file_path_set(self):
        return len(self.file_path) > 0


    def get_dev_key_assignment_value(self,dev_key_name):
        return self._keys_assignments_dict[dev_key_name]["assignment"]


    def set_dev_key_assignment_value(self,dev_key_name,new_value):
        self._keys_assignments_dict[dev_key_name]["assignment"] = new_value


    def get_dev_key_assignment_description(self,dev_key_name):
        return self._keys_assignments_dict[dev_key_name]["description"]


    def set_dev_key_assignment_description(self,dev_key_name,new_value):
        self._keys_assignments_dict[dev_key_name]["description"] = new_value


    def get_assignments_dict(self):
        return self._keys_assignments_dict


    def get_assigned_key_assignments_list(self,assigned_key):
        return self._keys_assignments_dict_reversed[assigned_key]


    def parse_masks(self,masks_dict): # to create order_ids_dict and orders_ids_reversed
        self.order_ids_dict = {}
        self.order_ids_dict_reversed = {}

        for i in masks_dict:
            self.device_id =  i['set'][0]['deviceId']
            self.order_ids_dict[ i['set'][0]['buttonId']] = i['id'] # dev_key_dik_id = order_id
            self.order_ids_dict_reversed[i['id']] = i['set'][0]['buttonId'] # order_id = dev_key_dik_id


    def parse_config(self):

        f = open(self.file_path)
        self.rewasd_file_dict = json.load(f)
        f.close()

        self.parse_masks(self.rewasd_file_dict['masks'])

        self._keys_assignments_dict = {} #

        self._keys_assignments_dict_reversed = {} # ASSIGNED_KEY : { "dev_key_1", "dev_key_2"} < 1 letter may be assigned on few base keys

        for i in self.rewasd_file_dict['mappings']:
            if 'description' in i.keys():
                order_id = i["condition"]['mask']["id"]
                dev_key_dik_id = self.order_ids_dict_reversed[order_id]
                dev_key_name = self.dik_obj.dik_dict_reversed[dev_key_dik_id]

                assigned_key_dik_id = i["macros"][0]['keyboard']["buttonId"]
                assigned_key_name = self.dik_obj.dik_dict_reversed[assigned_key_dik_id]

                # >>>>>>>>>>>>>>>_keys_assignments_dict <<<<<<<<<<<<<<<<<<<
                self._keys_assignments_dict[dev_key_name] = { # LETTER
                    "assignment" : assigned_key_name, # LETTER
                    "description": i["description"]
                }

                # reverse assignment

                if assigned_key_name in self._keys_assignments_dict_reversed:
                    if dev_key_name not in self._keys_assignments_dict_reversed[assigned_key_name]:
                        self._keys_assignments_dict_reversed[assigned_key_name].append(dev_key_name)
                else:
                    self._keys_assignments_dict_reversed[assigned_key_name] = [dev_key_name]

        # print(self._keys_assignments_dict_reversed)


################### json methods
    def _generate_jsonfile(self):

        self.rewasd_file_dict["schemaVersion"] = self.device_obj.schemaVersion
        self.rewasd_file_dict["appVersion"] = self.device_obj.appVersion
        self.rewasd_file_dict["config"] = {
                                            "appName": os.path.basename(self.file_path),
                                            "minTimeUnit": 1
                                        }
        self.rewasd_file_dict["devices"] = self.device_obj.devices
        self.rewasd_file_dict["masks"] = self.device_obj.masks
        self._generate_jsonfile_mappings() # create self.mapping_list
        self.rewasd_file_dict['mappings'] = self._mappings_list


    def _generate_jsonfile_mappings(self):
        self.parse_masks(self.device_obj.masks)
        self._mappings_list = []

        for order_id,dev_key_dik_id in self.order_ids_dict_reversed.items():

            dev_key_dik_id = self.order_ids_dict_reversed[order_id]
            dev_key_name = self.dik_obj.dik_dict_reversed[dev_key_dik_id]

            #assigned_key_name = self._keys_assignments_dict[dev_key_name]['assignment'] # connection point!
            assigned_key_name = self.buttons_dict[dev_key_name].get_assigned_key()
            assigned_key_dik_id = self.dik_obj.dik_dict[assigned_key_name]

            row_dict = {
                'condition': {
                    'hardware': {
                        'deviceId': 11,
                        'buttonId': dev_key_dik_id,
                        'description': 'DIK_' + dev_key_name
                        }
                },
                'hardware': {'unmap': True}
            }

            self._mappings_list.append(row_dict)

            row_dict = {
                "description": self.buttons_dict[dev_key_name].get_assigned_key_description(),
                "condition": {
                    "mask": {
                    "id": order_id,
                    "activator": {
                        "type": "single",
                        "mode": "hold_until_release"
                        }
                    }
                },
                "macros": [
                    {
                    "keyboard": {
                        "buttonId": assigned_key_dik_id,
                        "description": "DIK_" + self.dik_obj.dik_dict_reversed[assigned_key_dik_id]
                        }
                    }
                ]
            }

            self._mappings_list.append(row_dict)

            #print(row_dict)
        #print(json.dumps(self.mappings_list))


    def save_config(self,buttons_dict):
        self.buttons_dict = buttons_dict

        self._generate_jsonfile()

        #size = os.path.getsize(self.file_path)

        print(self.file_path)
        stat = os.stat(self.file_path)
        size = stat.st_size
        print(size)
        file_exists = os.path.getsize(self.file_path) > 0 # must be before opening file

        f = open(self.file_path, "a+") # open original file

        if file_exists: # if file exists and is not empty
            self.rewasd_file_bckp_dict = json.load(f)
            f_bckp = open(self.file_path + ".bak", "w") # create backup file
            f_bckp.write(json.dumps(self.rewasd_file_bckp_dict, indent=4)) # write original content to backup file
            f_bckp.close()

        f.write(json.dumps(self.rewasd_file_dict, indent=4)) # write new content to backup file
        f.close()