import json5
#import pandas as pd
import sys
import argparse
from chameleon import PageTemplateFile,PageTemplate
import pkg_resources
import xml.etree.ElementTree as ET
import re
import os


version = 0.6

json5_dict: dict = {}
json5_html_list: list = []

print(f"Generate SM2 code from JSON5 - Version {version}")
# Get the version of Chameleon using pkg_resources
try:
    version = pkg_resources.get_distribution("Chameleon").version
    print("Using Chameleon version:", version)
except pkg_resources.DistributionNotFound:
    print("Chameleon is not installed or found.")

def parse_json(json_obj, prefix=''):
    structured_list = []
    if isinstance(json_obj, dict):
        for k, v in json_obj.items():
            new_key = f"{prefix}.{k}" if prefix else k
            structured_list.extend(parse_json(v, new_key))
    elif isinstance(json_obj, list):
        for i, v in enumerate(json_obj):
            new_key = f"{prefix}[{i}]"
            structured_list.extend(parse_json(v, new_key))
    else:
        structured_list.append(f"{prefix}: {json_obj}")
    return structured_list

def json5_to_list(filename):
    with open(filename, 'r') as file:
        data = json5.load(file)
    return parse_json(data)

def json5_to_pandas(filename):
    with open(filename, 'r') as file:
        data = json5.load(file)
    print (data)
    return data.json_normalize(data)

def json5_to_dict(filename):
    with open(filename, 'r') as file:
        data = json5.load(file)
    return data

def rec_print(data, prefix=''):
    # Check if this item is a dictionary.
    if isinstance(data, dict):
        for key, val in data.items():
            rec_print(val, f"{prefix}.{key}")
    # Check if this item is a list.
    elif isinstance(data, list):
        for idx, val in enumerate(data):
            rec_print(val, f"{prefix}[{idx}]")
    # If neither, it's a basic type.
    else:
        print(f"{prefix}: {data}")
        
def find_item(nested_dict, target_key):
    for key, val in nested_dict.items():
        if key == target_key:
            return val
        elif isinstance(val, dict):
            result = find_item(val, target_key)
            if result is not None:
                return result 
   
def find_dicts_with_key(data, target_key):
    results = []
    if isinstance(data, dict):
        if target_key in data:
            results.append(data)
        for val in data.values():
            if isinstance(val, (dict, list)):
                results.extend(find_dicts_with_key(val, target_key))
    elif isinstance(data, list):
        for item in data:
            if isinstance(item, (dict, list)):
                results.extend(find_dicts_with_key(item, target_key))
    return results
    
def find_values_with_key(data, target_key):
    results = []   
    if isinstance(data, dict):
        if target_key in data:
            results.append(data[target_key])
        for val in data.values():
            if isinstance(val, (dict, list)):
                results.extend(find_values_with_key(val, target_key))
    elif isinstance(data, list):
        for item in data:
            if isinstance(item, (dict, list)):
                results.extend(find_values_with_key(item, target_key))
    return results
    
def lint_json5(filename):
    try:
        with open(filename, 'r') as file:
            data = file.read()
        json5.loads(data)
        print(f"{filename} as JSON5 data is valid")
    except Exception as e:
        print(f"{filename} as JSON5 data is invalid")
        print("Error:", str(e))
        sys.exit()


def flatten_hash_of_lists(hash_of_lists):
    flattened = {}
    for key, value in hash_of_lists.items():
        if isinstance(value, list):
            for i, item in enumerate(value):
                new_key = f"{key}_{i}"  # Appending index to the key to maintain uniqueness
                flattened[new_key] = item
        else:
            flattened[key] = value
    return flattened
    
def hl(keyname):
	# Return highest level value for the keyname
	if keyname in json5_dict:
		return json5_dict[keyname]
	else:
		print(f"{keyname} not found in JSON5 - top level")
		return 'None'

def get_all_routes():
    route_list = [html_block.get('route') for html_block in json5_dict.get('html', [])]
    return route_list 

def lc_get_all_routes():
    # All routes in lower case
    route_list = [html_block.get('route').lower() for html_block in json5_dict.get('html', [])]
    return route_list 
    
def has_file_been_modified(file_path):
    # Get the file's creation time and last modification time in Unix timestamp
    creation_time = os.path.getctime(file_path)
    last_modification_time = os.path.getmtime(file_path)

    # Compare the creation time and last modification time
    if creation_time < last_modification_time:
        return True  # File has been modified after creation
    else:
        return False  # File has not been modified after creation


import xml.etree.ElementTree as ET

def parse_xml_to_dict(xml_file):
    # Parse the XML file
    tree = ET.parse(xml_file)
    root = tree.getroot()

    xml_dict = {}  # Initialize an empty dictionary to store the data

    # Iterate through the XML tree and extract data
    for elem in root:
        tag = elem.tag
        if elem.text:
            xml_dict[tag] = elem.text
        else:
            cdata_content = elem.find('.//').text  # Extract CDATA text
            xml_dict[tag] = cdata_content

    return xml_dict

