from falkordb import FalkorDB

# Remote (existing, unchanged)
db = FalkorDB(host='localhost', port=6379)

# Embedded — zero config (ephemeral)
db = FalkorDB(embedded=True)

# Embedded — with persistence
db = FalkorDB(embedded=True, db_path='/tmp/my_graph.db')

# Embedded — custom config + standard kwargs
db = FalkorDB(
    embedded=True,
    db_path='/tmp/my_graph.db',
    embedded_config={'maxmemory': '1gb'},
    max_connections=32,
    socket_timeout=30,
    encoding='utf-8',
)

# Usage is identical from here on
g = db.select_graph('social')
g.query('CREATE (n:Person {name: "Alice"}) RETURN n')

# Cleanup (stops the embedded server)
db.close()

from falkordb.asyncio import FalkorDB as AsyncFalkorDB

# Async embedded
db = AsyncFalkorDB(embedded=True, db_path='/tmp/async_graph.db')
g = db.select_graph('social')
result = await g.query('MATCH (n) RETURN n')
await db.close()

from falkordb import FalkorDB

with FalkorDB(embedded=True, db_path='/tmp/my_graph.db') as db:
    g = db.select_graph('social')
    g.query('CREATE (n:Person {name: "Alice"}) RETURN n')
# Server automatically stopped on exit

import os
import sys
import platform

def get_bin_dir():
    """Return path to directory containing redis-server and falkordb.so/dylib"""
    return os.path.join(os.path.dirname(__file__), 'bin')

def get_redis_server():
    """Return path to redis-server binary"""
    name = 'redis-server.exe' if sys.platform == 'win32' else 'redis-server'
    return os.path.join(get_bin_dir(), name)

def get_falkordb_module():
    """Return path to falkordb module (falkordb.so on Linux, falkordb.dylib on macOS)"""
    if sys.platform == 'darwin':
        name = 'falkordb.dylib'
    else:
        name = 'falkordb.so'
    return os.path.join(get_bin_dir(), name)

"""
Embedded FalkorDB support.

This module is only usable when the 'lite' extra is installed:
    pip install falkordb[lite]
"""

"""Binary resolution — finds redis-server and falkordb.so from falkordb-bin package."""

import shutil
from pathlib import Path


class BinaryNotFoundError(Exception):
    """Raised when embedded binaries are not installed."""
    pass


def _require_bin():
    """Check that falkordb-bin is installed, raise helpful error if not."""
    try:
        import falkordb_bin
        return falkordb_bin
    except ImportError:
        raise BinaryNotFoundError(
            "Embedded FalkorDB requires the 'lite' extra. "
            "Install with: pip install falkordb[lite]"
        )


def get_redis_server_path() -> Path:
    """Resolve path to redis-server binary."""
    falkordb_bin = _require_bin()
    path = Path(falkordb_bin.get_redis_server())
    if not path.exists():
        raise BinaryNotFoundError(f"redis-server not found at {path}")
    return path


def get_falkordb_module_path() -> Path:
    """Resolve path to falkordb.so module."""
    falkordb_bin = _require_bin()
    path = Path(falkordb_bin.get_falkordb_module())
    if not path.exists():
        raise BinaryNotFoundError(f"falkordb.so not found at {path}")
    return path

"""Redis configuration generation for embedded mode."""

import os
import tempfile
from pathlib import Path


DEFAULT_CONFIG = {
    'bind': '127.0.0.1',
    'port': '0',                    # 0 = auto-assign port
    'save': '',                     # Disable RDB by default for ephemeral
    'appendonly': 'no',
    'protected-mode': 'yes',
    'loglevel': 'warning',
    'databases': '16',
}

PERSISTENT_OVERRIDES = {
    'save': '900 1 300 10 60 10000',  # RDB snapshots
    'appendonly': 'yes',
    'appendfsync': 'everysec',
}


