interface.py

from contextlib import redirect_stderr, redirect_stdout
from pathlib import Path
from queue import Empty, Queue
import os
import sys
import tempfile
import threading
import webbrowser

# import requests
import sentry_sdk

from PySide6.QtCore import QRectF, QTimer
from PySide6.QtGui import QColor, QFont, QIcon, QPainter, QPen
from PySide6.QtWidgets import (
    QApplication,
    QFileDialog,
    QHBoxLayout,
    QLabel,
    QMessageBox,
    QPlainTextEdit,
    QPushButton,
    QVBoxLayout,
    QWidget,
)

from renomeia_imagem import altera_titulo
from rotaciona_imagem import corrigir_orientacao


VERSION = "1.0.0"
VERSION_URL = "https://raw.githubusercontent.com/SEU_USUARIO/stonetag/main/version.json"
DOWNLOAD_URL = "https://github.com/SEU_USUARIO/stonetag/releases/latest"

sentry_sdk.init(
    dsn="https://5b81a0faf64518f915e57850eaf73213@o4511351175577600.ingest.us.sentry.io/4511351180165120",
    release=f"stonetag@{VERSION}",
    traces_sample_rate=0.2,
)
division_by_zero = 1 / 0
EXTENSOES = {".jpg", ".jpeg", ".png"}
PASTA_SAIDA_PADRAO = Path.home() / "Desktop" / "StoneTag - Renomeadas"


def verificar_atualizacao(callback):
    """Roda em thread separada. Chama callback(nova_versao) se houver update."""
    try:
        resp = requests.get(VERSION_URL, timeout=5)
        resp.raise_for_status()
        dados = resp.json()
        nova = dados.get("version", "")
        if nova and nova != VERSION:
            callback(nova)
    except Exception:
        pass  # falha silenciosa — não interrompe o app


def caminho_recurso(caminho_relativo):
    if getattr(sys, "frozen", False):
        base = Path(getattr(sys, "_MEIPASS", Path(sys.executable).parent))
    else:
        base = Path(__file__).resolve().parent

    return base / caminho_relativo


def icone_aplicativo():
    caminho_icone = caminho_recurso(Path("assets") / "icone.ico")
    if caminho_icone.exists():
        return QIcon(str(caminho_icone))

    return QIcon()


class BarraSegmentada(QWidget):
    def __init__(self):
        super().__init__()
        self.total = 0
        self.concluidas = 0
        self.setMinimumHeight(30)

    def definir_progresso(self, concluidas, total):
        self.concluidas = max(0, concluidas)
        self.total = max(0, total)
        self.update()

    def paintEvent(self, event):
        super().paintEvent(event)

        painter = QPainter(self)
        painter.setRenderHint(QPainter.RenderHint.Antialiasing)

        largura = self.width()
        altura = self.height()
        margem = 2

        painter.setPen(QPen(QColor("#4b5563"), 1))
        painter.setBrush(QColor("#1f2933"))
        painter.drawRoundedRect(QRectF(0, 0, largura - 1, altura - 1), 4, 4)

        if self.total <= 0:
            return

        espaco = 3
        largura_util = largura - (margem * 2)
        altura_barra = altura - (margem * 2)
        largura_segmento = (largura_util - (espaco * (self.total - 1))) / self.total

        if largura_segmento < 2:
            espaco = 1
            largura_segmento = (largura_util - (espaco * (self.total - 1))) / self.total

        for indice in range(self.total):
            x = margem + indice * (largura_segmento + espaco)
            retangulo = QRectF(x, margem, largura_segmento, altura_barra)

            if indice < self.concluidas:
                cor = QColor("#22c55e")
            else:
                cor = QColor("#3a3a3a")

            painter.setPen(QPen(QColor("#ffffff"), 1))
            painter.setBrush(cor)
            painter.drawRoundedRect(retangulo, 2, 2)


class QueueWriter:
    def __init__(self, fila: Queue):
        self.fila = fila

    def write(self, texto):
        if texto:
            self.fila.put(("log", texto))

    def flush(self):
        pass


