app.py

#!/usr/bin/env python3
"""
╔══════════════════════════════════════════════════════════════════════════════╗
║  ChatGPTGratuit API — Hugging Face Spaces Edition                          ║
║  Based on Ultimate Edition v5.0                                            ║
║  Deployed as a Docker Space on Hugging Face (Free Tier)                    ║
╚══════════════════════════════════════════════════════════════════════════════╝
"""

from __future__ import annotations

import re
import os
import sys
import json
import uuid
import time
import random
import string
import logging
import threading
from abc import ABC, abstractmethod
from collections import deque
from contextlib import contextmanager
from dataclasses import dataclass, field
from datetime import datetime, timezone
from enum import Enum, auto
from pathlib import Path
from typing import (
    Any, Deque, Dict, Generator, List, Optional, Tuple, Union
)
from urllib.parse import urlencode

import requests
from bs4 import BeautifulSoup

try:
    import yaml
    HAS_YAML = True
except ImportError:
    HAS_YAML = False

# ══════════════════════════════════════════════════════════════
#  CONSTANTS & ENUMS
# ══════════════════════════════════════════════════════════════

VERSION = "5.0.0-hf"
APP_NAME = "ChatGPTGratuit-API"
BASE_URL = "https://chatgptgratuit.org"


class SessionState(Enum):
    UNINITIALIZED = auto()
    READY = auto()
    DEGRADED = auto()
    EXPIRED = auto()
    FAILED = auto()


class ErrorCode(Enum):
    INIT_FAILED = "INIT_FAILED"
    NONCE_EXPIRED = "NONCE_EXPIRED"
    CACHE_FAILED = "CACHE_FAILED"
    STREAM_FAILED = "STREAM_FAILED"
    STREAM_EMPTY = "STREAM_EMPTY"
    RATE_LIMITED = "RATE_LIMITED"
    TIMEOUT = "TIMEOUT"
    PARSE_ERROR = "PARSE_ERROR"
    INVALID_INPUT = "INVALID_INPUT"
    CIRCUIT_OPEN = "CIRCUIT_OPEN"
    POOL_EXHAUSTED = "POOL_EXHAUSTED"
    UNKNOWN = "UNKNOWN"


class CircuitState(Enum):
    CLOSED = "closed"
    OPEN = "open"
    HALF_OPEN = "half_open"


USER_AGENTS: List[str] = [
    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/125.0.0.0 Safari/537.36",
    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36",
    "Mozilla/5.0 (Macintosh; Intel Mac OS X 14_5) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.5 Safari/605.1.15",
    "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:126.0) Gecko/20100101 Firefox/126.0",
    "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/125.0.0.0 Safari/537.36",
    "Mozilla/5.0 (Macintosh; Intel Mac OS X 14_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/125.0.0.0 Safari/537.36",
    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/125.0.0.0 Safari/537.36 Edg/125.0.0.0",
]

ACCEPT_LANGUAGES: List[str] = [
    "fr-FR,fr;q=0.9,en-US;q=0.8,en;q=0.7",
    "fr-FR,fr;q=0.9,en;q=0.8",
    "en-US,en;q=0.9,fr;q=0.8",
]

CONTROL_EVENTS: frozenset = frozenset({
    "done", "message_start", "openai_response_id",
    "error", "ping", "heartbeat", "keep-alive",
})


# ══════════════════════════════════════════════════════════════
#  LOGGING
# ══════════════════════════════════════════════════════════════

class PrettyFormatter(logging.Formatter):
    COLORS = {
        "DEBUG": "\033[36m", "INFO": "\033[32m",
        "WARNING": "\033[33m", "ERROR": "\033[31m",
        "CRITICAL": "\033[35m",
    }
    RESET = "\033[0m"
    ICONS = {
        "DEBUG": "🔍", "INFO": "✅", "WARNING": "⚠️ ",
        "ERROR": "❌", "CRITICAL": "💀",
    }

    def format(self, record: logging.LogRecord) -> str:
        color = self.COLORS.get(record.levelname, "")
        icon = self.ICONS.get(record.levelname, "")
        ts = datetime.now().strftime("%H:%M:%S.%f")[:-3]
        msg = record.getMessage()
        extra_parts = []
        for key in ("action", "duration_ms", "status_code", "cache_key"):
            val = getattr(record, key, None)
            if val is not None:
                extra_parts.append(f"{key}={val}")
        extra_str = f" [{', '.join(extra_parts)}]" if extra_parts else ""
        return f"{color}{ts} {icon} {msg}{extra_str}{self.RESET}"


def setup_logging(level: str = "INFO") -> logging.Logger:
    logger = logging.getLogger(APP_NAME)
    logger.setLevel(getattr(logging, level.upper(), logging.INFO))
    logger.handlers.clear()
    handler = logging.StreamHandler(sys.stderr)
    handler.setFormatter(PrettyFormatter())
    logger.addHandler(handler)
    return logger


log = setup_logging(os.environ.get("CGPT_LOG_LEVEL", "INFO"))


# ══════════════════════════════════════════════════════════════
#  CONFIGURATION
# ══════════════════════════════════════════════════════════════

