app.py

import gradio as gr
import numpy as np
import cv2
from pathlib import Path
import zipfile
import tempfile
import shutil
import os
import re
import time
import requests
from PIL import Image
from io import BytesIO
import base64
import urllib.parse
try:
    import undetected_chromedriver as uc
    from selenium.webdriver.common.by import By
    from pyvirtualdisplay import Display
    import ssl
    ssl._create_default_https_context = ssl._create_unverified_context
    SCRAPER_AVAILABLE = True
except ImportError:
    SCRAPER_AVAILABLE = False

from manhwa_extractor import ManhwaProcessor
from bs4 import BeautifulSoup

# ---------------------------------------------------------------------------
# Helpers
# ---------------------------------------------------------------------------

IMAGE_SUFFIXES = {".png", ".jpg", ".jpeg", ".webp", ".bmp", ".gif"}
NATURAL_TOKEN_RE = re.compile(r"(\d+)")

def _common_prefix_name(names: list) -> str:
    if not names:
        return "manhwa_batch"
    if len(names) == 1:
        return names[0]
    prefix = os.path.commonprefix(names).rstrip("_- ")
    return prefix if len(prefix) >= 3 else f"{names[0]}_{names[-1]}_batch"


def _natural_key(value) -> list:
    text = str(value).lower()
    return [int(token) if token.isdigit() else token for token in NATURAL_TOKEN_RE.split(text)]


def _is_image_path(path: Path) -> bool:
    return path.suffix.lower() in IMAGE_SUFFIXES and not any(part.startswith(".") for part in path.parts)


def _resolve_gradio_path(file_obj):
    if file_obj is None:
        return None
    return Path(file_obj if isinstance(file_obj, str) else getattr(file_obj, "name", str(file_obj)))


def _sanitize_folder_name(name: str, fallback: str) -> str:
    cleaned = re.sub(r"[^\w.\- /]+", "_", (name or "").strip()).strip(" ./")
    return cleaned or fallback


def _build_settings(min_panel_area, edge_sigma, low_threshold, high_threshold, reading_order, refine_panels):
    return dict(
        min_panel_area=min_panel_area,
        edge_sigma=edge_sigma,
        low_threshold=low_threshold,
        high_threshold=high_threshold,
        reading_order=reading_order,
        refine_panels=refine_panels,
    )


def _extract_panels_for_image(image_path: Path, settings: dict):
    processor = ManhwaProcessor(
        min_panel_area_ratio=settings["min_panel_area"] / 100,
        edge_detection_sigma=settings["edge_sigma"],
        low_threshold=settings["low_threshold"],
        high_threshold=settings["high_threshold"],
        reading_order=settings["reading_order"],
    )
    loaded = processor.load_image(str(image_path))
    if loaded is None:
        raise ValueError(f"Could not load {image_path.name}")

    segmentation = processor.detect_edges()
    processor.identify_panels(segmentation)
    processor.extract_panels()
    processor.order_panels()

    panels = []
    for panel_data in processor.ordered_panels:
        panel = panel_data["panel"]
        if settings["refine_panels"]:
            panel = processor.refine_panel(panel)[0]
        panels.append(panel)
    return panels


def _zip_directory_to_file(root_dir: Path, zip_name: str) -> str:
    root_dir.mkdir(parents=True, exist_ok=True)
    zip_path = Path(tempfile.gettempdir()) / f"{zip_name}.zip"
    with zipfile.ZipFile(zip_path, "w", compression=zipfile.ZIP_DEFLATED) as zf:
        for file_path in sorted(root_dir.rglob("*"), key=lambda p: _natural_key(p.relative_to(root_dir).as_posix())):
            if file_path.is_file():
                zf.write(file_path, arcname=str(file_path.relative_to(root_dir)))
    return str(zip_path)


def _process_chapter_sequence(image_paths: list[Path], chapter_rel_path: Path, settings: dict, output_root: Path):
    chapter_dir = output_root / chapter_rel_path
    chapter_dir.mkdir(parents=True, exist_ok=True)

    saved_paths = []
    issues = []
    panel_index = 1

    for image_path in sorted(image_paths, key=lambda p: _natural_key(p.name)):
        try:
            panels = _extract_panels_for_image(image_path, settings)
        except Exception as exc:
            issues.append(f"{chapter_rel_path.as_posix()}/{image_path.name} (error: {exc})")
            continue

        if not panels:
            issues.append(f"{chapter_rel_path.as_posix()}/{image_path.name} (no panels)")
            continue

        for panel in panels:
            out_path = chapter_dir / f"panel_{panel_index:04d}.png"
            cv2.imwrite(str(out_path), cv2.cvtColor(panel, cv2.COLOR_RGB2BGR))
            saved_paths.append(out_path)
            panel_index += 1

    return saved_paths, issues


def _extract_zip_groups(zip_path: Path, extract_root: Path):
    groups = {}
    with zipfile.ZipFile(zip_path) as zf:
        for info in sorted(zf.infolist(), key=lambda item: _natural_key(item.filename)):
            if info.is_dir():
                continue

            rel_name = info.filename.replace("\\", "/")
            rel_path = Path(*[part for part in Path(rel_name).parts if part not in {"", "."}])
            if not rel_path.parts or ".." in rel_path.parts or not _is_image_path(rel_path):
                continue

            dest = extract_root / rel_path
            dest.parent.mkdir(parents=True, exist_ok=True)
            with zf.open(info) as src, open(dest, "wb") as dst:
                shutil.copyfileobj(src, dst)

            chapter_key = rel_path.parent if rel_path.parent != Path(".") else Path(zip_path.stem)
            groups.setdefault(chapter_key, []).append(dest)

    return sorted(groups.items(), key=lambda item: _natural_key(item[0].as_posix()))


