# syntax=docker/dockerfile:1.7
FROM python:3.12-slim

ARG TARGETARCH
ARG DUCKDB_VERSION=1.5.4
ARG QUACKTUI_VERSION=0.1.1

ENV PYTHONDONTWRITEBYTECODE=1 \
    PYTHONUNBUFFERED=1 \
    PIP_DISABLE_PIP_VERSION_CHECK=1 \
    MINIO_ROOT_USER=minioadmin \
    MINIO_ROOT_PASSWORD=minioadmin \
    QUACKTUI_TEST_MINIO_KEY=minioadmin \
    QUACKTUI_TEST_MINIO_SECRET=minioadmin

RUN apt-get update \
    && apt-get install -y --no-install-recommends \
        curl ca-certificates unzip \
    && rm -rf /var/lib/apt/lists/*

RUN set -eux; \
    ARCH="${TARGETARCH:-$(dpkg --print-architecture)}"; \
    case "$ARCH" in \
        amd64) MINIO_ARCH=amd64; DUCKDB_ARCH=amd64 ;; \
        arm64) MINIO_ARCH=arm64; DUCKDB_ARCH=arm64 ;; \
        *) echo "unsupported arch: $ARCH" >&2; exit 1 ;; \
    esac; \
    curl -fsSL "https://dl.min.io/server/minio/release/linux-${MINIO_ARCH}/minio" \
        -o /usr/local/bin/minio; \
    chmod +x /usr/local/bin/minio; \
    curl -fsSL "https://dl.min.io/client/mc/release/linux-${MINIO_ARCH}/mc" \
        -o /usr/local/bin/mc; \
    chmod +x /usr/local/bin/mc; \
    curl -fsSL "https://github.com/duckdb/duckdb/releases/download/v${DUCKDB_VERSION}/duckdb_cli-linux-${DUCKDB_ARCH}.zip" \
        -o /tmp/duckdb.zip; \
    unzip -q /tmp/duckdb.zip -d /usr/local/bin; \
    rm /tmp/duckdb.zip; \
    chmod +x /usr/local/bin/duckdb

RUN pip install --no-cache-dir "quacktui==${QUACKTUI_VERSION}"

RUN mkdir -p /opt/quacktui /var/minio

RUN cat > /opt/quacktui/seed.sql <<'EOF'
CREATE TABLE IF NOT EXISTS demo_small (
    id INTEGER,
    name VARCHAR,
    value DOUBLE
);

INSERT INTO demo_small
SELECT
    i AS id,
    'name_' || i AS name,
    (i * 1.5) AS value
FROM generate_series(1, 100) AS s(i);

CREATE TABLE IF NOT EXISTS demo_medium (
    id INTEGER,
    name VARCHAR,
    value DOUBLE,
    created_at TIMESTAMP
);

INSERT INTO demo_medium
SELECT
    i AS id,
    'row_' || i AS name,
    (i % 1000) * 0.25 AS value,
    TIMESTAMP '2024-01-01 00:00:00' + INTERVAL (i) MINUTE AS created_at
FROM generate_series(1, 5000) AS s(i);

CREATE TABLE IF NOT EXISTS demo_partitioned (
    id INTEGER,
    category VARCHAR,
    value DOUBLE,
    event_date DATE
);

ALTER TABLE demo_partitioned SET PARTITIONED BY (category);

INSERT INTO demo_partitioned
SELECT
    i AS id,
    CASE (i % 4)
        WHEN 0 THEN 'alpha'
        WHEN 1 THEN 'beta'
        WHEN 2 THEN 'gamma'
        ELSE 'delta'
    END AS category,
    (i * 0.1) AS value,
    DATE '2024-01-01' + INTERVAL (i % 30) DAY AS event_date
FROM generate_series(1, 1000) AS s(i);
EOF

RUN cat > /opt/quacktui/connections.toml.default <<'EOF'
[settings]
default_limit = 10000
log_level = "INFO"

[[connections]]
name = "duckdb-demo"
read_only = false

[connections.catalog]
type = "duckdb"
connection_string = "/root/.local/share/quacktui/demo-catalog.duckdb"

[connections.storage]
data_path = "s3://ducklake-data/duckdb-demo/"
endpoint_url = "http://127.0.0.1:9000"
region = "us-east-1"
use_ssl = false
url_style = "path"
access_key_env = "QUACKTUI_TEST_MINIO_KEY"
secret_key_env = "QUACKTUI_TEST_MINIO_SECRET"
EOF

RUN cat > /opt/quacktui/seed_catalog.py <<'EOF'
from __future__ import annotations

import sys
from pathlib import Path

from quacktui.config import CatalogConfig, ConnectionConfig, S3Config
from quacktui.lake import LakeConnection

CATALOG_PATH = Path("/root/.local/share/quacktui/demo-catalog.duckdb")
SEED_SQL = Path("/opt/quacktui/seed.sql")


def main() -> int:
    if CATALOG_PATH.exists():
        print(f"[seed] catalog already exists at {CATALOG_PATH}, skipping")
        return 0

    CATALOG_PATH.parent.mkdir(parents=True, exist_ok=True)
    config = ConnectionConfig(
        name="duckdb-demo",
        catalog=CatalogConfig(type="duckdb", connection_string=str(CATALOG_PATH)),
        storage=S3Config(
            data_path="s3://ducklake-data/duckdb-demo/",
            endpoint_url="http://127.0.0.1:9000",
            region="us-east-1",
            use_ssl=False,
            url_style="path",
            access_key_env="QUACKTUI_TEST_MINIO_KEY",
            secret_key_env="QUACKTUI_TEST_MINIO_SECRET",
        ),
        read_only=False,
    )

    conn = LakeConnection(config)
    conn.open()
    try:
        for stmt in (s.strip() for s in SEED_SQL.read_text().split(";") if s.strip()):
            conn.execute(stmt)
    finally:
        conn.close()
    print(f"[seed] catalog seeded at {CATALOG_PATH}")
    return 0


if __name__ == "__main__":
    sys.exit(main())
EOF

RUN cat > /entrypoint.sh <<'EOF'
#!/usr/bin/env bash
set -euo pipefail

mkdir -p /root/.config/quacktui \
         /root/.local/share/quacktui \
         /root/.local/state/quacktui \
         /var/minio

minio server /var/minio --console-address ":9001" >/var/log/minio.log 2>&1 &
MINIO_PID=$!

echo "[entrypoint] waiting for MinIO health..."
for _ in $(seq 1 100); do
    if curl -sf http://127.0.0.1:9000/minio/health/live >/dev/null; then
        break
    fi
    sleep 0.3
done
if ! curl -sf http://127.0.0.1:9000/minio/health/live >/dev/null; then
    echo "[entrypoint] MinIO failed to come up; tail of /var/log/minio.log:" >&2
    tail -n 40 /var/log/minio.log >&2 || true
    exit 1
fi
echo "[entrypoint] MinIO ready"

mc alias set local "http://127.0.0.1:9000" "$MINIO_ROOT_USER" "$MINIO_ROOT_PASSWORD" >/dev/null
mc mb --ignore-existing local/ducklake-data >/dev/null
echo "[entrypoint] bucket ducklake-data ready"

if [ ! -f /root/.config/quacktui/connections.toml ]; then
    cp /opt/quacktui/connections.toml.default /root/.config/quacktui/connections.toml
    echo "[entrypoint] seeded default connections.toml"
fi

python /opt/quacktui/seed_catalog.py

exec quacktui "$@"
EOF
RUN chmod +x /entrypoint.sh

VOLUME ["/root/.config/quacktui", "/root/.local/share/quacktui", "/root/.local/state/quacktui"]
EXPOSE 9000 9001

ENTRYPOINT ["/entrypoint.sh"]
CMD ["--connection", "duckdb-demo"]