@dataclass
class Config:
    base_url: str = BASE_URL
    timeout_init: int = 20
    timeout_cache: int = 30
    timeout_stream: int = 120
    max_retries: int = 3
    retry_backoff_base: float = 1.5
    retry_jitter: float = 0.5
    rate_limit_rpm: int = 15
    rate_limit_burst: int = 5
    pool_size: int = 2
    session_ttl: int = 1800
    max_history_messages: int = 50
    max_message_length: int = 10000
    cb_failure_threshold: int = 5
    cb_recovery_timeout: int = 60
    cb_half_open_max: int = 2
    host: str = "0.0.0.0"
    port: int = 7860
    debug: bool = False
    log_level: str = "INFO"
    json_logs: bool = False
    log_sse_raw: bool = False
    enable_metrics: bool = True
    enable_openai_compat: bool = True
    enable_cors: bool = True

    @classmethod
    def from_env(cls) -> "Config":
        cfg = cls()
        env_map = {
            "CGPT_BASE_URL": ("base_url", str),
            "CGPT_TIMEOUT": ("timeout_stream", int),
            "CGPT_MAX_RETRIES": ("max_retries", int),
            "CGPT_RATE_LIMIT": ("rate_limit_rpm", int),
            "CGPT_POOL_SIZE": ("pool_size", int),
            "CGPT_MAX_HISTORY": ("max_history_messages", int),
            "CGPT_HOST": ("host", str),
            "CGPT_PORT": ("port", int),
            "CGPT_DEBUG": ("debug", lambda x: x.lower() in ("1", "true", "yes")),
            "CGPT_LOG_LEVEL": ("log_level", str),
            "CGPT_JSON_LOGS": ("json_logs", lambda x: x.lower() in ("1", "true", "yes")),
        }
        for env_key, (attr, converter) in env_map.items():
            val = os.environ.get(env_key)
            if val is not None:
                try:
                    setattr(cfg, attr, converter(val))
                except (ValueError, TypeError):
                    log.warning(f"Invalid env var {env_key}={val}, using default")
        return cfg

    def validate(self) -> List[str]:
        warnings = []
        if self.pool_size < 1:
            self.pool_size = 1
            warnings.append("pool_size adjusted to minimum 1")
        if self.max_retries < 0:
            self.max_retries = 0
            warnings.append("max_retries adjusted to 0")
        if self.rate_limit_rpm < 1:
            self.rate_limit_rpm = 1
            warnings.append("rate_limit_rpm adjusted to minimum 1")
        if self.timeout_stream < 10:
            self.timeout_stream = 10
            warnings.append("timeout_stream adjusted to minimum 10s")
        return warnings


# ══════════════════════════════════════════════════════════════
#  EXCEPTIONS
# ══════════════════════════════════════════════════════════════

class ChatGPTGratuitError(Exception):
    def __init__(self, message: str, code: ErrorCode = ErrorCode.UNKNOWN,
                 details: Optional[Dict] = None):
        super().__init__(message)
        self.code = code
        self.details = details or {}

    def to_dict(self) -> Dict[str, Any]:
        return {"error": str(self), "code": self.code.value, "details": self.details}


class InitError(ChatGPTGratuitError):
    def __init__(self, msg="Session initialization failed", **kw):
        super().__init__(msg, ErrorCode.INIT_FAILED, **kw)


class NonceExpiredError(ChatGPTGratuitError):
    def __init__(self, msg="Nonce expired", **kw):
        super().__init__(msg, ErrorCode.NONCE_EXPIRED, **kw)


class CacheError(ChatGPTGratuitError):
    def __init__(self, msg="Cache operation failed", **kw):
        super().__init__(msg, ErrorCode.CACHE_FAILED, **kw)


class StreamError(ChatGPTGratuitError):
    def __init__(self, msg="Stream error", **kw):
        super().__init__(msg, ErrorCode.STREAM_FAILED, **kw)


class EmptyResponseError(ChatGPTGratuitError):
    def __init__(self, msg="Empty response from stream", **kw):
        super().__init__(msg, ErrorCode.STREAM_EMPTY, **kw)


class RateLimitError(ChatGPTGratuitError):
    def __init__(self, msg="Rate limit exceeded", **kw):
        super().__init__(msg, ErrorCode.RATE_LIMITED, **kw)


class CircuitOpenError(ChatGPTGratuitError):
    def __init__(self, msg="Circuit breaker is open", **kw):
        super().__init__(msg, ErrorCode.CIRCUIT_OPEN, **kw)


class InputValidationError(ChatGPTGratuitError):
    def __init__(self, msg="Invalid input", **kw):
        super().__init__(msg, ErrorCode.INVALID_INPUT, **kw)


# ══════════════════════════════════════════════════════════════
#  DATA MODELS
# ══════════════════════════════════════════════════════════════

