import gradio as gr
import zipfile
import io
import re
import traceback

def process_files(phase, objecten_file_dict, template_files_data):
    try:
        # Read and process the 'objecten.txt' file
        content = objecten_file_dict['data'].decode('utf-8')
        t = content.strip().split('\n\n')
        phases = ["iFAT", "(i)SAT"]
        objs = {p: [] for p in phases}
        if phase in phases:
            objs = {phase: []}
        else:
            objs = {p: [] for p in phases}

        regObject = r"\d{4}[a-zA-Z]{2}"
        for g in t:
            ls = g.strip().split('\n')
            k = ls[0]
            if k in objs:
                objs[k] = ls[1:]
            else:
                error_msg = f"Key [{k}] is not recognized."
                return None, error_msg

        # Extract object codes
        for k in objs:
            objs[k] = [re.search(regObject, o).group(0) for o in objs[k] if re.search(regObject, o)]

        # Create an in-memory ZIP file
        zip_buffer = io.BytesIO()
        with zipfile.ZipFile(zip_buffer, 'w') as zf:
            for k in objs:
                regPhase = ''
                if k == '(i)SAT':
                    regPhase = r'sat'
                elif k == 'iFAT':
                    regPhase = r'fat'

                # Filter template files for this phase
                phase_templates = []
                for file_dict in template_files_data:
                    filename = file_dict['name']
                    if re.search(regPhase, filename, re.IGNORECASE):
                        phase_templates.append(file_dict)

                if not phase_templates:
                    error_msg = f"Phase {k} has no templates."
                    return None, error_msg

                for o in objs[k]:
                    folder_path = f"{o}/"
                    for file_dict in phase_templates:
                        template_filename = file_dict['name']
                        # Adjust filename if needed
                        if re.search(r"hut_\d{4}[a-zA-Z]{2}", template_filename, re.IGNORECASE):
                            adjusted_filename = template_filename[:4] + o + template_filename[10:]
                        else:
                            adjusted_filename = template_filename

                        file_content = file_dict['data']
                        file_path = folder_path + adjusted_filename
                        zf.writestr(file_path, file_content)
        zip_buffer.seek(0)
        return zip_buffer, None
    except Exception as e:
        # Capture the full traceback
        error_msg = traceback.format_exc()
        return None, error_msg

phase_options = ['iFAT', '(i)SAT', 'All']

interface = gr.Interface(
    fn=process_files,
    inputs=[
        gr.Dropdown(choices=phase_options, label="Select Phase"),
        gr.File(label="Upload 'objecten.txt' File", type='binary'),
        gr.File(label="Upload Template Files", type='binary', multiple=True)
    ],
    outputs=[
        gr.File(label="Download ZIP File"),
        gr.Textbox(label="Error Log", lines=15)
    ],
    title="Template Folder Generator",
    description="Upload 'objecten.txt' and template files to generate folders and files."
)

interface.launch()