app.py

import os
import time
import gradio as gr
from selenium import webdriver
from selenium.webdriver.chrome.options import Options
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.common.by import By
from selenium.common.exceptions import WebDriverException # Import specific exception
import tempfile
import logging
import atexit # Untuk cleanup saat skrip exit
from threading import Lock # Untuk thread safety jika Gradio menangani request secara konkuren

# --- Konfigurasi ---
CHROME_INSTANCE_TIMEOUT = 600 # Detik (10 menit)

# Konfigurasi logging dasar
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')

class ChromeDriverManager:
    """Mengelola satu instance WebDriver Chrome yang persisten dengan timeout."""
    def __init__(self, timeout_seconds):
        self.driver = None
        self.last_used_time = None
        self.timeout_seconds = timeout_seconds
        self.lock = Lock() # Lock untuk mencegah race condition saat mengakses/membuat driver
        self.options = self._configure_options()
        logging.info(f"ChromeDriverManager diinisialisasi dengan timeout {timeout_seconds} detik.")
        # Daftarkan fungsi cleanup untuk dijalankan saat skrip Python keluar
        atexit.register(self.quit_driver)

    def _configure_options(self):
        """Konfigurasi opsi Chrome (tanpa ukuran jendela awal)."""
        chrome_options = Options()
        chrome_options.add_argument('--headless')
        chrome_options.add_argument('--disable-gpu')
        chrome_options.add_argument('--no-sandbox')
        chrome_options.add_argument('--disable-dev-shm-usage')
        chrome_options.add_argument('--remote-debugging-port=9222') # Opsional
        # Jangan set window size di sini, akan diatur per permintaan
        # chrome_options.add_argument('--window-size=1920,1080')
        return chrome_options

    def _initialize_driver(self):
        """Membuat instance WebDriver baru."""
        logging.info("Menginisialisasi instance WebDriver Chrome baru...")
        try:
            # Pertimbangkan menggunakan webdriver-manager jika perlu
            # from selenium.webdriver.chrome.service import Service as ChromeService
            # from webdriver_manager.chrome import ChromeDriverManager
            # service = ChromeService(executable_path=ChromeDriverManager().install())
            # driver = webdriver.Chrome(service=service, options=self.options)
            driver = webdriver.Chrome(options=self.options)
            self.last_used_time = time.time()
            logging.info("Instance WebDriver baru berhasil dibuat.")
            return driver
        except Exception as e:
            logging.error(f"Gagal menginisialisasi WebDriver: {e}", exc_info=True)
            # Set driver ke None jika gagal agar dicoba lagi nanti
            self.driver = None
            self.last_used_time = None
            return None

    def _is_driver_alive(self):
        """Memeriksa apakah driver masih responsif."""
        if self.driver is None:
            return False
        try:
            # Perintah ringan untuk memeriksa koneksi, misal mendapatkan URL saat ini
            _ = self.driver.current_url
            return True
        except WebDriverException as e:
            # Tangkap error spesifik yang mengindikasikan driver mati/tidak terhubung
            logging.warning(f"Driver tampaknya tidak responsif: {e}")
            return False
        except Exception as e:
            # Tangkap error lain yang mungkin terjadi
            logging.warning(f"Error tidak terduga saat memeriksa status driver: {e}")
            return False


    def get_driver(self, requested_width, requested_height):
        """Mendapatkan instance driver yang ada atau membuat yang baru jika perlu."""
        with self.lock: # Pastikan operasi ini thread-safe
            current_time = time.time()
            needs_new_driver = False

            if self.driver is None:
                logging.info("Tidak ada driver aktif, membuat yang baru.")
                needs_new_driver = True
            elif not self._is_driver_alive():
                 logging.warning("Driver yang ada tidak responsif, membuat yang baru.")
                 self.quit_driver(acquire_lock=False) # Tutup driver lama (lock sudah dipegang)
                 needs_new_driver = True
            elif self.last_used_time and (current_time - self.last_used_time > self.timeout_seconds):
                logging.info(f"Driver melewati batas waktu idle ({self.timeout_seconds}s). Membuat yang baru.")
                self.quit_driver(acquire_lock=False) # Tutup driver lama (lock sudah dipegang)
                needs_new_driver = True

            if needs_new_driver:
                self.driver = self._initialize_driver()
                # Jika inisialisasi gagal, driver akan None, tangani di luar
                if self.driver is None:
                    logging.error("Gagal membuat instance driver baru setelah mencoba.")
                    return None # Kembalikan None untuk menandakan kegagalan

            # Jika driver berhasil didapatkan (baru atau lama)
            if self.driver:
                try:
                    # Atur ukuran jendela sesuai permintaan SETIAP kali driver digunakan
                    logging.info(f"Mengatur ukuran jendela driver ke {requested_width}x{requested_height}")
                    self.driver.set_window_size(requested_width, requested_height)
                    # Update waktu penggunaan terakhir HANYA jika berhasil mendapatkan/menggunakan driver
                    self.last_used_time = current_time
                    logging.info("Menggunakan instance driver yang ada/baru.")
                except WebDriverException as e:
                     logging.error(f"Gagal mengatur ukuran jendela atau driver bermasalah: {e}. Menutup driver.", exc_info=True)
                     self.quit_driver(acquire_lock=False) # Tutup driver bermasalah
                     self.driver = None # Pastikan driver di-reset
                     return None # Kembalikan None untuk menandakan kegagalan
            else:
                 # Kasus di mana _initialize_driver gagal dan self.driver masih None
                 logging.warning("Tidak dapat menyediakan instance driver.")


            return self.driver # Kembalikan driver (bisa None jika gagal total)


    def quit_driver(self, acquire_lock=True):
        """Menutup instance WebDriver jika ada."""
        # Fungsi ini bisa dipanggil dari atexit atau saat timeout/error,
        # jadi perlu penanganan lock yang fleksibel
        if acquire_lock:
            acquired = self.lock.acquire(timeout=5) # Coba kunci, timeout jika macet
            if not acquired:
                logging.error("Gagal mendapatkan lock untuk quit_driver. Melewati penutupan.")
                return
        try:
            if self.driver:
                logging.info("Menutup instance WebDriver...")
                try:
                    self.driver.quit()
                    logging.info("WebDriver berhasil ditutup.")
                except Exception as e:
                    logging.error(f"Error saat menutup WebDriver: {e}", exc_info=True)
                finally:
                    # Selalu set ke None meskipun quit gagal
                    self.driver = None
                    self.last_used_time = None
            else:
                logging.debug("Tidak ada instance WebDriver aktif untuk ditutup.") # Log level debug
        finally:
            if acquire_lock and acquired: # Hanya release jika lock didapatkan di sini
                self.lock.release()