@dataclass
class Message:
    role: str
    content: str
    timestamp: float = field(default_factory=time.time)
    message_id: str = field(default_factory=lambda: str(uuid.uuid4()))
    tokens_estimate: int = 0

    def __post_init__(self):
        self.tokens_estimate = max(1, len(self.content) // 4)


@dataclass
class Conversation:
    conversation_id: str = field(default_factory=lambda: str(uuid.uuid4()))
    messages: List[Message] = field(default_factory=list)
    created_at: float = field(default_factory=time.time)
    updated_at: float = field(default_factory=time.time)
    title: Optional[str] = None
    metadata: Dict[str, Any] = field(default_factory=dict)

    def add_message(self, role: str, content: str, max_messages: int = 50) -> Message:
        msg = Message(role=role, content=content)
        self.messages.append(msg)
        self.updated_at = time.time()
        if self.title is None and role == "user":
            self.title = content[:80] + ("..." if len(content) > 80 else "")
        if len(self.messages) > max_messages:
            system_msgs = [m for m in self.messages if m.role == "system"]
            other_msgs = [m for m in self.messages if m.role != "system"]
            keep = max_messages - len(system_msgs)
            self.messages = system_msgs + other_msgs[-keep:]
        return msg

    @property
    def total_tokens(self) -> int:
        return sum(m.tokens_estimate for m in self.messages)

    def to_dict(self) -> Dict:
        return {
            "conversation_id": self.conversation_id,
            "title": self.title,
            "message_count": len(self.messages),
            "total_tokens": self.total_tokens,
            "created_at": self.created_at,
            "updated_at": self.updated_at,
        }


@dataclass
class SessionInfo:
    nonce: Optional[str] = None
    bot_id: Optional[str] = None
    post_id: Optional[str] = None
    created_at: float = field(default_factory=time.time)
    last_used: float = field(default_factory=time.time)
    request_count: int = 0
    error_count: int = 0

    @property
    def is_valid(self) -> bool:
        return bool(self.nonce and self.bot_id)

    @property
    def age_seconds(self) -> float:
        return time.time() - self.created_at

    def mark_used(self):
        self.last_used = time.time()
        self.request_count += 1

    def mark_error(self):
        self.error_count += 1


# ══════════════════════════════════════════════════════════════
#  METRICS
# ══════════════════════════════════════════════════════════════

@dataclass
class Metrics:
    _lock: threading.Lock = field(default_factory=threading.Lock, repr=False)
    total_requests: int = 0
    successful_requests: int = 0
    failed_requests: int = 0
    total_retries: int = 0
    nonce_refreshes: int = 0
    total_chars_received: int = 0
    total_response_time_ms: float = 0.0
    active_streams: int = 0
    circuit_breaker_trips: int = 0
    _latencies: Deque[float] = field(default_factory=lambda: deque(maxlen=1000), repr=False)
    started_at: float = field(default_factory=time.time)

    def record_request(self, success: bool, duration_ms: float, chars: int = 0):
        with self._lock:
            self.total_requests += 1
            if success:
                self.successful_requests += 1
                self.total_chars_received += chars
            else:
                self.failed_requests += 1
            self.total_response_time_ms += duration_ms
            self._latencies.append(duration_ms)

    def record_retry(self):
        with self._lock:
            self.total_retries += 1

    def record_nonce_refresh(self):
        with self._lock:
            self.nonce_refreshes += 1

    def record_circuit_trip(self):
        with self._lock:
            self.circuit_breaker_trips += 1

    @property
    def avg_latency_ms(self) -> float:
        with self._lock:
            return sum(self._latencies) / len(self._latencies) if self._latencies else 0.0

    @property
    def p95_latency_ms(self) -> float:
        with self._lock:
            if not self._latencies:
                return 0.0
            s = sorted(self._latencies)
            return s[min(int(len(s) * 0.95), len(s) - 1)]

    @property
    def success_rate(self) -> float:
        with self._lock:
            return self.successful_requests / self.total_requests if self.total_requests else 1.0

    def to_dict(self) -> Dict[str, Any]:
        with self._lock:
            return {
                "total_requests": self.total_requests,
                "successful_requests": self.successful_requests,
                "failed_requests": self.failed_requests,
                "success_rate": round(self.success_rate, 4),
                "total_retries": self.total_retries,
                "nonce_refreshes": self.nonce_refreshes,
                "total_chars_received": self.total_chars_received,
                "avg_latency_ms": round(self.avg_latency_ms, 1),
                "p95_latency_ms": round(self.p95_latency_ms, 1),
                "active_streams": self.active_streams,
                "circuit_breaker_trips": self.circuit_breaker_trips,
                "uptime_seconds": round(time.time() - self.started_at, 1),
            }


metrics = Metrics()


# ══════════════════════════════════════════════════════════════
#  RATE LIMITER
# ══════════════════════════════════════════════════════════════

class RateLimiter:
    def __init__(self, rpm: int = 10, burst: int = 3):
        self.rate = rpm / 60.0
        self.max_tokens = float(burst)
        self.tokens = float(burst)
        self.last_refill = time.monotonic()
        self._lock = threading.Lock()

    def _refill(self):
        now = time.monotonic()
        self.tokens = min(self.max_tokens, self.tokens + (now - self.last_refill) * self.rate)
        self.last_refill = now

    def acquire(self, timeout: float = 30.0) -> bool:
        deadline = time.monotonic() + timeout
        while True:
            with self._lock:
                self._refill()
                if self.tokens >= 1.0:
                    self.tokens -= 1.0
                    return True
            if time.monotonic() >= deadline:
                return False
            time.sleep(min(1.0 / max(self.rate, 0.01), 0.5))

    @property
    def available_tokens(self) -> float:
        with self._lock:
            self._refill()
            return self.tokens


# ══════════════════════════════════════════════════════════════
#  CIRCUIT BREAKER
# ══════════════════════════════════════════════════════════════

class CircuitBreaker:
    def __init__(self, failure_threshold: int = 5, recovery_timeout: int = 60,
                 half_open_max: int = 2):
        self.failure_threshold = failure_threshold
        self.recovery_timeout = recovery_timeout
        self.half_open_max = half_open_max
        self.state = CircuitState.CLOSED
        self.failure_count = 0
        self.success_count = 0
        self.last_failure_time = 0.0
        self.half_open_attempts = 0
        self._lock = threading.Lock()

    def can_execute(self) -> bool:
        with self._lock:
            if self.state == CircuitState.CLOSED:
                return True
            if self.state == CircuitState.OPEN:
                if time.time() - self.last_failure_time >= self.recovery_timeout:
                    self.state = CircuitState.HALF_OPEN
                    self.half_open_attempts = 0
                    log.info("Circuit breaker → HALF_OPEN")
                    return True
                return False
            return self.half_open_attempts < self.half_open_max

    def record_success(self):
        with self._lock:
            if self.state == CircuitState.HALF_OPEN:
                self.success_count += 1
                if self.success_count >= self.half_open_max:
                    self.state = CircuitState.CLOSED
                    self.failure_count = 0
                    self.success_count = 0
                    log.info("Circuit breaker → CLOSED (recovered)")
            else:
                self.failure_count = max(0, self.failure_count - 1)

    def record_failure(self):
        with self._lock:
            self.failure_count += 1
            self.last_failure_time = time.time()
            if self.state == CircuitState.HALF_OPEN:
                self.state = CircuitState.OPEN
                metrics.record_circuit_trip()
                log.warning("Circuit breaker → OPEN (recovery failed)")
            elif self.failure_count >= self.failure_threshold:
                self.state = CircuitState.OPEN
                metrics.record_circuit_trip()
                log.warning(f"Circuit breaker → OPEN (failures={self.failure_count})")


# ══════════════════════════════════════════════════════════════
#  PLUGIN SYSTEM
# ══════════════════════════════════════════════════════════════

class ResponsePlugin(ABC):
    @property
    @abstractmethod
    def name(self) -> str: ...

    @abstractmethod
    def process(self, response: str, conversation: Conversation) -> str: ...


class StripWhitespacePlugin(ResponsePlugin):
    @property
    def name(self) -> str:
        return "strip_whitespace"

    def process(self, response: str, conversation: Conversation) -> str:
        return re.sub(r'\n{3,}', '\n\n', response).strip()


class PluginManager:
    def __init__(self):
        self._plugins: List[ResponsePlugin] = []

    def register(self, plugin: ResponsePlugin):
        self._plugins.append(plugin)

    def apply_all(self, response: str, conversation: Conversation) -> str:
        for plugin in self._plugins:
            try:
                response = plugin.process(response, conversation)
            except Exception as e:
                log.warning(f"Plugin {plugin.name} failed: {e}")
        return response


# ══════════════════════════════════════════════════════════════
#  WEBSITE PARSER
# ══════════════════════════════════════════════════════════════

class WebsiteParser:
    @staticmethod
    def parse(html: str) -> SessionInfo:
        info = SessionInfo()
        soup = BeautifulSoup(html, "html.parser")

        container = soup.find(class_="aipkit_chat_container")
        if container:
            config_str = container.get("data-config", "")
            if config_str:
                try:
                    config = json.loads(config_str)
                    info.nonce = config.get("nonce", "")
                    info.bot_id = str(config.get("botId", ""))
                    info.post_id = str(config.get("postId", ""))
                    if info.is_valid:
                        return info
                except json.JSONDecodeError:
                    pass

        if not info.bot_id:
            textarea = soup.find("textarea", id=re.compile(r"aipkit_chat_input_field_\d+"))
            if textarea:
                match = re.search(r"_(\d+)$", textarea.get("id", ""))
                if match:
                    info.bot_id = match.group(1)

        if not info.nonce:
            for pattern in [
                r'"nonce"\s*:\s*"([a-f0-9]{8,})"',
                r"'nonce'\s*:\s*'([a-f0-9]{8,})'",
                r'nonce["\s:=]+["\']([a-f0-9]{8,})',
            ]:
                match = re.search(pattern, html)
                if match:
                    info.nonce = match.group(1)
                    break

        if not info.bot_id:
            for pattern in [r'"botId"\s*:\s*"?(\d+)', r'"bot_id"\s*:\s*"?(\d+)']:
                match = re.search(pattern, html)
                if match:
                    info.bot_id = match.group(1)
                    break

        if not info.post_id:
            match = re.search(r'"postId"\s*:\s*"?(\d+)', html)
            info.post_id = match.group(1) if match else "7"

        return info


# ══════════════════════════════════════════════════════════════
#  SSE PARSER
# ══════════════════════════════════════════════════════════════

class SSEParser:
    @staticmethod
    def iter_events(response: requests.Response,
                    log_raw: bool = False) -> Generator[Tuple[str, str], None, None]:
        current_event = "message"
        data_buffer: List[str] = []

        for line in response.iter_lines(decode_unicode=True):
            if log_raw:
                log.debug(f"SSE RAW: {repr(line)}")
            if line is None:
                continue
            if not line:
                if data_buffer:
                    yield current_event, "\n".join(data_buffer)
                    data_buffer.clear()
                current_event = "message"
                continue
            if line.startswith("event:"):
                current_event = line[6:].strip()
            elif line.startswith("data:"):
                data_str = line[5:]
                if data_str.startswith(" "):
                    data_str = data_str[1:]
                data_buffer.append(data_str)
            elif line.startswith("id:") or line.startswith(":"):
                continue

        if data_buffer:
            yield current_event, "\n".join(data_buffer)

    @staticmethod
    def extract_text(data_str: str) -> str:
        try:
            data = json.loads(data_str)
            if isinstance(data, dict):
                if "delta" in data and isinstance(data["delta"], str):
                    return data["delta"]
                if "choices" in data and data["choices"]:
                    choice = data["choices"][0]
                    if "delta" in choice:
                        return choice["delta"].get("content", "")
                    if "message" in choice:
                        return choice["message"].get("content", "")
                for key in ("content", "text", "message", "data", "chunk", "response"):
                    if key in data and isinstance(data[key], str):
                        return data[key]
            if isinstance(data, str):
                return data
            return ""
        except (json.JSONDecodeError, TypeError):
            return data_str


# ══════════════════════════════════════════════════════════════
#  CORE CLIENT
# ══════════════════════════════════════════════════════════════

class ChatGPTGratuitClient:
    def __init__(self, config: Optional[Config] = None):
        self.config = config or Config.from_env()
        self._session = requests.Session()
        self._session_info = SessionInfo()
        self._state = SessionState.UNINITIALIZED
        self._guest_uuid = str(uuid.uuid4())
        self._lock = threading.Lock()

        self.rate_limiter = RateLimiter(
            rpm=self.config.rate_limit_rpm, burst=self.config.rate_limit_burst,
        )
        self.circuit_breaker = CircuitBreaker(
            failure_threshold=self.config.cb_failure_threshold,
            recovery_timeout=self.config.cb_recovery_timeout,
            half_open_max=self.config.cb_half_open_max,
        )
        self.plugin_manager = PluginManager()
        self.plugin_manager.register(StripWhitespacePlugin())

        self._conversations: Dict[str, Conversation] = {}
        self._active_conversation_id: Optional[str] = None
        self._rotate_identity()

    @property
    def state(self) -> SessionState:
        return self._state

    @property
    def is_ready(self) -> bool:
        return self._state in (SessionState.READY, SessionState.DEGRADED)

    @property
    def active_conversation(self) -> Conversation:
        if self._active_conversation_id not in self._conversations:
            conv = Conversation()
            self._conversations[conv.conversation_id] = conv
            self._active_conversation_id = conv.conversation_id
        return self._conversations[self._active_conversation_id]

    @property
    def session_info(self) -> SessionInfo:
        return self._session_info

    def _rotate_identity(self):
        ua = random.choice(USER_AGENTS)
        lang = random.choice(ACCEPT_LANGUAGES)
        self._session.headers.update({
            "User-Agent": ua,
            "Accept-Language": lang,
            "Referer": self.config.base_url + "/",
            "Origin": self.config.base_url,
            "DNT": "1",
            "Sec-Fetch-Dest": "empty",
            "Sec-Fetch-Mode": "cors",
            "Sec-Fetch-Site": "same-origin",
        })

    def init_session(self, force: bool = False) -> bool:
        with self._lock:
            if self.is_ready and not force:
                if self._session_info.age_seconds < self.config.session_ttl:
                    return True

            log.info("Initializing session...", extra={"action": "init_session"})
            self._rotate_identity()

            try:
                resp = self._session.get(self.config.base_url, timeout=self.config.timeout_init)
                resp.raise_for_status()
            except requests.RequestException as e:
                self._state = SessionState.FAILED
                log.error(f"Failed to load page: {e}")
                return False

            self._session_info = WebsiteParser.parse(resp.text)

            if self._session_info.is_valid:
                self._state = SessionState.READY
                log.info(
                    f"Session ready: bot_id={self._session_info.bot_id}, "
                    f"nonce={self._session_info.nonce[:8]}...",
                    extra={"action": "init_session", "bot_id": self._session_info.bot_id},
                )
            else:
                self._state = SessionState.DEGRADED
                log.warning(
                    f"Partial init: nonce={'✓' if self._session_info.nonce else '✗'}, "
                    f"bot_id={'✓' if self._session_info.bot_id else '✗'}"
                )

            return self._session_info.is_valid

    def refresh_nonce(self) -> bool:
        log.info("Refreshing nonce...")
        metrics.record_nonce_refresh()
        return self.init_session(force=True)

    def _ensure_session(self):
        if not self.is_ready:
            if not self.init_session():
                raise InitError()
        if self._session_info.age_seconds > self.config.session_ttl:
            self.refresh_nonce()

    def new_conversation(self, system_prompt: Optional[str] = None) -> Conversation:
        conv = Conversation()
        if system_prompt:
            conv.add_message("system", system_prompt, self.config.max_history_messages)
        self._conversations[conv.conversation_id] = conv
        self._active_conversation_id = conv.conversation_id
        return conv

    def get_conversation(self, conversation_id: str) -> Optional[Conversation]:
        return self._conversations.get(conversation_id)

    def list_conversations(self) -> List[Dict]:
        return [c.to_dict() for c in self._conversations.values()]

    def _generate_client_msg_id(self) -> str:
        ts = int(time.time() * 1000)
        rand = ''.join(random.choices(string.ascii_lowercase + string.digits, k=5))
        return f"aipkit-client-msg-{self._session_info.bot_id}-{ts}-{rand}"

    def _calculate_backoff(self, attempt: int) -> float:
        return self.config.retry_backoff_base ** attempt + random.uniform(0, self.config.retry_jitter)

    def send_message(
        self, message: str, *, stream: bool = False,
        conversation_id: Optional[str] = None,
        system_prompt: Optional[str] = None,
    ) -> Union[str, Generator[str, None, None]]:

        message = message.strip()
        if not message:
            raise InputValidationError("Message cannot be empty")
        if len(message) > self.config.max_message_length:
            raise InputValidationError(f"Message too long ({len(message)} chars)")

        if not self.circuit_breaker.can_execute():
            raise CircuitOpenError()

        if not self.rate_limiter.acquire(timeout=10.0):
            raise RateLimitError()

        self._ensure_session()

        if conversation_id and conversation_id in self._conversations:
            conv = self._conversations[conversation_id]
        else:
            conv = self.active_conversation

        if system_prompt and not any(m.role == "system" for m in conv.messages):
            conv.add_message("system", system_prompt, self.config.max_history_messages)

        conv.add_message("user", message, self.config.max_history_messages)

        last_error: Optional[Exception] = None
        start_time = time.monotonic()

        for attempt in range(self.config.max_retries + 1):
            try:
                if attempt > 0:
                    delay = self._calculate_backoff(attempt)
                    log.info(f"Retry {attempt}/{self.config.max_retries} after {delay:.1f}s")
                    metrics.record_retry()
                    time.sleep(delay)

                if stream:
                    gen = self._execute_stream(message, conv)
                    return self._wrap_stream_generator(gen, conv, start_time)
                else:
                    result = self._execute_blocking(message, conv)
                    duration = (time.monotonic() - start_time) * 1000
                    result = self.plugin_manager.apply_all(result, conv)
                    conv.add_message("assistant", result, self.config.max_history_messages)
                    metrics.record_request(True, duration, len(result))
                    self.circuit_breaker.record_success()
                    self._session_info.mark_used()
                    log.info(
                        f"Response received ({len(result)} chars)",
                        extra={"action": "send_message", "duration_ms": round(duration)},
                    )
                    return result

            except NonceExpiredError:
                log.warning("Nonce expired, refreshing...")
                self.refresh_nonce()
                last_error = NonceExpiredError()
            except (StreamError, EmptyResponseError, CacheError) as e:
                last_error = e
                self.circuit_breaker.record_failure()
                self._session_info.mark_error()
                log.warning(f"Attempt {attempt + 1} failed: {e}")
                if attempt < self.config.max_retries:
                    self.refresh_nonce()
            except requests.Timeout:
                last_error = ChatGPTGratuitError("Request timeout", ErrorCode.TIMEOUT)
                self.circuit_breaker.record_failure()
            except requests.RequestException as e:
                last_error = ChatGPTGratuitError(str(e), ErrorCode.UNKNOWN)
                self.circuit_breaker.record_failure()

        duration = (time.monotonic() - start_time) * 1000
        metrics.record_request(False, duration)
        if isinstance(last_error, ChatGPTGratuitError):
            raise last_error
        raise ChatGPTGratuitError(f"All attempts failed: {last_error}", ErrorCode.UNKNOWN)

    def _wrap_stream_generator(self, gen, conv, start_time):
        full_text = ""
        try:
            for chunk in gen:
                full_text += chunk
                yield chunk
            full_text = self.plugin_manager.apply_all(full_text, conv)
            conv.add_message("assistant", full_text, self.config.max_history_messages)
            duration = (time.monotonic() - start_time) * 1000
            metrics.record_request(True, duration, len(full_text))
            self.circuit_breaker.record_success()
            self._session_info.mark_used()
        except Exception:
            duration = (time.monotonic() - start_time) * 1000
            metrics.record_request(False, duration)
            self.circuit_breaker.record_failure()
            raise

    def _cache_message(self, message: str) -> str:
        info = self._session_info
        payload = {
            "action": "aipkit_cache_sse_message",
            "message": message,
            "_ajax_nonce": info.nonce,
            "bot_id": info.bot_id,
            "user_client_message_id": self._generate_client_msg_id(),
        }
        ajax_url = f"{self.config.base_url}/wp-admin/admin-ajax.php"
        resp = self._session.post(
            ajax_url, data=payload,
            headers={"X-Requested-With": "XMLHttpRequest", "Accept": "*/*"},
            timeout=self.config.timeout_cache,
        )
        if resp.status_code == 403 or (resp.status_code == 400 and "nonce" in resp.text.lower()):
            raise NonceExpiredError()
        try:
            data = resp.json()
        except json.JSONDecodeError:
            raise CacheError(f"Invalid JSON (HTTP {resp.status_code}): {resp.text[:200]}")
        if not data.get("success"):
            err_data = data.get("data", {})
            err_msg = err_data.get("message", str(err_data)) if isinstance(err_data, dict) else str(err_data)
            if "nonce" in err_msg.lower():
                raise NonceExpiredError()
            raise CacheError(f"Cache rejected: {err_msg}")
        return data["data"]["cache_key"]

    def _open_stream(self, cache_key: str, conv: Conversation) -> requests.Response:
        info = self._session_info
        ajax_url = f"{self.config.base_url}/wp-admin/admin-ajax.php"
        params = {
            "action": "aipkit_frontend_chat_stream",
            "cache_key": cache_key,
            "bot_id": info.bot_id,
            "session_id": self._guest_uuid,
            "conversation_uuid": conv.conversation_id,
            "post_id": info.post_id,
            "_ts": str(int(time.time() * 1000)),
            "_ajax_nonce": info.nonce,
        }
        resp = self._session.get(
            f"{ajax_url}?{urlencode(params)}",
            headers={"Accept": "text/event-stream", "Cache-Control": "no-cache", "Connection": "keep-alive"},
            timeout=self.config.timeout_stream,
            stream=True,
        )
        if resp.status_code == 403:
            raise NonceExpiredError()
        if resp.status_code != 200:
            raise StreamError(f"Stream HTTP {resp.status_code}")
        return resp

    def _execute_blocking(self, message: str, conv: Conversation) -> str:
        cache_key = self._cache_message(message)
        resp = self._open_stream(cache_key, conv)
        full_text = ""
        got_data = False
        for event_type, data_str in SSEParser.iter_events(resp, log_raw=self.config.log_sse_raw):
            got_data = True
            if data_str.strip() == "[DONE]":
                break
            if event_type == "error":
                raise StreamError(f"SSE error: {data_str}")
            if event_type in CONTROL_EVENTS:
                continue
            chunk = SSEParser.extract_text(data_str)
            if chunk:
                full_text += chunk
        if not got_data:
            raise EmptyResponseError()
        if not full_text.strip():
            raise EmptyResponseError("Stream completed but empty")
        return full_text

    def _execute_stream(self, message: str, conv: Conversation) -> Generator[str, None, None]:
        cache_key = self._cache_message(message)
        resp = self._open_stream(cache_key, conv)
        metrics.active_streams += 1
        try:
            for event_type, data_str in SSEParser.iter_events(resp, log_raw=self.config.log_sse_raw):
                if data_str.strip() == "[DONE]":
                    break
                if event_type == "error":
                    raise StreamError(f"SSE error: {data_str}")
                if event_type in CONTROL_EVENTS:
                    continue
                chunk = SSEParser.extract_text(data_str)
                if chunk:
                    yield chunk
        finally:
            metrics.active_streams = max(0, metrics.active_streams - 1)

    def get_status(self) -> Dict[str, Any]:
        return {
            "version": VERSION,
            "state": self._state.name,
            "session": {
                "bot_id": self._session_info.bot_id,
                "has_nonce": bool(self._session_info.nonce),
                "post_id": self._session_info.post_id,
                "age_seconds": round(self._session_info.age_seconds, 1),
                "request_count": self._session_info.request_count,
                "error_count": self._session_info.error_count,
            },
            "circuit_breaker": self.circuit_breaker.state.value,
            "rate_limiter_tokens": round(self.rate_limiter.available_tokens, 2),
            "metrics": metrics.to_dict(),
        }


# ══════════════════════════════════════════════════════════════
#  SESSION POOL
# ══════════════════════════════════════════════════════════════

class SessionPool:
    def __init__(self, config: Config):
        self.config = config
        self._clients: List[ChatGPTGratuitClient] = []
        self._index = 0
        self._lock = threading.Lock()
        for i in range(config.pool_size):
            self._clients.append(ChatGPTGratuitClient(config))

    def initialize_all(self) -> int:
        success = 0
        for i, client in enumerate(self._clients):
            try:
                if client.init_session():
                    success += 1
                    log.info(f"Pool client {i+1} initialized")
            except Exception as e:
                log.error(f"Pool client {i+1} init error: {e}")
        return success

    @contextmanager
    def acquire(self) -> Generator[ChatGPTGratuitClient, None, None]:
        with self._lock:
            attempts = len(self._clients)
            for _ in range(attempts):
                client = self._clients[self._index % len(self._clients)]
                self._index += 1
                if client.is_ready or client.state == SessionState.UNINITIALIZED:
                    break
            else:
                client = self._clients[0]
        yield client

    def get_status(self) -> Dict:
        return {
            "pool_size": len(self._clients),
            "clients": [
                {"index": i, "state": c.state.name, "requests": c.session_info.request_count}
                for i, c in enumerate(self._clients)
            ],
        }


# ══════════════════════════════════════════════════════════════
#  FLASK APP FACTORY
# ══════════════════════════════════════════════════════════════

def create_app(config: Optional[Config] = None) -> Tuple:
    from flask import Flask, request as freq, jsonify, Response, stream_with_context

    config = config or Config.from_env()
    app = Flask(APP_NAME)

    pool = SessionPool(config)
    ready_count = pool.initialize_all()
    if ready_count == 0:
        log.warning("No pool clients initialized! Will retry on first request.")

    if config.enable_cors:
        @app.after_request
        def add_cors(response):
            response.headers["Access-Control-Allow-Origin"] = "*"
            response.headers["Access-Control-Allow-Headers"] = "Content-Type, Authorization"
            response.headers["Access-Control-Allow-Methods"] = "GET, POST, OPTIONS"
            return response

    @app.errorhandler(ChatGPTGratuitError)
    def handle_api_error(e: ChatGPTGratuitError):
        status_map = {
            ErrorCode.RATE_LIMITED: 429,
            ErrorCode.INVALID_INPUT: 400,
            ErrorCode.CIRCUIT_OPEN: 503,
        }
        return jsonify({"ok": False, **e.to_dict()}), status_map.get(e.code, 500)

    @app.errorhandler(404)
    def not_found(e):
        return jsonify({
            "ok": False, "error": "Endpoint not found",
            "endpoints": [
                "POST /chat", "POST /chat/stream", "POST /v1/chat/completions",
                "POST /new", "POST /refresh", "GET /health", "GET /metrics",
            ],
        }), 404

    # ── Landing page ──
    @app.route("/", methods=["GET"])
    def index():
        return jsonify({
            "name": APP_NAME,
            "version": VERSION,
            "status": "running",
            "endpoints": {
                "chat": "POST /chat",
                "stream": "POST /chat/stream",
                "openai_compat": "POST /v1/chat/completions",
                "health": "GET /health",
                "metrics": "GET /metrics",
                "new_conversation": "POST /new",
                "refresh_session": "POST /refresh",
                "conversations": "GET /conversations",
            },
            "usage_example": {
                "curl": 'curl -X POST /chat -H "Content-Type: application/json" -d \'{"message": "Hello!"}\'',
            },
        })

    # ── POST /chat ──
    @app.route("/chat", methods=["POST"])
    def chat():
        data = freq.get_json(force=True, silent=True) or {}
        message = data.get("message", "").strip()
        if not message:
            return jsonify({"ok": False, "error": "Field 'message' is required"}), 400

        with pool.acquire() as client:
            if data.get("new_conversation"):
                client.new_conversation(data.get("system_prompt"))
            response_text = client.send_message(message, system_prompt=data.get("system_prompt"))
            return jsonify({
                "ok": True,
                "response": response_text,
                "conversation_id": client.active_conversation.conversation_id,
                "usage": {
                    "message_count": len(client.active_conversation.messages),
                    "estimated_tokens": client.active_conversation.total_tokens,
                },
            })

    # ── POST /chat/stream ──
    @app.route("/chat/stream", methods=["POST"])
    def chat_stream():
        data = freq.get_json(force=True, silent=True) or {}
        message = data.get("message", "").strip()
        if not message:
            return jsonify({"ok": False, "error": "Field 'message' is required"}), 400

        with pool.acquire() as client:
            if data.get("new_conversation"):
                client.new_conversation(data.get("system_prompt"))

            def generate():
                try:
                    for chunk in client.send_message(message, stream=True):
                        yield f"data: {json.dumps({'chunk': chunk}, ensure_ascii=False)}\n\n"
                    yield "data: [DONE]\n\n"
                except ChatGPTGratuitError as e:
                    yield f"data: {json.dumps(e.to_dict())}\n\n"
                except Exception as e:
                    yield f"data: {json.dumps({'error': str(e)})}\n\n"

            return Response(
                stream_with_context(generate()),
                content_type="text/event-stream",
                headers={"Cache-Control": "no-cache", "X-Accel-Buffering": "no"},
            )

    # ── POST /v1/chat/completions (OpenAI-compatible) ──
    if config.enable_openai_compat:
        @app.route("/v1/chat/completions", methods=["POST"])
        def openai_compat():
            data = freq.get_json(force=True, silent=True) or {}
            messages = data.get("messages", [])
            do_stream = data.get("stream", False)

            if not messages:
                return jsonify({"error": {"message": "messages required"}}), 400

            user_msg = None
            system_prompt = None
            for msg in messages:
                if msg.get("role") == "user":
                    user_msg = msg.get("content", "")
                if msg.get("role") == "system":
                    system_prompt = msg.get("content")

            if not user_msg:
                return jsonify({"error": {"message": "No user message found"}}), 400

            response_id = f"chatcmpl-{uuid.uuid4().hex[:24]}"
            created = int(time.time())

            with pool.acquire() as client:
                if do_stream:
                    def generate():
                        try:
                            for chunk in client.send_message(
                                user_msg, stream=True, system_prompt=system_prompt
                            ):
                                yield f"data: {json.dumps({'id': response_id, 'object': 'chat.completion.chunk', 'created': created, 'model': 'chatgpt-gratuit', 'choices': [{'index': 0, 'delta': {'content': chunk}, 'finish_reason': None}]})}\n\n"
                            yield f"data: {json.dumps({'id': response_id, 'object': 'chat.completion.chunk', 'created': created, 'model': 'chatgpt-gratuit', 'choices': [{'index': 0, 'delta': {}, 'finish_reason': 'stop'}]})}\n\n"
                            yield "data: [DONE]\n\n"
                        except Exception as e:
                            yield f"data: {json.dumps({'error': {'message': str(e)}})}\n\n"

                    return Response(
                        stream_with_context(generate()),
                        content_type="text/event-stream",
                        headers={"Cache-Control": "no-cache", "X-Accel-Buffering": "no"},
                    )

                response_text = client.send_message(user_msg, system_prompt=system_prompt)
                return jsonify({
                    "id": response_id,
                    "object": "chat.completion",
                    "created": created,
                    "model": "chatgpt-gratuit",
                    "choices": [{
                        "index": 0,
                        "message": {"role": "assistant", "content": response_text},
                        "finish_reason": "stop",
                    }],
                    "usage": {
                        "prompt_tokens": len(user_msg) // 4,
                        "completion_tokens": len(response_text) // 4,
                        "total_tokens": (len(user_msg) + len(response_text)) // 4,
                    },
                })

    # ── POST /new ──
    @app.route("/new", methods=["POST"])
    def new_conv():
        data = freq.get_json(force=True, silent=True) or {}
        with pool.acquire() as client:
            conv = client.new_conversation(data.get("system_prompt"))
            return jsonify({"ok": True, "conversation_id": conv.conversation_id})

    # ── POST /refresh ──
    @app.route("/refresh", methods=["POST"])
    def refresh():
        with pool.acquire() as client:
            result = client.refresh_nonce()
            return jsonify({
                "ok": result,
                "nonce_prefix": client.session_info.nonce[:8] + "..." if client.session_info.nonce else None,
            })

    # ── GET /health ──
    @app.route("/health", methods=["GET"])
    def health():
        with pool.acquire() as client:
            status = client.get_status()
            status["pool"] = pool.get_status()
            return jsonify(status), 200 if client.is_ready else 503

    # ── GET /metrics ──
    if config.enable_metrics:
        @app.route("/metrics", methods=["GET"])
        def metrics_endpoint():
            return jsonify(metrics.to_dict())

    # ── GET /conversations ──
    @app.route("/conversations", methods=["GET"])
    def conversations():
        with pool.acquire() as client:
            return jsonify({
                "ok": True,
                "conversations": client.list_conversations(),
                "active": client._active_conversation_id,
            })

    # ── GET /conversation/<id>/messages ──
    @app.route("/conversation/<conv_id>/messages", methods=["GET"])
    def conversation_messages(conv_id: str):
        with pool.acquire() as client:
            conv = client.get_conversation(conv_id)
            if not conv:
                return jsonify({"ok": False, "error": "Conversation not found"}), 404
            return jsonify({
                "ok": True,
                "conversation": conv.to_dict(),
                "messages": [
                    {"role": m.role, "content": m.content, "timestamp": m.timestamp, "message_id": m.message_id}
                    for m in conv.messages
                ],
            })

    return app, pool


# ══════════════════════════════════════════════════════════════
#  GUNICORN ENTRY POINT + DIRECT RUN
# ══════════════════════════════════════════════════════════════

config = Config.from_env()
config.validate()

# Gunicorn looks for 'application'
application, _pool = create_app(config)

if __name__ == "__main__":
    print(f"""
╔══════════════════════════════════════════════════════════════╗
║  🚀 ChatGPT Gratuit API v{VERSION:<38s}║
║  Server: http://{config.host}:{config.port:<43d}║
║                                                              ║
║  POST /chat                 → Complete response              ║
║  POST /chat/stream          → Streaming SSE                  ║
║  POST /v1/chat/completions  → OpenAI-compatible              ║
║  GET  /health               → Health check                   ║
║  GET  /metrics              → Metrics                        ║
╚══════════════════════════════════════════════════════════════╝
""")
    application.run(host=config.host, port=config.port, debug=config.debug, threaded=True)