import os
import tempfile
import gradio as gr
from gradio_pdf import PDF
from remittance_pdf_processor import process_pdf_with_flow
from remittance_pdf_processing_types import Candidate, InvoiceNumbers, PaymentAmount, ProcessedPDFResult
from remittance_pdf_processing_utils import remittance_logger, format_amount_str_to_decimal
from decimal import Decimal, InvalidOperation

def is_valid_decimal(s: str) -> bool:
	try:
		Decimal(s)
		return True
	except InvalidOperation:
		return False

def custom_invoice_numbers_verifier(invoice_numbers: InvoiceNumbers, ground_truth_invoices: str) -> InvoiceNumbers:
	ground_truth_set = set(map(str.lower, map(str.strip, ground_truth_invoices.split(','))))
	return [num for num in invoice_numbers if num.lower() in ground_truth_set]	

def custom_invoice_and_amount_verifier(invoice_numbers: InvoiceNumbers, amount: PaymentAmount, ground_truth_invoices: str, ground_truth_amount: str) -> bool:
	return format_amount_str_to_decimal(amount) == format_amount_str_to_decimal(ground_truth_amount)

def process_pdf_file(pdf_file_path: str, ground_truth_invoices: str, ground_truth_amount: str):
	# Input validation
	if not ground_truth_invoices.strip():
		return "Error: Ground Truth Invoices field cannot be empty."
	
	if not ground_truth_amount.strip():
		return "Error: Ground Truth Amount field cannot be empty."
	
	if not is_valid_decimal(ground_truth_amount.strip()):
		return "Error: Ground Truth Amount must be a valid decimal number."

	try:		
		invoice_verifier = lambda x: custom_invoice_numbers_verifier(x, ground_truth_invoices)
		invoice_and_amount_verifier = lambda x, y: custom_invoice_and_amount_verifier(x, y, ground_truth_invoices, ground_truth_amount)

		extracted_result: ProcessedPDFResult = process_pdf_with_flow(
			pdf_file_path, 
			invoice_verifier=invoice_verifier,
			invoice_and_amount_verifier=invoice_and_amount_verifier
		)
		
		verified_candidate, unverified_candidate = extracted_result

		result = ""
		# result += f"Extracted invoice numbers and payment amounts:\n"
		result += f"Ground Truth Invoices: {ground_truth_invoices}\n"
		result += f"Ground Truth Amount: {ground_truth_amount}\n"
		result += "-" * 40 + "\n"

		# Print Invoice Numbers
		result += "Extracted Invoice Numbers:\n"
		for i, invoice_numbers in enumerate(unverified_candidate[0], 1):
			status = "Verified" if any(set(invoice_numbers) == set(v) for v in verified_candidate[0]) else "Unverified"
			result += f"  Candidate {i} ({status}): {', '.join(invoice_numbers)}\n"
		result += "\n"

		# Print Payment Amounts
		result += "Extracted Payment Amounts:\n"
		for i, amount in enumerate(unverified_candidate[1], 1):
			status = "Verified" if amount in verified_candidate[1] else "Unverified"
			result += f"  Candidate {i} ({status}): {amount}\n"

		return result
	except Exception as e:
		error_message = f"An error occurred while processing the PDF: {str(e)}"
		remittance_logger.error(error_message, exc_info=True)
		return error_message

# Create the Gradio interface
with gr.Blocks() as iface:
	gr.Markdown("# Remittance PDF Processor")
	gr.Markdown("Upload a PDF file to extract invoice numbers and payment amounts. Provide ground truth data for comparison.")
	
	with gr.Row():
		with gr.Column():
			pdf_input = PDF(label="Upload PDF", visible=True, height=900)
		
		with gr.Column():
			ground_truth_invoices = gr.Textbox(label="Ground Truth Invoice Numbers (comma-separated)")
			ground_truth_amount = gr.Textbox(label="Ground Truth Payment Amount")
			
			submit_button = gr.Button("Process PDF")
			
			output = gr.Textbox(label="Processing Results", lines=20)
	
	submit_button.click(
		process_pdf_file,
		inputs=[pdf_input, ground_truth_invoices, ground_truth_amount],
		outputs=[output]
	)

# Launch the interface
iface.launch()