def _process_single(image_path: Path, settings: dict, temp_dir: Path):
    panels = _extract_panels_for_image(image_path, settings)
    if not panels:
        return 0, []

    parent_name = image_path.parent.name
    out_dir = (temp_dir / parent_name / image_path.stem
               if parent_name.lower().startswith("chapter")
               else temp_dir / image_path.stem)
    out_dir.mkdir(parents=True, exist_ok=True)

    panel_paths = []
    for panel_id, panel_to_save in enumerate(panels, start=1):
        out_path = out_dir / f"panel_{panel_id:02d}.png"
        cv2.imwrite(str(out_path), cv2.cvtColor(panel_to_save, cv2.COLOR_RGB2BGR))
        panel_paths.append(out_path)

    return len(panels), panel_paths


# ---------------------------------------------------------------------------
# Scraper Logic — site-agnostic
# ---------------------------------------------------------------------------

def _chap_num(url: str) -> float:
    """Extract a sortable chapter number from any URL."""
    url_l = url.lower().rstrip('/')
    
    # 1. Look for explicit chapter keywords 
    m = re.search(r'(?:chapter|ch|episode|ep|scan)[-_]?(\d+(?:\.\d+)?)', url_l)
    if m:
        return float(m.group(1))
        
    # 2. Look backwards for the last number block
    parts = url_l.split('/')
    for part in reversed(parts):
        nums = re.findall(r'\b(\d+(?:\.\d+)?)\b', part)
        if nums:
            return float(nums[-1])
            
    # 3. Fallback: last contiguous string of digits
    digits = re.findall(r'\d+', url_l)
    return float(digits[-1]) if digits else 0.0



def setup_uc_driver():
    options = uc.ChromeOptions()
    # No options.headless! We want it to be fully headed within the Virtual Display
    options.add_argument("--no-sandbox")
    options.add_argument("--disable-dev-shm-usage")
    options.add_argument("--disable-gpu")
    options.add_argument("--window-size=1920,1080")
    options.add_argument("--user-agent=Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36")
    
    # In Hugging Face Spaces, chromium is usually installed via packages.txt
    # and ends up in /usr/bin/chromium or similar.
    possible_bins = ["/usr/bin/chromium", "/usr/bin/google-chrome", "/usr/bin/chromium-browser"]
    for bin_path in possible_bins:
        if os.path.exists(bin_path):
            options.binary_location = bin_path
            break
            
    kwargs = {"options": options}
    
    # Also specify the chromedriver path if it exists
    possible_drivers = ["/usr/bin/chromedriver", "/usr/local/bin/chromedriver"]
    for driver_path in possible_drivers:
        if os.path.exists(driver_path):
            kwargs["driver_executable_path"] = driver_path
            break
            
    # Force version 146 as fallback if auto-download triggers
    # since Debian currently has chromium 146.
    kwargs["version_main"] = 146

    return uc.Chrome(**kwargs)


def _scroll_to_bottom(driver, pause=1.5, max_scrolls=15):
    last = driver.execute_script("return document.body.scrollHeight")
    for _ in range(max_scrolls):
        driver.execute_script("window.scrollTo(0, document.body.scrollHeight);")
        time.sleep(pause)
        new = driver.execute_script("return document.body.scrollHeight")
        if new == last:
            break
        last = new


def get_chapter_links(driver, series_url: str) -> list:
    driver.get(series_url)
    time.sleep(6)  # Let Cloudflare clear
    _scroll_to_bottom(driver)

    chapter_links = []
    for link in driver.find_elements(By.TAG_NAME, "a"):
        href = link.get_attribute("href") or ""
        href_l = href.lower()
        if not href or "#" in href or "login" in href_l or "register" in href_l:
            continue
            
        href_clean = href_l.rstrip('/')
        is_chapter = False
        
        if re.search(r'[-/](chapter|ch|episode|ep|scan)[-_]?\d+', href_clean):
            is_chapter = True
        elif re.search(r'/[a-z0-9-]+-chapter-\d+', href_clean):
            is_chapter = True
        elif re.search(r'/\d+(?:\.\d+)?$', href_clean):
            is_chapter = True
            
        if is_chapter:
            chapter_links.append(href)

    return sorted(set(chapter_links), key=_chap_num, reverse=True)


def parse_images_from_html(html_source: str, output_dir: str) -> list:
    soup = BeautifulSoup(html_source, 'html.parser')
    badKeywords = ['logo', 'avatar', 'icon', 'banner', 'button', 'ads', 'sprite', 'thumbnail', 'discord']
    
    img_urls = []
    for img in soup.find_all('img'):
        src = ""
        for name, val in img.attrs.items():
            name_l = name.lower()
            if isinstance(val, list):
                val = val[0]
            val_str = str(val).strip()
            if ('src' in name_l or 'url' in name_l) and val_str.startswith('http'):
                if name_l.startswith('data-'):
                    src = val_str
                    break
                if not src:
                    src = val_str
                    
        if src:
            src_l = src.lower()
            if len(src_l) > 5 and not src_l.startswith("data:") and not any(bad in src_l for bad in badKeywords):
                if src not in img_urls:
                    img_urls.append(src)
                    
    os.makedirs(output_dir, exist_ok=True)
    paths = []
    headers = {'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64)'}
    for i, url in enumerate(img_urls):
        try:
            r = requests.get(url, headers=headers, stream=True, timeout=10)
            if r.status_code == 200:
                ext = url.split("?")[0].split(".")[-1]
                if len(ext) > 5 or not ext: ext = "jpg"
                p = Path(output_dir) / f"{i:03d}.{ext}"
                with open(p, 'wb') as f:
                    for chunk in r.iter_content(1024):
                        f.write(chunk)
                paths.append(p)
        except Exception:
            pass
    return paths