def generate_config(
    falkordb_module_path: Path,
    db_path: str | None = None,
    unix_socket_path: str | None = None,
    user_config: dict | None = None,
) -> str:
    """Generate redis.conf content for embedded mode."""

    config = dict(DEFAULT_CONFIG)

    # If persistence requested, set dir and enable AOF/RDB
    if db_path:
        db_dir = os.path.dirname(os.path.abspath(db_path))
        db_file = os.path.basename(db_path)
        os.makedirs(db_dir, exist_ok=True)
        config['dir'] = db_dir
        config['dbfilename'] = db_file
        config.update(PERSISTENT_OVERRIDES)

    # Unix socket for local communication (preferred over TCP)
    if unix_socket_path:
        config['unixsocket'] = unix_socket_path
        config['unixsocketperm'] = '700'
        config['port'] = '0'  # Disable TCP when using socket

    # Load FalkorDB module
    config['loadmodule'] = str(falkordb_module_path)

    # Apply user overrides
    if user_config:
        config.update(user_config)

    # Render
    lines = [f'{k} {v}' for k, v in config.items()]
    return '\n'.join(lines) + '\n'

"""Embedded redis-server lifecycle management."""

import atexit
import os
import subprocess
import tempfile
import time
from pathlib import Path

import redis

from .binaries import get_redis_server_path, get_falkordb_module_path
from .config import generate_config


class EmbeddedServerError(Exception):
    pass


class EmbeddedServer:
    """Manages a local redis-server + FalkorDB process."""

    def __init__(
        self,
        db_path: str | None = None,
        config: dict | None = None,
        startup_timeout: float = 10.0,
    ):
        self._process: subprocess.Popen | None = None
        self._tmpdir = tempfile.mkdtemp(prefix='falkordb_')
        self._socket_path = os.path.join(self._tmpdir, 'falkordb.sock')
        self._config_path = os.path.join(self._tmpdir, 'redis.conf')
        self._db_path = db_path
        self._startup_timeout = startup_timeout

        # Resolve binaries
        self._redis_server = get_redis_server_path()
        self._falkordb_module = get_falkordb_module_path()

        # Generate config
        config_content = generate_config(
            falkordb_module_path=self._falkordb_module,
            db_path=db_path,
            unix_socket_path=self._socket_path,
            user_config=config,
        )
        Path(self._config_path).write_text(config_content)

        # Start server
        self._start()

        # Ensure cleanup on exit
        atexit.register(self.stop)

    def _start(self):
        """Start the redis-server process and wait for it to be ready."""
        self._process = subprocess.Popen(
            [str(self._redis_server), self._config_path],
            stdout=subprocess.PIPE,
            stderr=subprocess.PIPE,
        )

        # Wait for socket to appear and server to respond
        deadline = time.monotonic() + self._startup_timeout
        while time.monotonic() < deadline:
            if self._process.poll() is not None:
                stderr = self._process.stderr.read().decode()
                raise EmbeddedServerError(
                    f"redis-server exited with code {self._process.returncode}: {stderr}"
                )
            if os.path.exists(self._socket_path):
                try:
                    r = redis.Redis(unix_socket_path=self._socket_path)
                    r.ping()
                    r.close()
                    return
                except redis.ConnectionError:
                    pass
            time.sleep(0.05)

        self.stop()
        raise EmbeddedServerError(
            f"redis-server did not start within {self._startup_timeout}s"
        )

    @property
    def unix_socket_path(self) -> str:
        return self._socket_path

    def stop(self):
        """Gracefully shut down the embedded server."""
        if self._process and self._process.poll() is None:
            try:
                r = redis.Redis(unix_socket_path=self._socket_path)
                r.shutdown(nosave=not bool(self._db_path))
                r.close()
            except Exception:
                self._process.terminate()
            try:
                self._process.wait(timeout=5)
            except subprocess.TimeoutExpired:
                self._process.kill()
        self._process = None

    def __del__(self):
        self.stop()

