import gradio as gr
from bs4 import BeautifulSoup
import json
import time
import os
from transformers import AutoTokenizer, pipeline

models = {
    "model_n1": "sileod/deberta-v3-base-tasksource-nli",
    # "model_n2": "roberta-large-mnli",
    # "model_n3": "facebook/bart-large-mnli",
    # "model_n4": "cross-encoder/nli-deberta-v3-xsmall"
}
def open_html(file):
    with open(file.name, "r") as f:
        content = f.read()
    return content

def find_form_fields(html_content):
    
    soup = BeautifulSoup(html_content, 'html.parser')
    
    # find all form tags
    forms = soup.find_all('form')
    
    form_fields = []
    
    for form in forms:
        # find all input and select tags within each form
        input_tags = form.find_all('input')
        select_tags = form.find_all('select')
        
        for tag in input_tags:
            form_fields.append(str(tag))
            
        for tag in select_tags:
            form_fields.append(str(tag))
    
    # Convert the list to a single string for display
    return form_fields

def load_json(json_file):
    with open(json_file, 'r') as f:
        data = json.load(f)
    return data

def classify_lines(text, candidate_labels, model_name):
    start_time = time.time()  # Start measuring time
    classifier = pipeline('zero-shot-classification', model=model_name)
    
    # Check if the text is already a list or if it needs splitting
    if isinstance(text, list):
        lines = text
    else:
        lines = text.split('\n')
        
    classified_lines = []
    for line in lines:
        if line.strip() and (line.strip().startswith("<input") or line.strip().startswith("<select") )and 'hidden' not in line.lower():  
            # Skip empty lines, classify lines starting with "<input", and exclude lines with 'hidden'
            results = classifier(line, candidate_labels=candidate_labels)
            top_classifications = results['labels'][:2]  # Get the top two classifications
            top_scores = results['scores'][:2]  # Get the top two scores
            classified_lines.append((line, list(zip(top_classifications, top_scores))))
    end_time = time.time()  # Stop measuring time
    execution_time = end_time - start_time  # Calculate execution time
    return classified_lines, execution_time

def classify_lines_json(text, json_content, candidate_labels, model_name, output_file_path):
    start_time = time.time()  # Start measuring time
    classifier = pipeline('zero-shot-classification', model=model_name)
    
    # Check if the text is already a list or if it needs splitting
    if isinstance(text, list):
        lines = text
    else:
        lines = text.split('\n')
        
    # Open the output.html file in write mode
    output_content = []

    with open(output_file_path, 'w') as output_file:
        for line in lines:

            if line.strip() and (line.strip().startswith("<input") or line.strip().startswith("<select") )and 'hidden' not in line.lower():  
                # Skip empty lines, classify lines starting with "<input", and exclude lines with 'hidden'
                results = classifier(line, candidate_labels=candidate_labels)
                top_classifications = results['labels'][:2]  # Get the top two classifications
                top_scores = results['scores'][:2]  # Get the top two scores
                line = line + f"<!-- Input: {json_content[top_classifications[0]]} with this certainty: {top_scores[0]} -->"
            output_file.write(line + '\n')  
            output_content.append(line + '\n')
          

    end_time = time.time()  # Stop measuring time
    execution_time = end_time - start_time  # Calculate execution time
    return output_content, execution_time
    
def retrieve_fields(data, path=''):
    """Recursively retrieve all fields from a given JSON structure and prompt for filling."""
    fields = {}

    # If the data is a dictionary
    if isinstance(data, dict):
        for key, value in data.items():
            # Construct the updated path for nested structures
            new_path = f"{path}.{key}" if path else key
            fields.update(retrieve_fields(value, new_path))
    
    # If the data is a list, iterate over its items
    elif isinstance(data, list):
        for index, item in enumerate(data):
            new_path = f"{path}[{index}]"
            fields.update(retrieve_fields(item, new_path))
    
    # If the data is a simple type (str, int, etc.)
    else:
        prompt = f"Please fill in the {path} field." if not data else data
        fields[path] = prompt

    return fields

def retrieve_fields_from_file(file_path):
    """Load JSON data from a file, then retrieve all fields and prompt for filling."""
    with open(file_path.name, 'r') as f:
        data = f.read()
    
    return retrieve_fields(json.loads(data))


def process_files(html_file, json_file):
    # This function will process the files.
    # Replace this with your own logic.
    output_file_path = "./output.html"
    # Open and read the files
    html_content = open_html(html_file)
    #print(html_content)
    html_inputs = find_form_fields(html_content)
    
    json_content = retrieve_fields_from_file(json_file)
    #Classificar os inputs do json para ver em que tipo de input ["text", "radio", "checkbox", "button", "date"]

    # Classify lines and measure execution time
    for model_name in models.values():
        tokenizer = AutoTokenizer.from_pretrained(model_name)

        html_classified_lines, html_execution_time = classify_lines(html_inputs, ["text", "radio", "checkbox", "button", "date"], model_name)

        json_classified_lines, json_execution_time = classify_lines_json(html_content, json_content, list(json_content.keys()), model_name, output_file_path)

        # print(str(html_execution_time) + " - " + str(html_classified_lines))
        # print(str(json_execution_time) + " - " + str(json_classified_lines))
        #FILL HERE
          
        #print(type(json_classified_lines))
    # Assuming your function returns the processed HTML
    #json_classified_lines
    #return '\n'.join(map(str, html_classified_lines))
    return '\n'.join(map(str, json_classified_lines))

iface = gr.Interface(fn=process_files, 
                     inputs=[gr.inputs.File(label="Upload HTML File"), gr.inputs.File(label="Upload JSON File")], 
                     outputs="text")

iface.launch()