# ---------------------------------------------------------------------------
# API Hub Integrations (MangaDex & Comick)
# ---------------------------------------------------------------------------

def search_manga_api(source, query):
    if not query.strip(): return []
    results = []
    if source == "MangaDex":
        url = f"https://api.mangadex.org/manga?title={urllib.parse.quote(query)}&limit=15&includes[]=cover_art"
        try:
            r = requests.get(url, timeout=10).json()
            for manga in r.get("data", []):
                title = manga["attributes"]["title"].get("en", "Unknown Title")
                m_id = manga["id"]
                results.append((title, m_id))
        except: pass
    elif source == "Comick":
        url = f"https://api.comick.fun/v1.0/search?q={urllib.parse.quote(query)}&limit=15"
        try:
            r = requests.get(url, timeout=10).json()
            for manga in r:
                title = manga.get("title", "Unknown")
                hid = manga.get("hid")
                if hid: results.append((title, hid))
        except: pass
    return results

def get_chapters_api(source, manga_id):
    if not manga_id: return []
    chapters = []
    if source == "MangaDex":
        url = f"https://api.mangadex.org/manga/{manga_id}/feed?limit=500&translatedLanguage[]=en&order[chapter]=desc"
        try:
            r = requests.get(url, timeout=10).json()
            for ch in r.get("data", []):
                num = ch["attributes"].get("chapter")
                tit = ch["attributes"].get("title")
                cid = ch["id"]
                label = f"Chapter {num}" if num else "Oneshot"
                if tit: label += f" - {tit}"
                chapters.append((label, cid))
        except: pass
    elif source == "Comick":
        url = f"https://api.comick.fun/comic/{manga_id}/chapters?lang=en&limit=500"
        try:
            r = requests.get(url, timeout=10).json()
            for ch in r.get("chapters", []):
                num = ch.get("chap")
                tit = ch.get("title")
                cid = ch.get("hid")
                label = f"Chapter {num}" if num else "Oneshot"
                if tit: label += f" - {tit}"
                chapters.append((label, cid))
        except: pass
    return chapters

def download_api_chapter(source, chapter_id, output_dir):
    os.makedirs(output_dir, exist_ok=True)
    paths = []
    if source == "MangaDex":
        url = f"https://api.mangadex.org/at-home/server/{chapter_id}"
        try:
            r = requests.get(url, timeout=10).json()
            base = r.get("baseUrl")
            h = r.get("chapter", {}).get("hash")
            data = r.get("chapter", {}).get("data", [])
            for i, filename in enumerate(data):
                img_url = f"{base}/data/{h}/{filename}"
                p = Path(output_dir) / f"{i:03d}.jpg"
                img_r = requests.get(img_url, stream=True, timeout=10)
                with open(p, 'wb') as f:
                    for chunk in img_r.iter_content(1024): f.write(chunk)
                paths.append(p)
        except: pass
    elif source == "Comick":
        url = f"https://api.comick.fun/chapter/{chapter_id}"
        try:
            r = requests.get(url, timeout=10).json()
            images = r.get("chapter", {}).get("images", [])
            for i, img in enumerate(images):
                img_url = img.get("url")
                if img_url:
                    p = Path(output_dir) / f"{i:03d}.jpg"
                    img_r = requests.get(img_url, stream=True, timeout=10)
                    with open(p, 'wb') as f:
                        for chunk in img_r.iter_content(1024): f.write(chunk)
                    paths.append(p)
        except: pass
    return paths

def hub_search(query, source):
    res = search_manga_api(source, query)
    choices = [f"{t} ({i})" for t, i in res]
    return gr.update(choices=choices, value=choices[0] if choices else None), res

def hub_get_chapters(selected_str, res_state, source):
    if not selected_str: return gr.update(choices=[]), []
    manga_id = None
    for t, i in res_state:
        if f"{t} ({i})" == selected_str:
            manga_id = i
            break
    chaps = get_chapters_api(source, manga_id)
    choices = [f"{t} [{i}]" for t, i in chaps]
    return gr.update(choices=choices, value=choices[0] if choices else None), chaps

def hub_download_chapter(selected_chap_str, chaps_state, source):
    if not selected_chap_str: raise gr.Error("Select a chapter first")
    chap_id = None
    for t, i in chaps_state:
        if f"{t} [{i}]" == selected_chap_str:
            chap_id = i
            break
            
    td = Path(tempfile.mkdtemp()) / "hub_chapter"
    td.mkdir(parents=True, exist_ok=True)
    imgs = download_api_chapter(source, chap_id, str(td))
    if not imgs: raise gr.Error("Failed to fetch chapter images from API.")
    
    pil_images = [Image.open(p) for p in imgs]
    choices = [p.name for p in imgs]
    state_paths = {p.name: str(p) for p in imgs}
    return pil_images, gr.update(choices=choices, value=choices, visible=True), state_paths, f"✅ Fetched {len(imgs)} pages via {source} API."