# --- Buat instance manager global ---
chrome_manager = ChromeDriverManager(timeout_seconds=CHROME_INSTANCE_TIMEOUT)

# Function to capture a screenshot using the managed driver
def capture_screenshot_gradio(url, window_width, window_height, internal_delay):
    """
    Mengambil screenshot halaman web menggunakan instance Chrome yang dikelola.
    """
    # Validasi URL sederhana
    if not url.startswith(('http://', 'https://')):
        logging.info(f"Menambahkan 'http://' ke URL: {url}")
        url = 'http://' + url

    # Validasi input ukuran dan delay
    try:
        window_width = int(window_width)
        window_height = int(window_height)
        internal_delay = int(internal_delay)
        if window_width <= 0 or window_height <= 0 or internal_delay < 0:
             raise ValueError("Width, Height harus positif dan Delay tidak boleh negatif")
    except (ValueError, TypeError) as e:
        logging.error(f"Input tidak valid untuk ukuran/delay: {e}")
        raise gr.Error(f"Input tidak valid: Lebar, Tinggi harus angka positif dan Delay tidak boleh negatif.")

    logging.info(f"Permintaan screenshot untuk URL: {url}")
    logging.info(f"Opsi: Lebar={window_width}, Tinggi={window_height}, Delay={internal_delay} detik")

    driver = None # Inisialisasi driver di scope ini
    screenshot_path = None

    try:
        # Dapatkan driver dari manager (akan membuat baru atau menggunakan yang ada)
        # Ukuran jendela akan diatur di dalam get_driver
        driver = chrome_manager.get_driver(window_width, window_height)

        # Jika get_driver gagal mengembalikan driver
        if driver is None:
            raise gr.Error("Gagal mendapatkan atau menginisialisasi instance WebDriver Chrome.")

        logging.info(f"Navigasi ke URL: {url}")
        # Set page load timeout untuk mencegah hang jika halaman sangat lambat
        driver.set_page_load_timeout(60) # Timeout 60 detik untuk memuat halaman
        try:
            driver.get(url)
        except Exception as page_load_error:
             logging.error(f"Timeout atau error saat memuat URL {url}: {page_load_error}")
             # Pertimbangkan apakah driver harus ditutup jika hanya load gagal
             # chrome_manager.quit_driver() # Opsional: tutup driver jika load gagal total
             raise gr.Error(f"Gagal memuat URL {url}: {page_load_error}")

        # 1. Tunggu hingga status dokumen 'complete'
        logging.info("Menunggu document.readyState menjadi 'complete'...")
        try:
            WebDriverWait(driver, 45).until( # Timeout sedikit lebih lama
                lambda d: d.execute_script('return document.readyState') == 'complete'
            )
            logging.info("document.readyState sudah 'complete'.")
        except Exception as wait_error:
            logging.warning(f"Timeout atau error saat menunggu readyState complete untuk {url}: {wait_error}")
            # Lanjutkan saja, mungkin halaman masih bisa di-screenshot sebagian

        # 2. Tambahkan delay internal setelah 'complete'
        if internal_delay > 0:
            logging.info(f"Menunggu delay tambahan selama {internal_delay} detik...")
            time.sleep(internal_delay)
            logging.info("Delay selesai.")
        else:
            logging.info("Tidak ada delay tambahan (0 detik).")

        # Buat file sementara untuk menyimpan screenshot
        with tempfile.NamedTemporaryFile(suffix=".png", delete=False) as tmp_file:
            screenshot_path = tmp_file.name

        logging.info(f"Mengambil screenshot ke: {screenshot_path}")
        driver.save_screenshot(screenshot_path)
        logging.info("Screenshot berhasil diambil.")

        return screenshot_path

    except WebDriverException as wd_error:
        # Jika terjadi error spesifik WebDriver, kemungkinan besar instance-nya bermasalah
        logging.error(f"WebDriverException terjadi saat memproses {url}: {wd_error}", exc_info=True)
        logging.warning("Menutup instance driver karena WebDriverException.")
        chrome_manager.quit_driver() # Paksa tutup driver yang bermasalah
        # Hapus file sementara jika ada
        if screenshot_path and os.path.exists(screenshot_path):
             try: os.remove(screenshot_path)
             except OSError: pass
        raise gr.Error(f"Terjadi masalah dengan browser: {wd_error}")

    except Exception as e:
        logging.error(f"Terjadi kesalahan umum saat memproses URL {url}: {e}", exc_info=True)
        # Hapus file sementara jika ada
        if screenshot_path and os.path.exists(screenshot_path):
            try:
                os.remove(screenshot_path)
                logging.info(f"Membersihkan file sementara yang gagal: {screenshot_path}")
            except OSError as remove_err:
                logging.error(f"Gagal menghapus file sementara {screenshot_path}: {remove_err}")
        # Tidak perlu menutup driver di sini kecuali errornya WebDriverException (sudah ditangani)
        raise gr.Error(f"Gagal mengambil screenshot: {e}")

    # finally:
        # TIDAK ADA driver.quit() di sini lagi. Dikelola oleh ChromeDriverManager.
        # Cukup pastikan instance manager dibuat di luar dan atexit terdaftar.
        # logging.debug("Blok finally capture_screenshot_gradio selesai.") # Untuk debugging jika perlu


