import os
import json
import time
import logging
from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.chrome.options import Options as ChromeOptions
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
from selenium.common.exceptions import TimeoutException, NoSuchElementException

# Wichtig: Die zentralen Imports zuerst
from config import Config, DEALFRONT_LOGIN_URL, DEALFRONT_CREDENTIALS_FILE

# Logging-Konfiguration, eigenständig für dieses Skript
LOG_LEVEL = logging.DEBUG if Config.DEBUG else logging.INFO
LOG_FORMAT = '%(asctime)s - %(levelname)-8s - %(name)-25s - %(message)s'
logging.basicConfig(level=LOG_LEVEL, format=LOG_FORMAT, force=True)
logger = logging.getLogger(__name__)

# Definiere einen festen Ausgabeordner, der im Dockerfile erstellt wird
OUTPUT_DIR = "/app/output"

class DealfrontScraper:
    def __init__(self):
        logger.info("Initialisiere den DealfrontScraper und den Chrome WebDriver.")
        chrome_options = ChromeOptions()
        chrome_options.add_argument("--headless")
        chrome_options.add_argument("--no-sandbox")
        chrome_options.add_argument("--disable-dev-shm-usage")
        chrome_options.add_argument("--window-size=1920,1080")
        chrome_options.add_argument("--disable-blink-features=AutomationControlled")
        chrome_options.add_experimental_option("excludeSwitches", ["enable-automation"])
        chrome_options.add_experimental_option('useAutomationExtension', False)
        
        try:
            self.driver = webdriver.Chrome(options=chrome_options)
            self.driver.execute_script("Object.defineProperty(navigator, 'webdriver', {get: () => undefined})")
        except Exception as e:
            logger.critical(f"WebDriver konnte nicht initialisiert werden. Fehler: {e}", exc_info=True)
            self.driver = None
            raise
        
        self.wait = WebDriverWait(self.driver, 20)
        logger.info("WebDriver erfolgreich initialisiert.")

    def _load_credentials(self):
        try:
            with open(DEALFRONT_CREDENTIALS_FILE, 'r') as f:
                creds = json.load(f)
            username = creds.get("username")
            password = creds.get("password")
            if not username or "DEIN_DEALFRONT_BENUTZERNAME" in username or not password or "DEIN_DEALFRONT_PASSWORT" in password:
                logger.error(f"Zugangsdaten in '{DEALFRONT_CREDENTIALS_FILE}' sind ungültig.")
                return None, None
            return username, password
        except FileNotFoundError:
            logger.error(f"Credentials-Datei nicht gefunden: '{DEALFRONT_CREDENTIALS_FILE}'")
            return None, None
        except json.JSONDecodeError:
            logger.error(f"Fehler beim Parsen der Credentials-Datei: '{DEALFRONT_CREDENTIALS_FILE}'")
            return None, None

    def _save_error_screenshot(self):
        try:
            os.makedirs(OUTPUT_DIR, exist_ok=True)
            filepath = os.path.join(OUTPUT_DIR, "login_error_screenshot.png")
            self.driver.save_screenshot(filepath)
            logger.error(f"Screenshot '{filepath}' wurde für die Analyse gespeichert.")
        except Exception as e_ss:
            logger.error(f"Konnte Screenshot nicht speichern: {e_ss}")

    def login(self):
        if not self.driver:
            return False

        username, password = self._load_credentials()
        if not username or not password:
            return False

        try:
            logger.info(f"Navigiere zur Login-Seite: {DEALFRONT_LOGIN_URL}")
            self.driver.get(DEALFRONT_LOGIN_URL)
            
            # Warten, bis die Seite grundsätzlich geladen ist (z.B. auf das Username-Feld warten)
            self.wait.until(EC.visibility_of_element_located((By.ID, "username")))

            # Cookie-Banner behandeln, wenn es existiert
            try:
                # Wir suchen nach einem allgemeineren Cookie-Banner-Container
                cookie_banner = self.driver.find_element(By.ID, "CybotCookiebotDialog")
                if cookie_banner.is_displayed():
                    logger.debug("Cookie-Banner-Container gefunden. Suche nach 'Alle zulassen'-Button.")
                    # Suchen des Buttons innerhalb des Banners
                    allow_button = cookie_banner.find_element(By.ID, "CybotCookiebotDialogBodyLevelButtonLevelOptinAllowAll")
                    allow_button.click()
                    logger.info("Cookie-Banner akzeptiert.")
                    time.sleep(1) # Kurze Pause
            except NoSuchElementException:
                logger.warning("Kein Cookie-Banner gefunden. Fahre mit Login fort.")

            username_field = self.driver.find_element(By.ID, "username")
            password_field = self.driver.find_element(By.ID, "password")
            
            username_field.send_keys(username)
            password_field.send_keys(password)
            logger.info("Benutzername und Passwort eingetragen.")

            login_button = self.driver.find_element(By.CSS_SELECTOR, "button[type='submit']")
            login_button.click()
            logger.info("Login-Button geklickt. Warte auf die Verifizierung...")

            verification_element_xpath = "//input[@data-cy='header-search-input']"
            self.wait.until(EC.visibility_of_element_located((By.XPATH, verification_element_xpath)))
            
            logger.info("Login erfolgreich! Dashboard-Element gefunden.")
            return True

        except Exception as e:
            logger.critical(f"Ein Fehler ist während des Logins aufgetreten: {type(e).__name__}", exc_info=True)
            self._save_error_screenshot()
            return False

    def close(self):
        if self.driver:
            logger.info("Schließe den WebDriver.")
            self.driver.quit()

if __name__ == "__main__":
    logger.info("Starte Dealfront Automatisierung - Phase 1: Login-Test")
    scraper = None
    try:
        scraper = DealfrontScraper()
        if scraper.driver:
            if scraper.login():
                logger.info("Login-Prozess erfolgreich abgeschlossen.")
                time.sleep(5)
            else:
                logger.error("Login-Prozess ist fehlgeschlagen.")
    except Exception as e:
        logger.critical(f"Ein kritischer Fehler ist im Hauptprozess aufgetreten.", exc_info=True)
    finally:
        if scraper:
            scraper.close()
    logger.info("Login-Test beendet.")