def download_chapter_images(driver, chapter_url: str, output_dir: str) -> list:
    driver.get(chapter_url)
    time.sleep(14)
    _scroll_to_bottom(driver)

    js_images = driver.execute_script("""
        const imgs = Array.from(document.querySelectorAll('img'));
        const badKeywords = ['logo', 'avatar', 'icon', 'banner', 'button', 'ads', 'sprite', 'thumbnail', 'discord'];
        return imgs.map(img => {
            let src = img.src || "";
            for (let attr of img.attributes) {
                let name = attr.name.toLowerCase();
                let val = attr.value;
                if ((name.includes('src') || name.includes('url')) && val.startsWith('http')) {
                    if (name.startsWith('data-')) return val;
                    src = val;
                }
            }
            return src;
        }).filter(s => {
            if (!s) return false;
            let s_lower = s.toLowerCase();
            if (s_lower.length < 5 || s_lower.startsWith("data:")) return false;
            for (let bad of badKeywords) {
                if (s_lower.includes(bad)) return false;
            }
            return true;
        });
    """)

    img_urls = []
    for url in (js_images or []):
        if url not in img_urls:
            img_urls.append(url)

    os.makedirs(output_dir, exist_ok=True)
    paths = []
    headers = {"Referer": chapter_url, "User-Agent": "Mozilla/5.0"}
    
    driver.set_script_timeout(15)
    
    for i, url in enumerate(img_urls):
        out = os.path.join(output_dir, f"{i+1:03d}.jpg")
        
        # 1. Try fetching via the authenticated browser context to bypass Cloudflare
        try:
            script = """
                var url = arguments[0];
                var done = arguments[arguments.length - 1];
                fetch(url)
                    .then(response => response.blob())
                    .then(blob => {
                        var reader = new FileReader();
                        reader.onloadend = function() { done(reader.result); }
                        reader.readAsDataURL(blob);
                    })
                    .catch(err => done(null));
            """
            b64_data = driver.execute_async_script(script, url)
            if b64_data and "," in b64_data:
                img_data = base64.b64decode(b64_data.split(',')[1])
                
                # Check dimensions to filter out thumbnails/icons
                try:
                    img_pil = Image.open(BytesIO(img_data))
                    if img_pil.width < 400 and img_pil.height < 400:
                        continue
                except Exception:
                    pass
                    
                with open(out, "wb") as f:
                    f.write(img_data)
                paths.append(out)
                continue
        except Exception:
            pass
            
        # 2. Fallback to requests
        try:
            r = requests.get(url, timeout=15, headers=headers)
            r.raise_for_status()
            img_data = r.content
            
            # Check dimensions to filter out thumbnails/icons
            try:
                img_pil = Image.open(BytesIO(img_data))
                if img_pil.width < 400 and img_pil.height < 400:
                    continue
            except Exception:
                pass
                
            with open(out, "wb") as f:
                f.write(img_data)
            paths.append(out)
        except Exception:
            pass
            
    return [Path(p) for p in paths]


# ---------------------------------------------------------------------------
# Processor Wrappers
# ---------------------------------------------------------------------------

def process_manhwa_image(input_image, min_panel_area, edge_sigma, low_threshold,
                         high_threshold, reading_order, refine_panels):
    if input_image is None:
        return None, "Please upload an image first", []
    try:
        img_array = np.array(input_image)
        settings = _build_settings(
            min_panel_area, edge_sigma, low_threshold, high_threshold, reading_order, refine_panels
        )
        with tempfile.TemporaryDirectory() as tmp:
            td = Path(tmp)
            inp = td / "input.png"
            cv2.imwrite(str(inp), cv2.cvtColor(img_array, cv2.COLOR_RGB2BGR))
            n, paths = _process_single(inp, settings, td)
            if n == 0:
                return None, "No panels detected.", []
            imgs = [Image.open(p) for p in paths]
            pzip = Path(tempfile.gettempdir()) / f"manhwa_{id(input_image)}.zip"
            with zipfile.ZipFile(pzip, "w") as zf:
                for p in paths:
                    zf.write(p, p.name)
            return str(pzip), f"✅ Extracted {n} panel(s)" + (" (refined)" if refine_panels else ""), imgs
    except Exception as e:
        return None, f"❌ Error: {e}", []


def batch_process_images(files, min_panel_area, edge_sigma, low_threshold,
                         high_threshold, reading_order, refine_panels):
    if not files:
        return None, "⚠️ Please upload at least one image."
    settings = _build_settings(
        min_panel_area, edge_sigma, low_threshold, high_threshold, reading_order, refine_panels
    )
    file_paths = sorted([Path(f if isinstance(f, str) else getattr(f, "name", str(f))) for f in files],
                        key=lambda p: p.stem.lower())
    zip_name = _common_prefix_name([p.stem for p in file_paths])
    tot_panels, tot_imgs, failed = 0, 0, []

    with tempfile.TemporaryDirectory() as tmp:
        td = Path(tmp)
        for img_path in file_paths:
            try:
                n, _ = _process_single(img_path, settings, td)
                tot_panels += n
                tot_imgs += 1
                if n == 0:
                    failed.append(f"{img_path.name} (no panels)")
            except Exception as e:
                failed.append(f"{img_path.name} (error: {e})")

        pzip = Path(tempfile.gettempdir()) / f"{zip_name}.zip"
        with zipfile.ZipFile(pzip, "w", compression=zipfile.ZIP_DEFLATED) as zf:
            for folder in td.iterdir():
                if folder.is_dir():
                    for pf in sorted(folder.iterdir()):
                        zf.write(pf, f"{folder.name}/{pf.name}")

    msgs = [f"✅ Processed **{tot_imgs}** images", f"📦 Extracted **{tot_panels}** panels"]
    if failed:
        msgs.append("⚠️ Issues:\n" + "\n".join(f"  • {f}" for f in failed))
    return str(pzip), "\n".join(msgs)


