from PyQt5.QtWidgets import QApplication, QWidget, QVBoxLayout, QLabel, QLineEdit, QPushButton, QCheckBox, QMessageBox
from concurrent.futures import ThreadPoolExecutor
from PyQt5.QtCore import Qt, QThread, pyqtSignal
from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.common.keys import Keys
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
from bs4 import BeautifulSoup
import sys

class SearchThread(QThread):
    search_finished = pyqtSignal()

    def __init__(self, selected_webpages, search_term, parent=None):
        super(SearchThread, self).__init__(parent)
        self.selected_webpages = selected_webpages
        self.search_term = search_term
        self.error_message = None

    def run(self):
        try:
            

            with ThreadPoolExecutor() as executor:
                futures = []

                

                for webseite in self.selected_webpages:
                    # Fügen hier andere Suchfunktionen hinzu
                    # WebDriver initialisieren
                    self.driver = webdriver.Edge()
                    
                    if webseite == "Reichelt":
                        futures.append(executor.submit(self.suche_auf_reichelt))
                    elif webseite == "Conrad":
                        futures.append(executor.submit(self.suche_auf_conrad))
                    elif webseite == "Kosatec":
                        futures.append(executor.submit(self.suche_auf_kosatec))
                    elif webseite == "Hornbach": 
                        futures.append(executor.submit(self.suche_auf_hornbach))
                    elif webseite =="Contorion":
                        futures.append(executor.submit(self.suche_auf_contorion))
                    elif webseite == "Gastro Teile Shop":
                        futures.append(executor.submit(self.suche_auf_gastroteileshop))
                    elif webseite == "TiroLED":
                        futures.append(executor.submit(self.suche_auf_tiroled))
                    elif webseite == "Megabad":
                        futures.append(executor.submit(self.suche_auf_megabad))
                    elif webseite == "IPS":
                        futures.append(executor.submit(self.suche_auf_ips_shop, ))
                    elif webseite == "Brewes":
                        futures.append(executor.submit(self.suche_auf_brewes))
                    elif webseite == "Delker":
                        futures.appen(executor.submit(self.suche_auf_delker))
                    elif webseite == "Knauss":
                        futures.append(executor.submit(self.suche_auf_knauss))
                    elif webseite == "Schildershop24":
                        futures.append(executor.submit(self.suche_auf_schildershop24))
                    elif webseite == "Häfele":
                        futures.append(executor.submit(self.suche_auf_haefele))
                    elif webseite == "Esmeyer":
                        futures.append(executor.submit(self.suche_auf_esmeyer))
                    elif webseite == "Papstar":
                        futures.append(executor.submit(self.suche_auf_papstar))
                    elif webseite == "Lusini":
                        futures.append(executor.submit(self.suche_auf_lusini))
                    elif webseite == "Hygi":
                        futures.append(executor.submit(self.suche_auf_hygi))
                    elif webseite == "Schafferer":
                        futures.append(executor.submit(self.suche_auf_schafferer))
                    elif webseite == "Gastronomie Kaufhaus":
                        futures.append(executor.submit(self.suche_auf_gastronomie_kaufhaus))
                    elif webseite == "Böttcher":
                        futures.append(executor.submit(self.suche_auf_boettcher))
                    elif webseite == "Büroshop24":
                        futures.append(executor.submit(self.suche_auf_bueroshop24))

                for future in futures:
                    future.result()  # Warte auf das Ende der Suche

            self.search_finished.emit()
        except Exception as e:
            self.error_message = f"Fehler bei der Suche: {e}"
            
        
        

    def suche_auf_haefele(self):
        # URL für die Suche generieren
        search_url = 'https://www.haefele.de/'

        # Webseite aufrufen und auf das vollständige Laden warten
        self.driver.get(search_url)
        WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.ID, "inputSearchTerm")))

        # Suchbegriff eingeben und Suche starten
        search_box = self.driver.find_element(By.ID, "inputSearchTerm")
        search_box.clear()  
        search_box.send_keys(self.search_term)
        search_box.send_keys(Keys.RETURN)

    def suche_auf_brewes(self):

        # URL für die Suche generieren
        search_url = 'https://www.brewes.de/catalogsearch/result?q='

        # Webseite aufrufen und auf das vollständige Laden warten
        self.driver.get(search_url)
        WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.ID, "search")))

        # Suchbegriff eingeben und Suche starten
        search_box = self.driver.find_element(By.ID, "search")
        search_box.clear()  # Falls vorheriger Text vorhanden ist
        search_box.send_keys(self.search_term)
        search_box.send_keys(Keys.RETURN)

    def suche_auf_conrad(self):
        # WebDriver initialisieren
        

        # Such-URL generieren
        search_url = f'https://www.conrad.de/search.html?search={self.search_term}'

        # Webseite aufrufen und auf das vollständige Laden warten
        self.driver.get(search_url)
        WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.ID, "header-search")))

        # Suchbegriff eingeben
        search_box = self.driver.find_element(By.ID, "header-search")
        search_box.clear()  # Falls vorheriger Text vorhanden ist
        search_box.send_keys(self.search_term)

        # Enter-Taste drücken
        search_box.send_keys(Keys.RETURN)

    def suche_auf_contorion(self):
        # Such-URL generieren
        search_url = f'https://www.contorion.de/suche?q={self.search_term}'

        # Webseite aufrufen und auf das vollständige Laden warten
        self.driver.get(search_url)
        WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.ID, "search-input")))

        # Suchbegriff eingeben
        search_box = self.driver.find_element(By.ID, "search-input")
        search_box.clear()  # Falls vorheriger Text vorhanden ist
        search_box.send_keys(self.search_term)

        # Enter-Taste drücken
        search_box.send_keys(Keys.RETURN)

    def suche_auf_reichelt(self):
        # WebDriver initialisieren
        self.driver = webdriver.Edge()

    
            # Such-URL generieren
        search_url = f'https://www.reichelt.de/index.html?ACTION=446&LA=446&nbc=1&SEARCH={self.search_term}'

            # Webseite aufrufen und auf das vollständige Laden warten
        self.driver.get(search_url)
        WebDriverWait(self.driver, 60).until(EC.presence_of_element_located((By.ID, "searchbutton")))

            # Suchbegriff eingeben und Suche starten
        search_box = self.driver.find_element(By.ID, "quicksearch_new")
        search_box.clear()  # Falls vorheriger Text vorhanden ist
        search_box.send_keys(self.search_term)

            # Formular abschicken
        search_button = self.driver.find_element(By.ID, "searchbutton")
        search_button.click()

    def suche_auf_kosatec(self):
        # WebDriver initialisieren
        self.driver = webdriver.Edge()

        # Such-URL generieren
        search_url = f'https://www.kosatec.de/suche?query={self.search_term}'

        # Webseite aufrufen und auf das vollständige Laden warten
        self.driver.get(search_url)
        WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.CSS_SELECTOR, "input[name='search']")))

        # Suchbegriff eingeben
        search_box = self.driver.find_element(By.CSS_SELECTOR, "input[name='search']")
        search_box.clear()  # Falls vorheriger Text vorhanden ist
        search_box.send_keys(self.search_term)

        # Enter-Taste drücken
        search_box.send_keys(Keys.RETURN)

    def suche_auf_hornbach(self):
        # WebDriver initialisieren
        self.driver = webdriver.Edge()

        # URL für die Suche generieren
        search_url = 'https://www.hornbach.de/s/'

        # Webseite aufrufen und auf das vollständige Laden warten
        self.driver.get(search_url)
        WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.NAME, "global_search")))

        # Suchbegriff eingeben und Suche starten
        search_box = self.driver.find_element(By.NAME, "global_search")
        search_box.clear()  # Falls vorheriger Text vorhanden ist
        search_box.send_keys(self.search_term)
        search_box.send_keys(Keys.RETURN)
        
    def suche_auf_gastroteileshop(self):
        # WebDriver initialisieren
        self.driver = webdriver.Edge()

        # URL für die Suche generieren
        search_url = f'https://www.gastroteileshop.de/?s={self.search_term}'

        # Webseite aufrufen und auf das vollständige Laden warten
        self.driver.get(search_url)

        # Warten, bis das Suchfeld sichtbar ist
        WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.CLASS_NAME, "search-input")))

        # Suchbegriff eingeben und Suche starten
        search_box = self.driver.find_element(By.CLASS_NAME, "search-input")
        search_box.clear()  # Falls vorheriger Text vorhanden ist
        search_box.send_keys(self.search_term)
        search_box.send_keys(Keys.RETURN)

    def suche_auf_tiroled(self):
        # WebDriver initialisieren
        self.driver = webdriver.Edge()

        # URL für die Suche generieren
        search_url = 'https://www.tiroled.de/de/search'

        # Webseite aufrufen und auf das vollständige Laden warten
        self.driver.get(search_url)
        WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.NAME, "search")))

        # Suchbegriff eingeben und Suche starten
        search_box = self.driver.find_element(By.NAME, "search")
        search_box.clear()  # Falls vorheriger Text vorhanden ist
        search_box.send_keys(self.search_term)
        search_box.send_keys(Keys.RETURN)

    def suche_auf_megabad(self):
        # WebDriver initialisieren
        self.driver = webdriver.Edge()

        # URL für die Suche generieren
        search_url = 'https://www.megabad.com/'

        # Webseite aufrufen und auf das vollständige Laden warten
        self.driver.get(search_url)
        WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.ID, "search-bar-input")))

        # Suchbegriff eingeben und Suche starten
        search_box = self.driver.find_element(By.ID, "search-bar-input")
        search_box.clear()  # Falls vorheriger Text vorhanden ist
        search_box.send_keys(self.search_term)
        search_box.send_keys(Keys.RETURN)

    def suche_auf_ips_shop(self):
        # WebDriver initialisieren
        self.driver = webdriver.Edge()

        # URL für die Suche generieren
        search_url = 'https://www.ips-kts.com/de/suche?query='

        # Webseite aufrufen und auf das vollständige Laden warten
        self.driver.get(search_url)
        WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.NAME, "query")))

        # Suchbegriff eingeben und Suche starten
        search_box = self.driver.find_element(By.NAME, "query")
        search_box.clear()  # Falls vorheriger Text vorhanden ist
        search_box.send_keys(self.search_term)
        search_box.send_keys(Keys.RETURN)

    def suche_auf_delker(self):
        # WebDriver initialisieren
        self.driver = webdriver.Edge()

        # URL für die Suche generieren
        search_url = 'https://www.delker2business.com/nw2017/'

        # Webseite aufrufen und auf das vollständige Laden warten
        self.driver.get(search_url)
        WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.NAME, "query")))

        # Suchbegriff eingeben und Suche starten 
        search_box = self.driver.find_element(By.NAME, "query")
        search_box.clear()  # Falls vorheriger Text vorhanden ist
        search_box.send_keys(self.search_term)

        # Enter-Taste drücken, um die Suche zu starten
        search_box.send_keys(Keys.RETURN)

    def suche_auf_knauss(self):
        # WebDriver initialisieren
        self.driver = webdriver.Edge()

        # URL für die Suche generieren
        search_url = 'https://www.knauss.info/'

        # Webseite aufrufen und auf das vollständige Laden warten
        self.driver.get(search_url)
        WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.NAME, "sSearch")))

        # Suchbegriff eingeben und Suche starten
        search_box = self.driver.find_element(By.NAME, "sSearch")
        search_box.clear()  # Falls vorheriger Text vorhanden ist
        search_box.send_keys(self.search_term)

        # Enter-Taste drücken, um die Suche zu starten
        search_box.send_keys(Keys.RETURN)

    def suche_auf_schildershop24(self):
        # WebDriver initialisieren
        self.driver = webdriver.Edge()

        # URL für die Suche generieren
        search_url = 'https://www.schildershop24.de/'

        # Webseite aufrufen und auf das vollständige Laden warten
        self.driver.get(search_url)
        WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.ID, "search-query-stichwort_neu")))

        # Suchbegriff eingeben und Suche starten
        search_box = self.driver.find_element(By.ID, "search-query-stichwort_neu")
        search_box.clear()  # Falls vorheriger Text vorhanden ist
        search_box.send_keys(self.search_term)

        # Enter-Taste drücken, um die Suche zu starten
        search_box.send_keys(Keys.RETURN)

    def suche_auf_esmeyer(self):
        # WebDriver initialisieren
        self.driver = webdriver.Edge()

        # URL für die Suche generieren
        search_url = 'https://www.esmeyer-shop.de/'

        # Webseite aufrufen und auf das vollständige Laden warten
        self.driver.get(search_url)
        WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.NAME, "search")))

        # Suchbegriff eingeben und Suche starten
        search_box = self.driver.find_element(By.NAME, "search")
        search_box.clear()  # Falls vorheriger Text vorhanden ist
        search_box.send_keys(self.search_term)

        # Enter-Taste drücken, um die Suche zu starten
        search_box.send_keys(Keys.RETURN)

    def suche_auf_papstar(self):
        # WebDriver initialisieren
        self.driver = webdriver.Edge()

        # URL für die Suche generieren
        search_url = 'https://www.papstar-shop.de/'

        # Webseite aufrufen und auf das vollständige Laden warten
        self.driver.get(search_url)
        WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.ID, "search")))

        # Suchbegriff eingeben und Suche starten
        search_box = self.driver.find_element(By.ID, "search")
        search_box.clear()  # Falls vorheriger Text vorhanden ist
        search_box.send_keys(self.search_term)

        # Enter-Taste drücken, um die Suche zu starten
        search_box.send_keys(Keys.RETURN)

    def suche_auf_lusini(self):
        # WebDriver initialisieren
        self.driver = webdriver.Edge()

        # URL für die Suche generieren
        search_url = 'https://www.lusini.de/'

        # Webseite aufrufen und auf das vollständige Laden warten
        self.driver.get(search_url)
        WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.ID, "search-input")))

        # Suchbegriff eingeben und Suche starten
        search_box = self.driver.find_element(By.ID, "search-input")
        search_box.clear()  # Falls vorheriger Text vorhanden ist
        search_box.send_keys(self.search_term)

        # Enter-Taste drücken, um die Suche zu starten
        search_box.send_keys(Keys.RETURN)

    def suche_auf_hygi(self):
        # WebDriver initialisieren
        self.driver = webdriver.Edge()

        # URL für die Suche generieren
        search_url = 'https://www.hygi.de/'

        # Webseite aufrufen und auf das vollständige Laden warten
        self.driver.get(search_url)
        WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.ID, "qbox")))

        # Suchbegriff eingeben und Suche starten
        search_box = self.driver.find_element(By.ID, "qbox")
        search_box.clear()  # Falls vorheriger Text vorhanden ist
        search_box.send_keys(self.search_term)

        # Enter-Taste drücken, um die Suche zu starten
        search_box.send_keys(Keys.RETURN)

    def suche_auf_schafferer(self):
        # WebDriver initialisieren
        self.driver = webdriver.Edge()

        # URL für die Suche generieren
        search_url = 'https://www.schafferer.de/gastro/'

        # Webseite aufrufen und auf das vollständige Laden warten
        self.driver.get(search_url)
        WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.ID, "quicksearch-input")))

        # Suchbegriff eingeben und Suche starten
        search_box = self.driver.find_element(By.ID, "quicksearch-input")
        search_box.clear()  # Falls vorheriger Text vorhanden ist
        search_box.send_keys(self.search_term)

        # Enter-Taste drücken, um die Suche zu starten
        search_box.send_keys(Keys.RETURN)

    def suche_auf_gastronomie_kaufhaus(self):
        # WebDriver initialisieren
        self.driver = webdriver.Edge()

        # URL für die Suche generieren
        search_url = 'https://www.gastronomie-kaufhaus.de/' 

        # Webseite aufrufen und auf das vollständige Laden warten
        self.driver.get(search_url)
        WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.ID, "searchParam")))

        # Suchbegriff eingeben und Suche starten
        search_box = self.driver.find_element(By.ID, "searchParam")
        search_box.clear()  # Falls vorheriger Text vorhanden ist
        search_box.send_keys(self.search_term)

        # Enter-Taste drücken, um die Suche zu starten (falls notwendig)
        search_box.send_keys(Keys.RETURN)

    def suche_auf_boettcher(self):
    # WebDriver initialisieren
        self.driver = webdriver.Edge()

        # URL für die Suche generieren
        search_url = 'https://www.bueromarkt-ag.de/'  # Bitte die tatsächliche URL einsetzen

        # Webseite aufrufen und auf das vollständige Laden warten
        self.driver.get(search_url)
        WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.ID, "autocomplete-0-input")))

        # Suchbegriff eingeben und Suche starten
        search_box = self.driver.find_element(By.ID, "autocomplete-0-input")
        search_box.clear()  # Falls vorheriger Text vorhanden ist
        search_box.send_keys(self.search_term)

        # Enter-Taste drücken, um die Suche zu starten (falls notwendig)
        search_box.send_keys(Keys.RETURN)

    def suche_auf_bueroshop24(self):
        # WebDriver initialisieren
        self.driver = webdriver.Edge()

        # URL für die Suche generieren
        search_url = 'https://www.bueroshop24.de/' 

        # Webseite aufrufen und auf das vollständige Laden warten
        self.driver.get(search_url)
        WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.ID, "searchTerm")))

        # Suchbegriff eingeben und Suche starten
        search_box = self.driver.find_element(By.ID, "searchTerm")
        search_box.clear()  # Falls vorheriger Text vorhanden ist
        search_box.send_keys(self.search_term)

        # Enter-Taste drücken, um die Suche zu starten (falls notwendig)
        search_box.send_keys(Keys.RETURN)

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

        self.selected_webpages = {
            "Reichelt": False,
            "Conrad": False,
            "Kosatec": False,
            "Hornbach": False,
            "Contorion": False,
            "Gastro Teile Shop": False,
            "TiroLED": False,
            "Megabad": False,
            "IPS": False,
            "Brewes": False,
            "Delker": False,
            "Knauss": False,
            "Schildershop24": False,
            "Häfele": False,
            "Esmeyer": False,
            "Papstar": False,
            "Lusini": False,
            "Hygi": False,
            "Schafferer": False,
            "Gastronomie Kaufhaus": False,
            "Böttcher": False,
            "Büroshop24": False
        }

        self.search_term = ""
        self.driver = None

        self.init_ui()

    def init_ui(self):
        layout = QVBoxLayout()

        # Webseiten-Auswahl
        layout.addWidget(QLabel("Wählen Sie die Webseiten aus:"))
        for webpage, checked in self.selected_webpages.items():
            checkbox = QCheckBox(webpage)
            checkbox.setChecked(checked)
            checkbox.stateChanged.connect(lambda state, page=webpage: self.update_webpage_state(page, state))
            layout.addWidget(checkbox)

        # Suchbegriff-Eingabe
        search_label = QLabel("Geben Sie den Suchbegriff ein:")
        layout.addWidget(search_label)

        search_input = QLineEdit(self)
        search_input.textChanged.connect(self.update_search_term)
        layout.addWidget(search_input)

        # Suchen-Button
        search_button = QPushButton("Suche starten", self)
        search_button.clicked.connect(self.start_search)
        layout.addWidget(search_button)

        # Neues Suche-Button
        new_search_button = QPushButton("Neue Suche starten", self)
        new_search_button.clicked.connect(self.new_search)
        layout.addWidget(new_search_button)

        self.setLayout(layout)
        self.setGeometry(300, 300, 400, 200)
        self.setWindowTitle('Webseiten Suche App')
        self.show()

    def update_webpage_state(self, webpage, state):
        self.selected_webpages[webpage] = state == 2  # 2 entspricht dem Zustand "ausgewählt"

    def update_search_term(self, text):
        self.search_term = text

    def start_search(self):
        selected_webpages = [webpage for webpage, selected in self.selected_webpages.items() if selected]

        if not selected_webpages:
            QMessageBox.warning(self, "Fehler", "Bitte wählen Sie mindestens eine Webseite aus.")
            return

        if not self.search_term:
            QMessageBox.warning(self, "Fehler", "Bitte geben Sie einen Suchbegriff ein.")
            return

        # Starte den Such-Thread
        self.search_thread = SearchThread(selected_webpages, self.search_term)
        self.search_thread.search_finished.connect(self.search_finished)
        self.search_thread.start()

    def search_finished(self):
        self.search_thread.quit()
        self.search_thread.wait()
        if hasattr(self.search_thread, 'error_message') and self.search_thread.error_message:
            QMessageBox.critical(None, "Fehler", self.search_thread.error_message)
        else:
            QMessageBox.information(None, "Suche abgeschlossen", "Die Suche wurde erfolgreich abgeschlossen.")

    

    def new_search(self):
        self.close_driver()
        print("Neue Suche starten")

if __name__ == '__main__':
    app = QApplication(sys.argv)
    window = WebseitenSucheApp()
    sys.exit(app.exec_())