class FalkorDB:
    """FalkorDB client — connects to remote or embedded server."""

    def __init__(
        self,
        host="localhost",
        port=6379,
        password=None,
        socket_timeout=None,
        socket_connect_timeout=None,
        socket_keepalive=None,
        socket_keepalive_options=None,
        connection_pool=None,
        unix_socket_path=None,
        encoding="utf-8",
        encoding_errors="strict",
        retry_on_error=None,
        ssl=False,
        # ... other existing params ...
        #
        # ── NEW embedded params ──
        embedded=False,
        db_path=None,
        embedded_config=None,
        max_connections=16,
        startup_timeout=10.0,
    ):
        self._embedded_server = None

        if embedded:
            # Lazy import — only loaded when embedded=True
            from .lite.server import EmbeddedServer

            server = EmbeddedServer(
                db_path=db_path,
                config=embedded_config,
                startup_timeout=startup_timeout,
            )
            self._embedded_server = server

            # Override connection to use Unix socket with pooling
            unix_socket_path = server.unix_socket_path
            connection_pool = redis.ConnectionPool(
                connection_class=redis.UnixDomainSocketConnection,
                path=unix_socket_path,
                max_connections=max_connections,
                decode_responses=True,
                socket_timeout=socket_timeout,
                socket_connect_timeout=socket_connect_timeout,
                encoding=encoding,
                encoding_errors=encoding_errors,
                retry_on_error=retry_on_error or [],
            )

        # ... existing __init__ logic using connection_pool or host/port ...

    def close(self):
        """Close the connection. If embedded, also stops the server."""
        if self._embedded_server:
            self._embedded_server.stop()
            self._embedded_server = None

    def __enter__(self):
        return self

    def __exit__(self, *args):
        self.close()

    def __del__(self):
        self.close()

import redis.asyncio

class FalkorDB:
    # ... existing async FalkorDB ...

    def __init__(
        self,
        # ... existing params ...
        embedded=False,
        db_path=None,
        embedded_config=None,
        max_connections=16,
        startup_timeout=10.0,
    ):
        self._embedded_server = None

        if embedded:
            from ..lite.server import EmbeddedServer

            # Server start is synchronous (subprocess), but fast
            server = EmbeddedServer(
                db_path=db_path,
                config=embedded_config,
                startup_timeout=startup_timeout,
            )
            self._embedded_server = server

            # Create async connection pool over Unix socket
            connection_pool = redis.asyncio.BlockingConnectionPool(
                connection_class=redis.asyncio.UnixDomainSocketConnection,
                path=server.unix_socket_path,
                max_connections=max_connections,
                timeout=None,
                decode_responses=True,
            )
            # Pass pool to existing init logic...

    async def close(self):
        """Close async connection and stop embedded server if applicable."""
        # Close the connection pool
        if hasattr(self, 'connection') and self.connection:
            await self.connection.aclose()
        if self._embedded_server:
            self._embedded_server.stop()
            self._embedded_server = None

    async def __aenter__(self):
        return self

    async def __aexit__(self, *args):
        await self.close()

# BEFORE (falkordblite)
from redislite.falkordb_client import FalkorDB
db = FalkorDB('/tmp/falkordb.db')
g = db.select_graph('social')
g.query('CREATE (n:Person {name: "Alice"}) RETURN n')

# AFTER (falkordb[lite])
from falkordb import FalkorDB
db = FalkorDB(embedded=True, db_path='/tmp/falkordb.db')
g = db.select_graph('social')
g.query('CREATE (n:Person {name: "Alice"}) RETURN n')

FalkorDB(embedded=True)                                   # ephemeral (no RDB/AOF)
FalkorDB(embedded=True, db_path='/tmp/my.db')             # persistent

# Default pool (16 connections)
db = FalkorDB(embedded=True)

# Custom pool size
db = FalkorDB(embedded=True, max_connections=32)