def process_chapter_batch(folder_files, folder_name, zip_file, min_panel_area, edge_sigma, low_threshold,
                          high_threshold, reading_order, refine_panels):
    if not folder_files and not zip_file:
        return None, "⚠️ Upload a chapter folder or a ZIP file first."

    settings = _build_settings(
        min_panel_area, edge_sigma, low_threshold, high_threshold, reading_order, refine_panels
    )

    with tempfile.TemporaryDirectory() as tmp:
        td = Path(tmp)
        output_root = td / "processed"
        output_root.mkdir(parents=True, exist_ok=True)

        chapter_groups = []
        if folder_files:
            file_paths = [
                path for path in (_resolve_gradio_path(f) for f in folder_files)
                if path is not None and _is_image_path(path)
            ]
            if file_paths:
                chapter_name = _sanitize_folder_name(
                    folder_name,
                    _common_prefix_name([path.stem for path in file_paths]) or "uploaded_chapter",
                )
                chapter_groups.append((Path(chapter_name), sorted(file_paths, key=lambda p: _natural_key(p.name))))

        if zip_file:
            zip_path = _resolve_gradio_path(zip_file)
            if zip_path is not None:
                chapter_groups.extend(_extract_zip_groups(zip_path, td / "unzipped"))

        if not chapter_groups:
            return None, "⚠️ No valid chapter images were found in the uploaded folder/ZIP."

        total_pages = 0
        total_panels = 0
        failed = []
        processed_chapters = []

        for chapter_rel_path, image_paths in sorted(chapter_groups, key=lambda item: _natural_key(item[0].as_posix())):
            if not image_paths:
                failed.append(f"{chapter_rel_path.as_posix()} (empty chapter)")
                continue

            saved_paths, issues = _process_chapter_sequence(image_paths, chapter_rel_path, settings, output_root)
            total_pages += len(image_paths)
            total_panels += len(saved_paths)
            processed_chapters.append(chapter_rel_path.as_posix())
            failed.extend(issues)

        if not list(output_root.rglob("*.png")):
            return None, "⚠️ No panels were extracted. Try lowering sensitivity or checking the source images."

        zip_sources = []
        if zip_file:
            zip_path = _resolve_gradio_path(zip_file)
            if zip_path is not None:
                zip_sources.append(zip_path.stem)
        if folder_files:
            zip_sources.append(_sanitize_folder_name(folder_name, "folder_upload"))
        zip_base = _common_prefix_name(zip_sources or ["processed_chapters"]) + "_processed"
        pzip = _zip_directory_to_file(output_root, zip_base)

    msgs = [
        f"✅ Processed **{len(processed_chapters)}** chapter folder(s)",
        f"📄 Read **{total_pages}** page(s)",
        f"📦 Extracted **{total_panels}** panel(s)",
        "📁 Output keeps the chapter folder layout and saves panels directly inside each chapter folder.",
    ]
    if failed:
        msgs.append("⚠️ Issues:\n" + "\n".join(f"  • {issue}" for issue in failed))
    return str(pzip), "\n".join(msgs)


def process_series_flow(series_url, start_chap, end_chap, do_extract,
                        min_panel_area, edge_sigma, low_threshold,
                        high_threshold, reading_order, refine_panels,
                        progress=gr.Progress(track_tqdm=True)):
    if not SCRAPER_AVAILABLE:
        raise gr.Error("Scraper dependencies not installed (undetected-chromedriver).")
    if not series_url.strip():
        raise gr.Error("Please provide a Comic Series URL.")
    if start_chap > end_chap:
        raise gr.Error("Start chapter must be ≤ End chapter.")

    settings = _build_settings(
        min_panel_area, edge_sigma, low_threshold, high_threshold, reading_order, refine_panels
    )

    progress(0, desc="Booting browser (Cloudflare bypass)…")
    disp = None
    driver = None
    try:
        disp = Display(visible=0, size=(1920, 1080))
        disp.start()
        driver = setup_uc_driver()
    except Exception as e:
        if disp: disp.stop()
        raise gr.Error(f"Failed to start browser: {e}")

    try:
        progress(0.05, desc="Fetching chapter list…")
        links = get_chapter_links(driver, series_url)
        if not links:
            raise gr.Error("No chapter links found — check the URL and try again.")

        filtered = [l for l in links if start_chap <= _chap_num(l) <= end_chap]
        if not filtered:
            raise gr.Error(f"No chapters found between {int(start_chap)} and {int(end_chap)}.")

        tot_panels, tot_imgs, failed = 0, 0, []
        label = "extracted_panels" if do_extract else "raw_chapters"
        pzip = Path(tempfile.gettempdir()) / f"manga_{label}.zip"

        with tempfile.TemporaryDirectory() as tmp:
            td = Path(tmp)
            raw_root = td / "raw"
            out_root = td / "output"
            raw_root.mkdir(parents=True, exist_ok=True)
            out_root.mkdir(parents=True, exist_ok=True)

            for idx, chap_url in enumerate(reversed(filtered)):
                chap_name = f"Chapter-{_chap_num(chap_url):g}"
                progress(0.1 + 0.7 * (idx / len(filtered)),
                         desc=f"{'Extracting' if do_extract else 'Downloading'} {chap_name}…")

                raw_dir = raw_root / chap_name
                imgs = download_chapter_images(driver, chap_url, str(raw_dir))
                if not imgs:
                    failed.append(f"{chap_name}: nothing downloaded")
                    continue

                tot_imgs += len(imgs)
                if not do_extract:
                    continue

                saved_paths, issues = _process_chapter_sequence(imgs, Path(chap_name), settings, out_root)
                tot_panels += len(saved_paths)
                failed.extend(issues)

            if do_extract:
                pzip = _zip_directory_to_file(out_root, f"manga_{label}")
            else:
                pzip = _zip_directory_to_file(raw_root, f"manga_{label}")

        msgs = [f"✅ {len(filtered)} chapters downloaded."]
        if do_extract:
            msgs.append(f"✅ {tot_imgs} pages → {tot_panels} panels extracted.")
        else:
            msgs.append(f"✅ {tot_imgs} raw pages saved.")
        if failed:
            msgs.append("⚠️ Issues:\n" + "\n".join(f"  • {f}" for f in failed))
        return str(pzip), "\n".join(msgs)

    except gr.Error:
        raise
    except Exception as e:
        raise gr.Error(str(e))
    finally:
        if driver is not None:
            driver.quit()
        if disp: disp.stop()