def deduplicate_array(arr):
    # Convert the array to a set to remove duplicates
    unique_set = set(arr)
    
    # Convert the set back to a list to maintain the order
    deduplicated_list = list(unique_set)
    
    return deduplicated_list

def get_db_fields():
	return []
	
def get_table_control_data():
	return find_values_with_key(json5_html_list,'TableControl')

if __name__ == "__main__":
    filename = '/home/brianr/clients/SM2/SM2Gen/nfsshare.json5'
    
    # Command line parameters
    parser = argparse.ArgumentParser(description="SM2Gen")
    parser.add_argument('-f', '--filename', help='Specify a filename for the JSON5 file', default=filename)
    parser.add_argument('-nc', '--noController', help='Stop it creating a controller file', default="no")
    parser.add_argument('-nh', '--noHtml', help='Stop it creating html files(s)', default="no")
    parser.add_argument('-nl', '--noLang', help='Stop it creating language localise files(s)', default="no")
    args = parser.parse_args()
    filename = args.filename
    print(f"JSON5 from {filename} with noController={args.noController}, noHtml={args.noHtml} and noLang={args.noLang}") #Not yet activated
    #print("Chameleon version:", chameleon.__version__)

	# check syntax of JSON5
    lint_json5(filename);
    
    # Get dict of it all
    json5_dict = json5_to_dict(filename)
    #print(json5_dict)
    
    # Get dict of just the html bit
    json5_html_list = json5_dict['html']
    #print(json5_html_list)
    
    #Identify message
    print(f"\nGenerating mojo panels for {hl('PackageName')}")
    print( "-----------------------------------")
    
    # Routes for each panel
    routes = get_all_routes();
    lc_routes =lc_get_all_routes();
    
    #File names
    controller_file = 'Targets/'+hl('PackageName')+'.pm'
    custom_controller_file = 'Targets/'+hl('PackageName')+'-Custom.pm'
    # see if it has been modified by developer
    if has_file_been_modified(custom_controller_file):
        custom_controller_file = custom_controller_file+'.new'
    layout_file = 'Targets/'+hl('PackageName')+'.html.ep'
    partial_files = list()
    for panel in routes:
        partial_files.append('Targets/_'+hl('prefix')+"_"+panel+'.html.ep')
    print(partial_files)
    lex_file = 'Targets/'+hl('PackageName').lower()+'_en.lex'
    tablecontrols = get_table_control_data() #arrays of hashes used to drive rows in tables
    #print(tablecontrols)  
    #quit()
    
    #Generate controller file
    try:
        controller_template = PageTemplateFile("Templates/controller.pm.tem")
        dbentries = get_db_fields() #Params which correspond to Db fields
        try:
            controller_perl = controller_template.render(tablecontrols=tablecontrols, dbentries=dbentries,**json5_dict,panels=routes,lcPackageName=json5_dict['PackageName'].lower())
            #print()
            #print(controller_perl)
            # Map '$ 'to '$' to overcome problem with escaping $ signs
            #controller_perl = controller_perl.replace("$ ", "$")
            with open(controller_file, 'w') as file:
                file.write(controller_perl)
            print(f"{controller_file} controller generated ok")
        except Exception as e:
            print(f"An chameleon controller render error occurred: {e}")    
    except Exception as e:
        print(f"An chameleon controller template error occurred: {e}")
        
    #Generate Custom controller file
    try:
        custom_controller_template = PageTemplateFile("Templates/custom.pm.tem")
        try:
            custom_controller_perl = custom_controller_template.render(panels=routes,tablecontrols=tablecontrols)
            # We must be careful to not overwrite the custom file if the developer has already written to it - TBD
            with open(custom_controller_file, 'w') as file:
                file.write(custom_controller_perl)
            print(f"{custom_controller_file} custom controller generated ok")
        except Exception as e:
            print(f"An chameleon custom controller render error occurred: {e}")    
    except Exception as e:
        print(f"An chameleon custom controller template error occurred: {e}")

    #generate Layout file
    layout_template = PageTemplateFile("Templates/layout.html.ep.tem")
    try:
        try:
            layout_mojo = layout_template.render(**json5_dict,conditions=routes)
            # Map '$ 'to '$' to overcome problem with escaping $ signs
            #layout_mojo = layout_mojo.replace("$ ", "$")
            with open(layout_file, 'w') as file:
                file.write(layout_mojo)
            print(f"{layout_file} mojo template layout file generated ok")
        except Exception as e:
            print(f"An chameleon render on layout file error occurred: {e}")    
        #print()
        #print(layout_mojo_template)
    except Exception as e:
        print(f"An chameleon template layout file error occurred: {e}")    
    
    #Generate a partial file for each of the entries in the html list
    #Pull in the template code for each of the input types
    #html_controls = json5_to_dict('Templates/html_controls.html.ep.tem')
    html_controls = parse_xml_to_dict('Templates/html_controls.html.ep.xml')
    #print(html_controls)
    i = 0
    for html in json5_html_list:
        # Generate a mojo template file, and then add in the controls   
        # main file first
        try:
            partial_template = PageTemplateFile("Templates/partial.html.ep.tem")
            partial_mojo_context = {**json5_dict,**html}          
            try:
                partial_mojo_template = partial_template.render(**partial_mojo_context)
                # Map '$ 'to '$' to overcome problem with escaping $ signs
                #partial_mojo_template = partial_mojo_template.replace("$ ", "$")
                with open( partial_files[i], 'w') as file:
                    file.write(partial_mojo_template)
                print(f"{partial_files[i]} mojo template generated ok - phase 1")
            except Exception as e:
                print(f"An chameleon render error on partial file {html['route']} occurred: {e}")    
        except Exception as e:
            print(f"An chameleon html  {html['route']} error occurred: {e}")    

        #Now generate the controls from the rest of the entries in the dict.
        #print()
        #print(html['route']);
        all_controls_html = "";
        prefix_is = hl('prefix')
        for html_control in html:
            #print(html_control)
            inner_html = html[html_control]
            if isinstance(inner_html, dict):
                #print("\t\t"+inner_html['route']+":"+inner_html['Type'])
                try:
                    control_template = PageTemplate(html_controls[inner_html['Type']])
                    try:
                        control_html = control_template.render(**inner_html,prefix=prefix_is) #Contents=Contents,Headings=Headings)
                        # Map '$ 'to '$' to overcome problem with escaping $ signs
                        #control_html = control_html.replace("$ ", "$")
                        # Add in two tabs before each newline
                        #control_html = control_html.replace("\n", "\n\t\t")
                        # and an extra tab before each "%"
                        #control_html = control_html.replace("%", "\t%")                   
                        #print(control_html)
                        # And re-run it if the type is "table"
                        #if inner_html['Type'] == 'Table'
                            #Another scan
                        #    print("Another scan for the table")
                        #Else just move on.
                        all_controls_html = all_controls_html + control_html
                    except Exception as e:
                        print(f"An chameleon render on partial file control {inner_html['Name']} error occurred: {e}")                  				
                except Exception as e:
                    print(f"An chameleon render on partial file control {inner_html['Name']} error occurred: {e}")                  
            else:
                #just a simple entry - name less numerics is type
                html_Type =  ''.join(char for char in html_control if not char.isdigit())
                #print(html_Type);
                try:
                    simple_control_template  = PageTemplate(html_controls[html_Type])
                    try:
                        simple_control_html = simple_control_template.render(value=inner_html,prefix=prefix_is)
                        # Map '$ 'to '$' to overcome problem with escaping $ signs
                        #simple_control_html = simple_control_html.replace("$ ", "$")                        
                        # Add in two tabs before each newline
                        #simple_control_html = simple_control_html.replace("\n", "\n\t\t")
                        all_controls_html = all_controls_html + simple_control_html
                    except Exception as e:
                        print(f"An chameleon render on partial file control {html_control} error occurred: {e}")                  								
                except Exception as e:
                    print(f"An chameleon template partial file control {html_control} error occurred: {e}")
                    
        # Now insert it into the partial file in the correct place.
        # Read in the text file and split at "%# Inputs etc in here."
        with open(partial_files[i], 'r') as file:
            lines = file.readlines()
            index = next((i for i, line in enumerate(lines) if "%# Inputs etc in here." in line), len(lines))
            
        # Insert the string at the specified index
        lines.insert(index+1, all_controls_html + '\n')
        
        # Write the modified content back to the file
        with open(partial_files[i], 'w') as file:
            file.writelines(lines)
        print(f"Content modified and saved to {partial_files[i]}")
        i += 1
        
    # Now generate the <name>.en file
    # Look through the generated files for the /l[\s|(]['|"](.*)['|"]\)/ strings.

    # create a combined list of all the files
    all_files = [controller_file,layout_file]+partial_files
    #print(all_files)
    all_strings = []
    for filename in all_files:
        with open(filename, 'r') as file:
            file_content = file.read()
        # Define the regular expression pattern to match the strings you want to extract
        pattern = r"l[\s|(][\'|\"](.*)[\'|\"]\)"
        # Use re.findall to extract all occurrences of the pattern from the file content
        extracted_strings = re.findall(pattern, file_content)
        #print(len(extracted_strings))
        all_strings = all_strings + extracted_strings
    #print(len(all_strings))
    #Take out any duplicates
    all_strings = deduplicate_array(all_strings)
    #print(len(all_strings))  
    # Now process them one by one into the lexical file
    lex_all = "";
    # '<prefix>_english-message' => 'English Message',
    for lex_message in all_strings:
        # If has a prefix - leave it for left hand side but delete it for the right
        # If has no prefix - add one for left hand side but and lkeave it for the right
        if lex_message.startswith(hl('prefix')):
            left_str = lex_message
            right_str = lex_message[len(hl('prefix'))+1:]
        else:
            left_str = hl('prefix')+"_"+lex_message
            right_str = lex_message
        lex_all += f"'{left_str}' => '{right_str}'\n"
    #And write it to lex file
    with open( lex_file, 'w') as file:
        file.write(lex_all)