import os
import sys
from prompt_toolkit import Application
from prompt_toolkit.layout import Layout, HSplit, VSplit, Window, ConditionalContainer
from prompt_toolkit.widgets import TextArea, Frame, Button, RadioList
from prompt_toolkit.lexers import PygmentsLexer
from pygments.lexers.python import PythonLexer
from prompt_toolkit.styles import Style
from prompt_toolkit.key_binding import KeyBindings
from prompt_toolkit.filters import Condition
from prompt_toolkit.widgets import Box
from prompt_toolkit.styles import style_from_pygments_cls, merge_styles
from pygments.styles import get_style_by_name
from prompt_toolkit.selection import SelectionState
import asyncio

# 🎨 ESTILO MINIMALISTA (Branco + Cinza Profundo)
style = Style.from_dict({
    'frame.border': 'white',            # Bordas Brancas
    'side-bar': 'bg:#1a1a1a white',     # Lateral cinza com letra branca
    'button': 'bg:#2a2a2a white',       # Botões discretos
    'button.focused': 'bg:white black', # Botão focado inverte (Preto no Branco)
    'selected': 'bg:#333333',           # Seleção sutil
    'textarea': 'bg:#1a1a1a white',     # Fundo do editor e cor da letra
})

class ZelieMobile:
    def __init__(self):
        self.editando = True if len(sys.argv) > 1 else False
        self.arquivo_atual = sys.argv[1] if len(sys.argv) > 1 else None
        
        self.inicio_selecao = None 
        self.temas = ["dracula", "monokai", "perldoc", "friendly"]
        self.tema_index = 0
        
        # 1. SETUP DO EDITOR
        self.editor = TextArea(
            text="",
            lexer=PygmentsLexer(PythonLexer),
            scrollbar=True,
            line_numbers=True,
            multiline=True,
            wrap_lines=False,
            focus_on_click=True,
        )

        arquivos = [a for a in os.listdir('.') if os.path.isfile(a)]
        self.lista_arquivos = RadioList(values=[(a, a) for a in arquivos])
        
        # --- AQUI ESTAVA O SEGREDO: CHAMAR A MONTAGEM ---
        self.montar_interface() 
        
        if self.arquivo_atual:
            self.carregar_arquivo(self.arquivo_atual)

    # --- MÉTODOS DE UTILIDADE (PARAFUSADOS NA CLASSE) ---
    def criar_botao_grande(self, label, acao):
        return Box(
            body=Button(label, handler=acao),
            height=1,
            padding=0
        )

    def montar_interface(self):
        # 2. BARRA LATERAL
        self.menu_lateral = HSplit([
            self.criar_botao_grande(" ❌ SAIR ", self.gerenciar_saida),
            Window(height=1),
            self.criar_botao_grande(" 📂 MENU ", self.ir_para_menu),
            Window(height=1),
            self.criar_botao_grande(" ↩️ WRAP ", self.toggle_wrap),
            Window(height=1), # Respiro
            self.criar_botao_grande(" 💾 SAVE ", self.salvar),
            Window(height=1),
            self.criar_botao_grande(" 🌙 TEMA ", self.trocar_tema),
            Window(height=1),
            self.criar_botao_grande(" 📑 COPY ", self.copiar_texto),
            Window(height=1),
            self.criar_botao_grande(" ✂️ CUT  ", self.recortar_texto),
            Window(height=1),
            
            # CUIDADO CON BOTAO DELETE
            self.criar_botao_grande(" 📋 PAST ", self.colar_texto),
            Window(height=1),
            self.criar_botao_grande(" 💥 DELETE  ", self.apagar_selecao),
            Window(height=1),
            
           # IDENTACAO E RECUO
            self.criar_botao_grande(" ➡️️ INDENTAR", self.indentar_bloco),  # INDENTAR BLOC
            Window(height=1),
            self.criar_botao_grande(" ⬅️ RECUAR", self.recuar_bloco),    # RECUAR BLOCO
            Window(height=1),
            self.criar_botao_grande("📍🔺IN", self.marcar_inicio),
            Window(height=1),
            self.criar_botao_grande("📍🔻OUT", self.marcar_fim_e_selecionar),
                    
            Window(), 
         ], width=12, style='class:side-bar')
        
        # 1. BARRINHA TURBO
        self.barra_turbo_h = VSplit([
            self.criar_botao_grande("  << TURBO  ", lambda: self.scroll_vapt("esq")),
            Window(width=25, char='-'),
            self.criar_botao_grande("  TURBO >>  ", lambda: self.scroll_vapt("dir")),
        
        
        ], height=1)

        # 3. TELAS
        self.container_editor = Frame(title=" EDITOR ", body=self.editor)
        self.container_menu = Frame(title=" MENU ", body=HSplit([
            self.lista_arquivos,
            Window(height=1),
            Button("ABRIR", handler=self.abrir_da_lista)
        ]))
        # 4. MONTAGEM DO LADO ESQUERDO (Editor em cima, Turbo embaixo)
        self.lado_esquerdo = HSplit([
            ConditionalContainer(
                content=self.container_editor,
                filter=Condition(lambda: self.editando)
            ),
            ConditionalContainer(
                content=self.container_menu,
                filter=Condition(lambda: not self.editando)
            ),
            # Só mostra a barra turbo se estiver editando
            ConditionalContainer(
                content=self.barra_turbo_h,
                filter=Condition(lambda: self.editando)
            ),
        ])
        # 5. LAYOUT FINAL - O VSplit que une tudo
        self.layout_total = VSplit([
            self.lado_esquerdo, # Isso aqui vai expandir e ocupar o resto!
            Window(width=1, char='|', style='class:frame.border'),
            self.menu_lateral,
        ])

    # --- LÓGICA DE SELEÇÃO ---
    def marcar_inicio(self):
        self.inicio_selecao = self.editor.buffer.cursor_position
        self.container_editor.title = " 📍 INÍCIO MARCADO "

    def marcar_fim_e_selecionar(self):
        if self.inicio_selecao is not None:
            self.editor.buffer.selection_state = SelectionState(self.inicio_selecao)
            self.container_editor.title = " 📝 TEXTO SELECIONADO "
        else:
            self.container_editor.title = " ⚠️ MARQUE O INÍCIO! "

    def apagar_selecao(self):
        if self.editor.buffer.selection_state:
            self.editor.buffer.cut_selection()
            self.container_editor.title = " 🗑️ SELEÇÃO APAGADA "
            self.inicio_selecao = None
        else:
            self.editor.buffer.delete()
    def copiar_texto(self):
        if self.editor.buffer.selection_state:
            data = self.editor.buffer.copy_selection()
            # Colocamos no clipboard interno do prompt-toolkit
            app.clipboard.set_data(data)
            self.container_editor.title = " 📋 COPIADO! "
        else:
            self.container_editor.title = " ⚠️ SELECIONE PRIMEIRO! "

    def recortar_texto(self):
        if self.editor.buffer.selection_state:
            data = self.editor.buffer.cut_selection()
            app.clipboard.set_data(data)
            self.container_editor.title = " ✂️ RECORTADO! "
        else:
            self.container_editor.title = " ⚠️ SELECIONE PRIMEIRO! "

    def colar_texto(self):
        # Pega o que está no clipboard e insere na posição do cursor
        self.editor.buffer.paste_clipboard_data(app.clipboard.get_data())
        self.container_editor.title = " 📥 COLADO! "
    
    def scroll_vapt(self, direcao):
        # Pula 20 espaços de uma vez
        for _ in range(20):
            if direcao == "dir":
                self.editor.buffer.cursor_right()
            else:
                self.editor.buffer.cursor_left()
               
    def indentar_bloco(self):
        """ Empurra o bloco selecionado para a direita """
        buffer = self.editor.buffer
        if buffer.selection_state:
            start, end = buffer.document.selection_range()
            # Pegamos o texto todo e dividimos
            texto_todo = buffer.text
            selecao = texto_todo[start:end]
            
            # Adicionamos espaços no início de cada linha da seleção
            linhas = selecao.split('\n')
            novo_texto = '\n'.join(['    ' + l for l in linhas])
            
            # Substituímos no buffer de forma limpa
            buffer.text = texto_todo[:start] + novo_texto + texto_todo[end:]
            # Reposiciona o cursor para não bugar a visão
            buffer.cursor_position = start + len(novo_texto)
            self.container_editor.title = " ✅ INDENTADO [>>] "

    def recuar_bloco(self):
        """ Puxa o bloco selecionado para a esquerda """
        buffer = self.editor.buffer
        if buffer.selection_state:
            start, end = buffer.document.selection_range()
            texto_todo = buffer.text
            selecao = texto_todo[start:end]
            
            linhas = selecao.split('\n')
            novas_linhas = []
            for l in linhas:
                if l.startswith('    '): novas_linhas.append(l[4:])
                elif l.startswith('\t'): novas_linhas.append(l[1:])
                else: novas_linhas.append(l)
            
            novo_texto = '\n'.join(novas_linhas)
            buffer.text = texto_todo[:start] + novo_texto + texto_todo[end:]
            buffer.cursor_position = start + len(novo_texto)
            self.container_editor.title = " ✅ RECUADO [<<] "
            
    # --- OUTRAS FUNCIONES ---
    def trocar_tema(self):
        # 1. Escolhe o próximo tema da lista
        self.tema_index = (self.tema_index + 1) % len(self.temas)
        nome_tema = self.temas[self.tema_index]
        
        # 2. Busca o estilo do código (Pygments)
        novo_pygments_style = style_from_pygments_cls(get_style_by_name(nome_tema))
        
        # 3. DEFINE O ESTILO DA INTERFACE (MUDAMOS DO VERDE PARA O BRANCO!)
        # Aqui o fundo é #1a1a1a (cinza escuro) e os detalhes são brancos
        ui_style = Style.from_dict({
            'frame.border': 'white',             # Borda Branca
            'side-bar': 'bg:#1a1a1a white',      # Lateral cinza com letra branca
            'button': 'bg:#2a2a2a white',        # Botões discretos
            'button.focused': 'bg:white black',  # Botão focado (Inverte: Preto no Branco)
            'textarea': 'bg:#1a1a1a white',      # Fundo do editor e texto principal
            'selected': 'bg:#333333',            # Seleção sutil
        })
        
        # 4. JUNTA TUDO E APLICA
        global app
        if 'app' in globals():
            # Mesclamos o tema de código com a nossa UI Minimalista
            app.style = merge_styles([novo_pygments_style, ui_style])
            
        # Atualiza o título
        self.container_editor.title = f" 📝 TEMA: {nome_tema.upper()} "
        
    def carregar_arquivo(self, nome):
        try:
            with open(nome, "r", encoding="utf-8") as f:
                self.editor.text = f.read()
            self.arquivo_atual = nome
            self.container_editor.title = f" [{nome}] "
            self.editando = True
        except: pass

    def abrir_da_lista(self):
        nome = self.lista_arquivos.current_value
        if nome: self.carregar_arquivo(nome)

    def ir_para_menu(self):
        self.editando = False
        self.mensagem_status = " 📁 Abrindo Arquivos. "
        
    def salvar(self):
        if self.arquivo_atual:
            try:
                with open(self.arquivo_atual, "w", encoding="utf-8") as f:
                    f.write(self.editor.text)
                
                # O "PRINT" DA VITÓRIA:
                self.container_editor.title = f" ✅ SALVO COM SUCESSO: {self.arquivo_atual} "
            except Exception as e:
                self.container_editor.title = f" ❌ ERRO AO SALVAR: {e} "
                
    def toggle_wrap(self):
        self.editor.wrap_lines = not self.editor.wrap_lines

    def gerenciar_saida(self):
        if self.editando: self.editando = False
        else: app.exit()

    # SETUP DO MOUSE
    def run(self):
        self.montar_interface()
        
        global app
        kb = KeyBindings()
        
        # --- ATALHOS DE EDIÇÃO (Zeliaverso Standard) ---

        @kb.add('c-c') # Ctrl + C
        def _(event):
            self.copiar_texto()

        @kb.add('c-v') # Ctrl + V
        def _(event):
            self.colar_texto()

        @kb.add('c-x') # Ctrl + X
        def _(event):
            self.recortar_texto()

        @kb.add('c-s') # Ctrl + S
        def _(event):
            self.salvar()
            
        # 🎹 COMPORTAMENTO INTELIGENTE DA TECLA TAB
        @kb.add('tab')
        def _(event):
            buffer = event.current_buffer
            # SE tiver algo selecionado -> Indenta o bloco todo
            if buffer.selection_state:
                self.indentar_bloco()
            # SE NÃO tiver seleção -> Apenas insere 4 espaços
            else:
                buffer.insert_text('    ')

        # 🎹 SHIFT + TAB PARA RECUAR (Volta o bloco)
        @kb.add('s-tab')
        def _(event):
            # Se houver seleção, recua o bloco
            if event.current_buffer.selection_state:
                self.recuar_bloco()
        # 🚀 ATALHOS PARA SCROLL X VELOZ
        @kb.add('escape', 'right') # Alt + Direita
        def _(event):
            for _ in range(10): event.current_buffer.cursor_right()

        @kb.add('escape', 'left')  # Alt + Esquerda
        def _(event):
            for _ in range(10): event.current_buffer.cursor_left()

        
        # Pegamos o tema atual (Dracula) antes de carregar a UI
        estilo_pygments = style_from_pygments_cls(get_style_by_name(self.temas[self.tema_index]))
        
        # Mesclamos com o seu estilo Neon de bordas e botões
        estilo_final = merge_styles([estilo_pygments, style])

        # CONFIGURAÇÃO DA APP
        app = Application(
            layout=Layout(
                self.layout_total, 
                focused_element=self.editor if self.editando else self.lista_arquivos
            ),
            full_screen=True, 
            style=estilo_final, 
            key_bindings=kb, 
            mouse_support=True, # ATIVA O TOQUE
            refresh_interval=0.1 # Deixa a resposta do scroll mais rápida
        )
        app.run()

def main(): # permite aceitar comando arquivo direto: zelie teste.py
    ZelieMobile().run()

if __name__ == "__main__":
    ZelieMobile().run()