def fetch_chapter_images_only(chapter_url, html_source=""):
    if not str(chapter_url).strip() and not str(html_source).strip():
        raise gr.Error("Please provide a Chapter URL or HTML Source.")
        
    td = Path(tempfile.mkdtemp()) / "single_chapter"
    td.mkdir(parents=True, exist_ok=True)
    
    try:
        if str(html_source).strip():
            imgs = parse_images_from_html(html_source, str(td))
        else:
            if not SCRAPER_AVAILABLE:
                raise gr.Error("Browser scraping is disabled in this Space build. Paste HTML source instead, or use the API Hub tab.")
            disp = None
            try:
                disp = Display(visible=0, size=(1920, 1080))
                disp.start()
                driver = setup_uc_driver()
            except Exception as e:
                if disp: disp.stop()
                raise gr.Error(f"Failed to start browser: {e}")
                
            imgs = download_chapter_images(driver, chapter_url, str(td))
            driver.quit()
            if disp: disp.stop()
            
        if not imgs:
            raise gr.Error("No images found on this page. Check the URL or HTML contents.")
            
        pil_images = [Image.open(p) for p in imgs]
        choices = [p.name for p in imgs]
        state_paths = {p.name: str(p) for p in imgs}
        
        return pil_images, gr.update(choices=choices, value=choices, visible=True), state_paths, f"✅ Fetched {len(imgs)} pages successfully."
    except gr.Error:
        raise
    except Exception as e:
        raise gr.Error(str(e))
def _create_zip_from_selected(state_paths, selected_names, zip_name):
    paths = [Path(state_paths[name]) for name in selected_names if name in state_paths]
    pzip = Path(tempfile.gettempdir()) / f"{zip_name}.zip"
    with zipfile.ZipFile(pzip, "w", compression=zipfile.ZIP_DEFLATED) as zf:
        for p in paths:
            zf.write(p, p.name)
    return str(pzip)

def download_selected_single(state_paths, selected_names):
    if not selected_names:
        return None, "⚠️ No images selected."
    try:
        pzip = _create_zip_from_selected(state_paths, selected_names, "manga_chapter_raw")
        return str(pzip), f"✅ Prepared zip with {len(selected_names)} raw images."
    except Exception as e:
        return None, f"❌ Error: {e}"

def extract_selected_single(state_paths, selected_names, min_panel_area, edge_sigma, low_threshold,
                            high_threshold, reading_order, refine_panels):
    if not selected_names:
        return None, "⚠️ No images selected."

    settings = _build_settings(
        min_panel_area, edge_sigma, low_threshold, high_threshold, reading_order, refine_panels
    )

    paths = [Path(state_paths[name]) for name in selected_names if name in state_paths]

    with tempfile.TemporaryDirectory() as tmp:
        td = Path(tmp)
        output_root = td / "chapter_panels"
        saved_paths, issues = _process_chapter_sequence(paths, Path("selected_chapter"), settings, output_root)
        pzip = _zip_directory_to_file(output_root, "manga_chapter_panels")

    msgs = [
        f"✅ Processed **{len(paths)}** images",
        f"📦 Extracted **{len(saved_paths)}** panels",
        "📁 Panels are saved directly inside the chapter folder with continuous numbering.",
    ]
    if issues:
        msgs.append("⚠️ Issues:\n" + "\n".join(f"  • {issue}" for issue in issues))
    return str(pzip), "\n".join(msgs)


def download_only_series(url, start, end, ma, es, lt, ht, ro, rp,
                         progress=gr.Progress(track_tqdm=True)):
    return process_series_flow(url, start, end, False, ma, es, lt, ht, ro, rp, progress)


def download_and_extract_series(url, start, end, ma, es, lt, ht, ro, rp,
                                progress=gr.Progress(track_tqdm=True)):
    return process_series_flow(url, start, end, True, ma, es, lt, ht, ro, rp, progress)


def load_sample():
    url = "https://raw.githubusercontent.com/kushalchoksi/manhwa-panel-extractor/refs/heads/main/jinwoo.jpg"
    return Image.open(BytesIO(requests.get(url).content))


# ---------------------------------------------------------------------------
# UI
# ---------------------------------------------------------------------------

def _settings_block():
    with gr.Accordion("⚙️ Advanced Settings", open=False):
        with gr.Row():
            min_panel_area = gr.Slider(0.1, 10.0, value=1.0, step=0.1, label="Min Panel Area (%)")
            edge_sigma = gr.Slider(0.1, 3.0, value=1.0, step=0.1, label="Edge Sensitivity")
        with gr.Row():
            low_threshold = gr.Slider(0.01, 0.5, value=0.1, step=0.01, label="Low Threshold")
            high_threshold = gr.Slider(0.05, 0.8, value=0.2, step=0.01, label="High Threshold")
        with gr.Row():
            reading_order = gr.Radio(["ltr", "rtl"], value="ltr", label="Reading Order")
            refine_panels = gr.Checkbox(value=False, label="Refine Panels (Trim Bubbles)")
    return min_panel_area, edge_sigma, low_threshold, high_threshold, reading_order, refine_panels