class StoneTagApp(QWidget):
    def __init__(self):
        super().__init__()

        self.setWindowTitle("StoneTag")
        icone = icone_aplicativo()
        if not icone.isNull():
            self.setWindowIcon(icone)
        self.resize(780, 520)
        self.setMinimumSize(700, 460)
        self.aplicar_tema()

        self.fila = Queue()
        self.processando = False
        self.imagens = []
        self.pasta_saida = PASTA_SAIDA_PADRAO
        self.total_fotos = 0
        self.fotos_processadas = 0

        self.criar_layout()
        self.atualizar_resumo()
        self.atualizar_progresso()

        self.timer = QTimer(self)
        self.timer.timeout.connect(self.processar_fila)
        self.timer.start(100)

        # Verifica atualização em background ao abrir
        threading.Thread(
            target=verificar_atualizacao,
            args=(self._on_update_disponivel,),
            daemon=True,
        ).start()

    def aplicar_tema(self):
        self.setStyleSheet("""
            QWidget {
                background-color: #151515;
                color: #ffffff;
                font-family: "Segoe UI";
                font-size: 11pt;
            }

            QLabel {
                color: #ffffff;
            }

            QPushButton {
                background-color: #2a2a2a;
                color: #ffffff;
                border: 1px solid #4a4a4a;
                padding: 8px 12px;
                font-weight: 600;
            }

            QPushButton:hover {
                background-color: #353535;
                border-color: #6b7280;
            }

            QPushButton:pressed {
                background-color: #1f1f1f;
            }

            QPushButton:disabled {
                color: #9ca3af;
                background-color: #202020;
                border-color: #333333;
            }

            QPlainTextEdit {
                background-color: #0d0d0d;
                color: #ffffff;
                border: 1px solid #3a3a3a;
                selection-background-color: #22c55e;
                selection-color: #0d0d0d;
                font-family: "Consolas";
                font-size: 10pt;
            }

            QMessageBox {
                background-color: #151515;
                color: #ffffff;
            }
        """)

    def criar_layout(self):
        layout = QVBoxLayout(self)
        layout.setContentsMargins(18, 18, 18, 18)
        layout.setSpacing(10)

        titulo = QLabel("StoneTag")
        titulo.setStyleSheet("font-size: 26px; font-weight: 800; color: #ffffff;")
        layout.addWidget(titulo)

        # Banner de atualização (oculto por padrão)
        self.banner_update = QPushButton("🔄 Nova versão disponível — clique para baixar")
        self.banner_update.setVisible(False)
        self.banner_update.clicked.connect(lambda: webbrowser.open(DOWNLOAD_URL))
        self.banner_update.setStyleSheet(
            "background-color: #15803d; color: #ffffff; font-weight: 700; "
            "padding: 8px; border: none; text-align: left;"
        )
        layout.addWidget(self.banner_update)

        self.status = QLabel("Selecione as fotos para começar.")
        self.status.setStyleSheet("font-size: 14px; color: #ffffff;")
        layout.addWidget(self.status)

        botoes = QHBoxLayout()

        self.botao_fotos = QPushButton("Selecionar fotos")
        self.botao_fotos.clicked.connect(self.selecionar_fotos)
        botoes.addWidget(self.botao_fotos)

        self.botao_saida = QPushButton("Escolher saída")
        self.botao_saida.clicked.connect(self.escolher_saida)
        botoes.addWidget(self.botao_saida)

        self.botao_processar = QPushButton("Processar")
        self.botao_processar.clicked.connect(self.iniciar_processamento)
        botoes.addWidget(self.botao_processar)

        self.botao_resultado = QPushButton("Abrir resultado")
        self.botao_resultado.clicked.connect(self.abrir_resultado)
        botoes.addWidget(self.botao_resultado)

        layout.addLayout(botoes)

        self.resumo = QLabel("")
        layout.addWidget(self.resumo)

        self.contador = QLabel("0 de 0 fotos processadas")
        self.contador.setStyleSheet("font-size: 18px; font-weight: 800; color: #ffffff;")
        layout.addWidget(self.contador)

        self.progresso = BarraSegmentada()
        layout.addWidget(self.progresso)

        self.log = QPlainTextEdit()
        self.log.setReadOnly(True)
        layout.addWidget(self.log, 1)

    def selecionar_fotos(self):
        arquivos, _ = QFileDialog.getOpenFileNames(
            self,
            "Selecionar fotos",
            "",
            "Imagens (*.jpg *.jpeg *.png);;Todos os arquivos (*.*)",
        )

        if not arquivos:
            return

        novas = []
        caminhos_atuais = {imagem.resolve() for imagem in self.imagens}

        for arquivo in arquivos:
            caminho = Path(arquivo)
            if caminho.suffix.lower() not in EXTENSOES:
                continue
            if caminho.resolve() in caminhos_atuais:
                continue
            novas.append(caminho)
            caminhos_atuais.add(caminho.resolve())

        self.imagens.extend(novas)
        if novas and not self.processando:
            self.total_fotos = len(self.imagens)
            self.fotos_processadas = 0
            self.atualizar_progresso()
            self.status.setText("Fotos selecionadas. Pronto para processar.")
            self.status.setStyleSheet("font-size: 14px; color: #ffffff;")

        self.escrever_log(f"{len(novas)} foto(s) adicionada(s).\n")
        self.atualizar_resumo()

    def escolher_saida(self):
        pasta = QFileDialog.getExistingDirectory(
            self,
            "Escolher pasta de saída",
            str(self.pasta_saida.parent),
        )

        if not pasta:
            return

        self.pasta_saida = Path(pasta)
        self.atualizar_resumo()

    def iniciar_processamento(self):
        if self.processando:
            return

        if not self.imagens:
            QMessageBox.warning(self, "StoneTag", "Selecione pelo menos uma foto.")
            return

        self.limpar_log()
        self.processando = True
        self.total_fotos = len(self.imagens)
        self.fotos_processadas = 0
        self.atualizar_progresso()
        self.alternar_botoes(False)
        self.status.setText("Processando fotos...")
        self.status.setStyleSheet("font-size: 14px; font-weight: 700; color: #ffffff;")

        thread = threading.Thread(target=self.processar_imagens, daemon=True)
        thread.start()

    def processar_imagens(self):
        salvas = 0
        duplicadas = 0
        codigos_processados = set()

        try:
            writer = QueueWriter(self.fila)
            with redirect_stdout(writer), redirect_stderr(writer):
                self.pasta_saida.mkdir(parents=True, exist_ok=True)

                with tempfile.TemporaryDirectory(prefix="stonetag_") as pasta_temporaria:
                    pasta_rotacionadas = Path(pasta_temporaria) / "rotacionadas"

                    print(f"{len(self.imagens)} foto(s) selecionada(s).")
                    print(f"Saída: {self.pasta_saida}\n")

                    total = len(self.imagens)

                    for indice, imagem in enumerate(self.imagens, start=1):
                        self.fila.put(("status", f"Processando {indice} de {total}: {imagem.name}"))
                        print(f"[{indice}/{total}] {imagem.name}")
                        caminho_corrigido = corrigir_orientacao(
                            str(imagem),
                            pasta_saida=pasta_rotacionadas,
                        )

                        resultado = altera_titulo(
                            str(caminho_corrigido),
                            codigos_ja_processados=codigos_processados,
                            pasta_saida=self.pasta_saida,
                        )

                        if resultado is None:
                            print("Não foi possível renomear esta foto.\n")
                            self.fila.put(("progress", (indice, total)))
                            continue

                        codigo = resultado["codigo"]
                        caminho_salvo = resultado["caminho_salvo"]

                        if caminho_salvo is None:
                            duplicadas += 1
                        else:
                            salvas += 1
                            codigos_processados.add(codigo)

                        print()
                        self.fila.put(("progress", (indice, total)))

                self.fila.put(("concluido", (salvas, duplicadas, len(self.imagens))))
        except Exception as erro:
            self.fila.put(("erro", str(erro)))
        finally:
            self.fila.put(("finalizado", None))

    def processar_fila(self):
        while True:
            try:
                tipo, valor = self.fila.get_nowait()
            except Empty:
                break

            if tipo == "log":
                self.escrever_log(valor)
            elif tipo == "status":
                self.status.setText(valor)
            elif tipo == "progress":
                concluidas, total = valor
                self.fotos_processadas = concluidas
                self.total_fotos = total
                self.atualizar_progresso()
            elif tipo == "concluido":
                salvas, duplicadas, total = valor
                self.fotos_processadas = total
                self.total_fotos = total
                self.atualizar_progresso()
                self.status.setText(
                    f"PROCESSAMENTO CONCLUÍDO: {salvas} salva(s), {duplicadas} duplicada(s)."
                )
                self.status.setStyleSheet(
                    "font-size: 16px; font-weight: 800; color: #ffffff; "
                    "background-color: #15803d; padding: 8px;"
                )
                QMessageBox.information(
                    self,
                    "StoneTag",
                    f"Processamento concluído.\n\n{salvas} imagem(ns) salva(s).\n{duplicadas} duplicada(s).",
                )
            elif tipo == "erro":
                self.status.setText("Erro durante o processamento.")
                self.status.setStyleSheet(
                    "font-size: 16px; font-weight: 800; color: #ffffff; "
                    "background-color: #b91c1c; padding: 8px;"
                )
                QMessageBox.critical(self, "StoneTag", valor)
            elif tipo == "finalizado":
                self.processando = False
                self.alternar_botoes(True)
            elif tipo == "update":
                self.banner_update.setText(f"🔄 Nova versão {valor} disponível — clique para baixar")
                self.banner_update.setVisible(True)

    def atualizar_resumo(self):
        self.resumo.setText(
            f"{len(self.imagens)} foto(s) selecionada(s) | Saída: {self.pasta_saida}"
        )

    def atualizar_progresso(self):
        self.progresso.definir_progresso(self.fotos_processadas, self.total_fotos)
        self.contador.setText(
            f"{self.fotos_processadas} de {self.total_fotos} fotos processadas"
        )

    def escrever_log(self, texto):
        cursor = self.log.textCursor()
        cursor.movePosition(cursor.MoveOperation.End)
        cursor.insertText(texto)
        self.log.setTextCursor(cursor)
        self.log.ensureCursorVisible()

    def limpar_log(self):
        self.log.clear()

    def alternar_botoes(self, ativo):
        self.botao_fotos.setEnabled(ativo)
        self.botao_saida.setEnabled(ativo)
        self.botao_processar.setEnabled(ativo)
        self.botao_resultado.setEnabled(ativo)

    def _on_update_disponivel(self, nova_versao):
        """Chamado pela thread de update — usa fila para atualizar UI com segurança."""
        self.fila.put(("update", nova_versao))

    def abrir_resultado(self):
        self.pasta_saida.mkdir(parents=True, exist_ok=True)
        os.startfile(self.pasta_saida.resolve())

    def closeEvent(self, event):
        if self.processando:
            resposta = QMessageBox.question(
                self,
                "Fechar StoneTag",
                "O processamento ainda está em andamento.\n\nDeseja fechar e interromper agora?",
                QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No,
                QMessageBox.StandardButton.No,
            )

            if resposta != QMessageBox.StandardButton.Yes:
                event.ignore()
                return

        event.accept()
        os._exit(0)


if __name__ == "__main__":
    app = QApplication(sys.argv)
    icone = icone_aplicativo()
    if not icone.isNull():
        app.setWindowIcon(icone)
    app.setFont(QFont("Segoe UI", 10))
    app.setQuitOnLastWindowClosed(True)
    app.lastWindowClosed.connect(lambda: os._exit(0))
    janela = StoneTagApp()
    janela.show()
    sys.exit(app.exec())