# --- Membuat Antarmuka Gradio (Sama seperti sebelumnya) ---

# 1. Definisikan Komponen Input
url_input = gr.Textbox(
    label="Masukkan URL Website",
    placeholder="contoh: https://www.google.com atau example.com"
)
width_input = gr.Number(label="Lebar Jendela (px)", value=1920, minimum=300, step=10, info="Lebar viewport browser.")
height_input = gr.Number(label="Tinggi Jendela (px)", value=1080, minimum=200, step=10, info="Tinggi viewport browser.")
delay_input = gr.Number(label="Delay Tambahan (detik)", value=5, minimum=0, step=1, info="Waktu tunggu ekstra setelah halaman 'lengkap'.")

# 2. Definisikan Komponen Output
output_image = gr.Image(type="filepath", label="Hasil Screenshot")

# 3. Membuat instance Interface Gradio
iface = gr.Interface(
    fn=capture_screenshot_gradio,
    inputs=[url_input, width_input, height_input, delay_input],
    outputs=output_image,
    title="Pengambil Screenshot Website Cepat (Chrome Persisten)",
    description="Masukkan URL, atur ukuran jendela dan delay. Instance Chrome akan berjalan hingga 10 menit untuk mempercepat respons.",
    allow_flagging='never',
    concurrency_limit=None, # <--- DITAMBAHKAN DI SINI
    examples=[
        ["https://gradio.app", 1280, 720, 3],
        ["https://github.com", 1920, 1080, 5],
        ["https://www.google.com/maps", 1024, 768, 8]
    ]
)

# Menjalankan aplikasi Gradio
if __name__ == "__main__":
    print("Menjalankan aplikasi Gradio dengan instance Chrome persisten...")
    print(f"Instance Chrome akan ditutup otomatis setelah {CHROME_INSTANCE_TIMEOUT} detik tidak aktif atau saat aplikasi berhenti.")
    print("Pastikan Google Chrome dan ChromeDriver yang sesuai sudah terinstall.")
    print("Anda mungkin perlu menginstal: pip install selenium webdriver-manager gradio") # webdriver-manager jika digunakan
    iface.launch()
    print("Aplikasi Gradio ditutup.")
    # atexit akan memanggil chrome_manager.quit_driver() secara otomatis di sini