def create_demo():
    CSS = """
    .gradio-container { font-family: 'Segoe UI', Tahoma, sans-serif; }
    .hdr { text-align:center; background:linear-gradient(135deg,#667eea,#764ba2);
           color:#fff; padding:1.8rem; border-radius:10px; margin-bottom:1.2rem; }
    """
    with gr.Blocks(css=CSS, title="Manhwa Panel Extractor") as demo:
        gr.HTML("""
        <div class="hdr">
          <h1 style="margin:0;font-size:2rem;">🖼️ Manhwa Batch Extractor</h1>
          <p style="margin:.4rem 0 0;opacity:.9;">Extract panels from any manhwa/manga page — upload images or scrape directly from the web.</p>
        </div>
        """)
        if not SCRAPER_AVAILABLE:
            gr.Markdown("> Browser-based scraping is disabled in this Space build so the app stays lightweight and starts reliably. Batch uploads, HTML source parsing, and the API Hub still work.")

        with gr.Tabs():

            # ── Tab 1: Single Image ──────────────────────────────────────────
            with gr.TabItem("🖼️ Single Image"):
                with gr.Row():
                    with gr.Column():
                        s_img = gr.Image(label="Manhwa Page", type="pil", height=420)
                        s_sets = _settings_block()
                        with gr.Row():
                            s_samp = gr.Button("Load Sample", size="sm")
                            s_btn = gr.Button("Extract Panels ▶", variant="primary", size="lg")
                    with gr.Column():
                        s_stat = gr.Textbox(label="Status", interactive=False)
                        s_down = gr.File(label="⬇️ Download ZIP", interactive=False)
                        s_gal = gr.Gallery(label="Extracted Panels", columns=2, rows=3,
                                           height=550, object_fit="contain")

                s_btn.click(process_manhwa_image, inputs=[s_img] + list(s_sets),
                            outputs=[s_down, s_stat, s_gal])
                s_samp.click(load_sample, outputs=[s_img])

            # ── Tab 2: Batch Chapters ───────────────────────────────────────
            with gr.TabItem("📂 Batch Chapters"):
                gr.Markdown("""
### 📂 Chapter Batch Processor
Upload either:
- a single **chapter folder** of page images, or
- one **ZIP** that contains many chapter folders.

The output ZIP keeps the chapter folder layout and saves processed panels directly inside each chapter folder with continuous numbering. No page subfolders are created.
                """)
                with gr.Row():
                    with gr.Column():
                        b_folder = gr.File(file_count="directory", label="📁 Upload One Chapter Folder")
                        b_folder_name = gr.Textbox(
                            label="Chapter Folder Name",
                            value="chapter_001",
                            info="Used for folder uploads. ZIP uploads keep their own folder names.",
                        )
                        b_zip = gr.File(file_count="single", label="🗜️ Or Upload ZIP of Chapter Folders", file_types=[".zip"])
                        b_sets = _settings_block()
                        b_btn = gr.Button("Process Chapters ▶", variant="primary", size="lg")
                    with gr.Column():
                        b_stat = gr.Textbox(label="Status", interactive=False, lines=8)
                        b_down = gr.File(label="⬇️ Download Processed ZIP", interactive=False)

                b_btn.click(
                    process_chapter_batch,
                    inputs=[b_folder, b_folder_name, b_zip] + list(b_sets),
                    outputs=[b_down, b_stat],
                )

            # ── Tab 3: Web Downloader ────────────────────────────────────────
            with gr.TabItem("🌐 Download & Extract Series"):
                gr.Markdown("""
### 🌐 Scrape any Manga / Manhwa site
Paste the **series homepage** URL. Works with **TCB Scans, Kaynscan, OmegaScans, AsuraScans, MangaDex-style readers**, and most sites that scroll to reveal all images on one page.

> ⚠️ Sites that require you to click "Next Page" per image are not yet supported.
                """)
                if not SCRAPER_AVAILABLE:
                    gr.Markdown("> Browser scraping is unavailable in this build. Use the API Hub tab, or duplicate the Space with scraper dependencies if you want full site scraping.")
                with gr.Row():
                    c_url = gr.Textbox(label="Series URL",
                                       placeholder="https://tcbscanschapters.net/manga/one-piece/",
                                       scale=3)
                    c_strt = gr.Number(label="Start Chapter", value=1, precision=0, scale=1)
                    c_end = gr.Number(label="End Chapter", value=3, precision=0, scale=1)

                c_sets = _settings_block()

                with gr.Row():
                    c_btn_dl = gr.Button("⬇️ Just Download Raw Pages", variant="secondary", size="lg")
                    c_btn_ext = gr.Button("🚀 Download & Extract Panels", variant="primary", size="lg")

                c_stat = gr.Textbox(label="Log", interactive=False, lines=5)
                c_down = gr.File(label="⬇️ Download ZIP", interactive=False)

                c_btn_dl.click(download_only_series,
                               inputs=[c_url, c_strt, c_end] + list(c_sets),
                               outputs=[c_down, c_stat])
                c_btn_ext.click(download_and_extract_series,
                                inputs=[c_url, c_strt, c_end] + list(c_sets),
                                outputs=[c_down, c_stat])

            # ── Tab 4: Single Chapter Downloader ─────────────────────────────
            with gr.TabItem("📖 Single Chapter Scraper"):
                gr.Markdown("""
### 📖 Download or Extract a Single Chapter
Paste a direct **chapter URL** to fetch all images, or paste the page HTML source if the site blocks automation. You can then preview them, uncheck any unwanted pages (like sponsor pages or credits), and download or extract the final selection.
                """)
                if not SCRAPER_AVAILABLE:
                    gr.Markdown("> URL scraping is disabled here, but HTML source parsing still works. Open the chapter in your browser, choose `View Page Source`, and paste it below.")
                with gr.Row():
                    sc_url = gr.Textbox(label="Chapter URL", placeholder="https://site.com/manga/title/chapter-1/", scale=4)
                    sc_fetch = gr.Button("🔍 Fetch Images", variant="primary", scale=1)
                    
                with gr.Accordion("🛡️ Anti-Bot Bypass (For protected sites like Webtoonscan)", open=False):
                    gr.Markdown("If Cloudflare blocks the URL, open the chapter in your browser, **right-click -> View Page Source**, copy all text, and paste it here.")
                    sc_html = gr.Textbox(label="HTML Page Source", lines=4, placeholder="Paste entire HTML code here...")
                    
                sc_state = gr.State({})
                
                with gr.Row():
                    with gr.Column(scale=2):
                        sc_gal = gr.Gallery(label="Chapter Pages Preview", columns=3, rows=4, height=600, object_fit="contain", allow_preview=True)
                    with gr.Column(scale=1):
                        sc_stat = gr.Textbox(label="Status", interactive=False, lines=3)
                        sc_checks = gr.CheckboxGroup(label="Select Pages to Process", choices=[], visible=False)
                        
                sc_sets = _settings_block()
                
                with gr.Row():
                    sc_dl = gr.Button("⬇️ Download Selected Only", variant="secondary", size="lg")
                    sc_ext = gr.Button("🚀 Extract Panels from Selected", variant="primary", size="lg")
                    
                sc_down = gr.File(label="⬇️ Download ZIP", interactive=False)
                
                sc_fetch.click(
                    fn=fetch_chapter_images_only, 
                    inputs=[sc_url, sc_html], 
                    outputs=[sc_gal, sc_checks, sc_state, sc_stat]
                )
                sc_dl.click(
                    fn=download_selected_single, 
                    inputs=[sc_state, sc_checks], 
                    outputs=[sc_down, sc_stat]
                )
                sc_ext.click(
                    fn=extract_selected_single, 
                    inputs=[sc_state, sc_checks] + list(sc_sets), 
                    outputs=[sc_down, sc_stat]
                )

            # ── Tab 5: 📚 Built-in Manga Search Hub ──────────────────────────
            with gr.TabItem("📚 Built-in Manga Search Hub"):
                gr.Markdown("### 🔍 Search & Download API (100% Free & Cloudflare-Immune)\nSearch directly via MangaDex or Comick APIs. This bypasses all Cloudflare blocks natively.")
                with gr.Row():
                    hub_source = gr.Dropdown(["MangaDex", "Comick"], value="MangaDex", label="API Source", scale=1)
                    hub_query = gr.Textbox(label="Search Manga Title", placeholder="e.g. Solo Leveling", scale=3)
                    hub_btn_search = gr.Button("Search", variant="primary", scale=1)
                
                hub_manga_state = gr.State([])
                with gr.Row():
                    hub_manga_drop = gr.Dropdown(label="Select Series", choices=[], scale=4)
                    hub_btn_chaps = gr.Button("Load Chapters", scale=1)
                
                hub_chap_state = gr.State([])
                with gr.Row():
                    hub_chap_drop = gr.Dropdown(label="Select Chapter", choices=[], scale=4)
                    hub_btn_fetch = gr.Button("Fetch Images", variant="primary", scale=1)
                
                hub_state = gr.State({})
                
                with gr.Row():
                    with gr.Column(scale=2):
                        hub_gal = gr.Gallery(label="Chapter Pages Preview", columns=3, rows=4, height=600, object_fit="contain", allow_preview=True)
                    with gr.Column(scale=1):
                        hub_stat = gr.Textbox(label="Status", interactive=False, lines=3)
                        hub_checks = gr.CheckboxGroup(label="Select Pages to Process", choices=[], visible=False)
                        
                hub_sets = _settings_block()
                
                with gr.Row():
                    hub_dl = gr.Button("⬇️ Download Selected Only", variant="secondary", size="lg")
                    hub_ext = gr.Button("🚀 Extract Panels from Selected", variant="primary", size="lg")
                    
                hub_down = gr.File(label="⬇️ Download ZIP", interactive=False)
                
                hub_btn_search.click(hub_search, inputs=[hub_query, hub_source], outputs=[hub_manga_drop, hub_manga_state])
                hub_btn_chaps.click(hub_get_chapters, inputs=[hub_manga_drop, hub_manga_state, hub_source], outputs=[hub_chap_drop, hub_chap_state])
                hub_btn_fetch.click(hub_download_chapter, inputs=[hub_chap_drop, hub_chap_state, hub_source], outputs=[hub_gal, hub_checks, hub_state, hub_stat])
                hub_dl.click(download_selected_single, inputs=[hub_state, hub_checks], outputs=[hub_down, hub_stat])
                hub_ext.click(extract_selected_single, inputs=[hub_state, hub_checks] + list(hub_sets), outputs=[hub_down, hub_stat])

    return demo


if __name__ == "__main__":
    demo = create_demo()
    demo.launch(server_name="0.0.0.0", server_port=7860, share=False)