import os
import json
import tkinter as tk
from tkinter import ttk, filedialog, messagebox
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg
from scipy.signal import savgol_filter

class WoodAnalysisTool:
    def __init__(self, root):
        self.root = root
        self.root.title("Wood Analysis Tool - Resistograph RGP")
        self.root.geometry("1200x800")
        
        self.current_folder = ""
        self.rgp_files = []
        
        self.setup_ui()

    def setup_ui(self):
        # --- PAINEL ESQUERDO: Navegação e Controles ---
        left_frame = ttk.Frame(self.root, width=300, padding=10)
        left_frame.pack(side=tk.LEFT, fill=tk.Y)
        
        # Botão Selecionar Pasta
        ttk.Button(left_frame, text="1. Selecionar Pasta", command=self.load_folder).pack(fill=tk.X, pady=(0, 10))
        
        # Label da Pasta Atual
        self.lbl_folder = ttk.Label(left_frame, text="Nenhuma pasta selecionada", wraplength=280)
        self.lbl_folder.pack(fill=tk.X, pady=(0, 10))
        
        # Listbox de Arquivos RGP
        ttk.Label(left_frame, text="2. Arquivos .rgp (Clique para analisar):").pack(fill=tk.X)
        self.lst_files = tk.Listbox(left_frame, height=15)
        self.lst_files.pack(fill=tk.BOTH, expand=True, pady=(0, 10))
        self.lst_files.bind('<<ListboxSelect>>', self.on_file_select)
        
        # Área dos 12 Botões de Script (Batch Processing)
        ttk.Label(left_frame, text="3. Scripts em Lote (Geração de .xlsx):").pack(fill=tk.X, pady=(10, 5))
        buttons_frame = ttk.Frame(left_frame)
        buttons_frame.pack(fill=tk.X)
        
        # Criando os 12 botões dinamicamente
        for i in range(1, 13):
            btn = ttk.Button(buttons_frame, text=f"Rodar Script {i}", 
                             command=lambda idx=i: self.run_batch_script(idx))
            # Organizando em 2 colunas
            btn.grid(row=(i-1)//2, column=(i-1)%2, padx=2, pady=2, sticky="ew")
            
        buttons_frame.columnconfigure(0, weight=1)
        buttons_frame.columnconfigure(1, weight=1)

        # --- PAINEL DIREITO: Visualização e Gráficos ---
        right_frame = ttk.Frame(self.root, padding=10)
        right_frame.pack(side=tk.RIGHT, fill=tk.BOTH, expand=True)
        
        # Texto do Cabeçalho (Header)
        ttk.Label(right_frame, text="Informações do Header (Metadados):").pack(anchor=tk.W)
        self.txt_header = tk.Text(right_frame, height=6, wrap=tk.WORD, bg="#f0f0f0")
        self.txt_header.pack(fill=tk.X, pady=(0, 10))
        
        # Área do Gráfico (Matplotlib)
        self.fig, (self.ax1, self.ax2) = plt.subplots(2, 1, figsize=(8, 6), tight_layout=True)
        self.canvas = FigureCanvasTkAgg(self.fig, master=right_frame)
        self.canvas.get_tk_widget().pack(fill=tk.BOTH, expand=True)

    def load_folder(self):
        """Abre o diálogo para selecionar a pasta e lista os arquivos .rgp"""
        folder_path = filedialog.askdirectory()
        if not folder_path:
            return
            
        self.current_folder = folder_path
        self.lbl_folder.config(text=f"Pasta: {os.path.basename(folder_path)}")
        
        # Limpar listbox
        self.lst_files.delete(0, tk.END)
        self.rgp_files = []
        
        # Buscar arquivos .rgp
        for file in os.listdir(folder_path):
            if file.lower().endswith('.rgp'):
                self.rgp_files.append(file)
                self.lst_files.insert(tk.END, file)
                
        if not self.rgp_files:
            messagebox.showinfo("Aviso", "Nenhum arquivo .rgp encontrado nesta pasta.")

    def on_file_select(self, event):
        """Acionado ao clicar em um arquivo na Listbox"""
        selection = self.lst_files.curselection()
        if not selection:
            return
            
        file_name = self.lst_files.get(selection[0])
        file_path = os.path.join(self.current_folder, file_name)
        
        self.analyze_single_file(file_path)

    def analyze_single_file(self, filepath):
        """Lê o arquivo RGP, extrai o header, aplica o filtro SG e plota"""
        try:
            # NOTA: Assumindo que o .rgp tem estrutura JSON. 
            # Se for um formato proprietário, você precisará adaptar este parser.
            with open(filepath, 'r', encoding='utf-8') as f:
                data = json.load(f)
                
            header = data.get("header", {})
            drill_data = np.array(data.get("drill", []))
            feed_data = np.array(data.get("feed", []))
            
            # 1. Atualizar o Header na tela
            self.txt_header.delete(1.0, tk.END)
            formatted_header = json.dumps(header, indent=4, ensure_ascii=False)
            self.txt_header.insert(tk.END, formatted_header)
            
            # 2. Processamento: Filtro Savitzky-Golay (SG)
            # Parâmetros padrão: janela (window_length) e ordem do polinômio (polyorder)
            window_length = 51 # Deve ser ímpar
            polyorder = 3
            
            # Evitar erro se o array for menor que a janela
            if len(drill_data) > window_length:
                drill_sg = savgol_filter(drill_data, window_length, polyorder)
                feed_sg = savgol_filter(feed_data, window_length, polyorder)
            else:
                drill_sg = drill_data
                feed_sg = feed_data
                
            # 3. Atualizar Gráficos
            self.ax1.clear()
            self.ax2.clear()
            
            # Gráfico Drill (Resistência)
            self.ax1.plot(drill_data, label='Drill Original', color='lightgray')
            self.ax1.plot(drill_sg, label='Drill Filtro SG', color='blue')
            self.ax1.set_title("Resistência à Perfuração (Drill)")
            self.ax1.set_ylabel("Amplitude")
            self.ax1.legend()
            
            # Gráfico Feed (Avanço)
            self.ax2.plot(feed_data, label='Feed Original', color='lightgray')
            self.ax2.plot(feed_sg, label='Feed Filtro SG', color='red')
            self.ax2.set_title("Velocidade de Avanço (Feed)")
            self.ax2.set_ylabel("Amplitude")
            self.ax2.set_xlabel("Profundidade / Pontos")
            self.ax2.legend()
            
            self.canvas.draw()
            
        except Exception as e:
            messagebox.showerror("Erro de Leitura", f"Não foi possível ler o arquivo:\n{str(e)}\nVerifique se o .rgp está formatado como JSON.")

    def run_batch_script(self, script_number):
        """Função que será acionada pelos 12 botões para rodar em lote"""
        if not self.current_folder or not self.rgp_files:
            messagebox.showwarning("Atenção", "Selecione uma pasta com arquivos .rgp primeiro.")
            return
            
        print(f"Executando Script {script_number} na pasta {self.current_folder}...")
        
        # --- AQUI VOCÊ INSERE A LÓGICA DO SEU SCRIPT ---
        # Exemplo de fluxo para salvar um Excel:
        # 1. Iterar sobre todos os self.rgp_files
        # 2. Extrair dados
        # 3. Criar um DataFrame pandas
        # 4. Salvar com df.to_excel()
        
        messagebox.showinfo("Sucesso", f"Script {script_number} executado com sucesso!\nPlanilhas geradas na pasta selecionada.")

if __name__ == "__main__":
    root = tk.Tk()
    app = WoodAnalysisTool(root)
    root.mainloop()