import gradio as gr
import cv2
import numpy as np
from PIL import Image
import io

def analisar_iris(imagem):
    """
    Função para analisar a íris através de processamento de imagem
    """
    # Converter para array numpy
    img_array = np.array(imagem)
    
    # Converter para escala de cinza
    gray = cv2.cvtColor(img_array, cv2.COLOR_RGB2GRAY)
    
    # Detectar círculos (íris) usando transformada de Hough
    circles = cv2.HoughCircles(
        gray,
        cv2.HOUGH_GRADIENT,
        dp=1,
        minDist=50,
        param1=50,
        param2=30,
        minRadius=20,
        maxRadius=100
    )
    
    # Criar cópia da imagem para desenhar
    output = img_array.copy()
    
    resultados = []
    
    if circles is not None:
        circles = np.uint16(np.around(circles))
        for i in circles[0, :]:
            # Desenhar círculo externo
            cv2.circle(output, (i[0], i[1]), i[2], (0, 255, 0), 2)
            # Desenhar centro
            cv2.circle(output, (i[0], i[1]), 2, (0, 0, 255), 3)
            
            # Análise de características
            roi = gray[i[1]-i[2]:i[1]+i[2], i[0]-i[2]:i[0]+i[2]]
            if roi.size > 0:
                media = np.mean(roi)
                std = np.std(roi)
                
                resultados.append(f"Análise da Íris:")
                resultados.append(f"- Densidade média: {media:.2f}")
                resultados.append(f"- Variação de textura: {std:.2f}")
                
                # Análise de setores
                altura, largura = roi.shape
                setor_superior = np.mean(roi[:altura//3, :])
                setor_medio = np.mean(roi[altura//3:2*altura//3, :])
                setor_inferior = np.mean(roi[2*altura//3:, :])
                
                resultados.append("\nAnálise por Setores:")
                resultados.append(f"- Setor Superior: {setor_superior:.2f}")
                resultados.append(f"- Setor Médio: {setor_medio:.2f}")
                resultados.append(f"- Setor Inferior: {setor_inferior:.2f}")
    
    return output, "\n".join(resultados)

def gerar_relatorio(imagem, nome_paciente, idade, data_analise):
    """
    Função para gerar relatório completo da análise
    """
    img_array = np.array(imagem)
    resultado_analise, metricas = analisar_iris(imagem)
    
    relatorio = f"""
    RELATÓRIO DE ANÁLISE IRIDOLÓGICA
    
    Data: {data_analise}
    
    DADOS DO PACIENTE
    Nome: {nome_paciente}
    Idade: {idade}
    
    ANÁLISE TÉCNICA
    {metricas}
    
    OBSERVAÇÕES GERAIS
    - Análise realizada com processamento computadorizado de imagem
    - Recomenda-se acompanhamento profissional para interpretação detalhada
    """
    
    return relatorio

def main():
    # Configuração do tema
    theme = gr.themes.Soft(
        primary_hue="blue",
        secondary_hue="gray",
    ).set(
        body_background_fill="*neutral_50",
        block_background_fill="*neutral_100",
        button_primary_background_fill="*primary_500",
    )
    
    # Criação da interface
    with gr.Blocks(theme=theme, title="Análise Iridológica") as iface:
        gr.Markdown("# Sistema de Análise Iridológica")
        
        with gr.Tabs():
            # Aba de Análise Básica
            with gr.Tab("Análise Básica"):
                with gr.Row():
                    with gr.Column():
                        input_image = gr.Image(label="Carregar Imagem da Íris", type="pil")
                    with gr.Column():
                        output_image = gr.Image(label="Íris Analisada")
                        output_text = gr.Textbox(label="Resultados da Análise", lines=10)
                
                analyze_btn = gr.Button("Realizar Análise", variant="primary")
                analyze_btn.click(
                    fn=analisar_iris,
                    inputs=[input_image],
                    outputs=[output_image, output_text]
                )
            
            # Aba de Relatório Completo
            with gr.Tab("Relatório Completo"):
                with gr.Row():
                    with gr.Column():
                        nome_input = gr.Textbox(label="Nome do Paciente")
                        idade_input = gr.Number(label="Idade", minimum=0, maximum=120)
                        data_input = gr.Textbox(label="Data da Análise")
                        report_image = gr.Image(label="Carregar Imagem da Íris", type="pil")
                    
                    with gr.Column():
                        report_output = gr.Textbox(label="Relatório Completo", lines=15)
                
                report_btn = gr.Button("Gerar Relatório", variant="primary")
                report_btn.click(
                    fn=gerar_relatorio,
                    inputs=[report_image, nome_input, idade_input, data_input],
                    outputs=[report_output]
                )
            
            # Aba de Informações
            with gr.Tab("Informações"):
                gr.Markdown("""
                ## Sobre a Análise Iridológica
                
                A iridologia é uma técnica de análise que estuda os sinais presentes na íris dos olhos 
                para avaliar características e condições do organismo. Este sistema realiza uma análise 
                computadorizada preliminar, que deve ser interpretada por um profissional qualificado.
                
                ### Recursos do Sistema:
                1. Análise básica da íris com detecção automática
                2. Medições de densidade e textura
                3. Análise setorial da íris
                4. Geração de relatórios personalizados
                
                ### Recomendações:
                - Utilize fotos em boa resolução
                - Certifique-se de que a íris está bem iluminada
                - A imagem deve estar focada e nítida
                """)
    
    # Iniciar a interface
    iface.launch(share=True)

if __name__ == "__main__":
    main()