"""Pluggable blob storage. Local filesystem for dev; S3-compatible for production.

Both back ends share one interface so evidence files and raw import blobs are stored

identically regardless of environment. Selected via SIGHTLINE_STORAGE_BACKEND."""

from __future__ import annotations

import os

import shutil

from abc import ABC, abstractmethod

from typing import BinaryIO

from app.core.config import settings

class StorageBackend(ABC):

    @abstractmethod

    def put(self, key: str, data: bytes) -> str: ...

    @abstractmethod

    def get(self, ref: str) -> bytes: ...

    @abstractmethod

    def open_stream(self, ref: str) -> BinaryIO: ...

    @abstractmethod

    def delete(self, ref: str) -> None: ...

class LocalStorage(StorageBackend):

    """Stores under settings.storage_dir. The returned ref is the absolute path."""

    def __init__(self, base_dir: str):

        self.base = os.path.abspath(base_dir)

        os.makedirs(self.base, exist_ok=True)

    def _safe_path(self, key: str) -> str:

        clean = key.lstrip("/").replace("..", "_")

        path = os.path.join(self.base, clean)

        os.makedirs(os.path.dirname(path), exist_ok=True)

        return path

    def put(self, key: str, data: bytes) -> str:

        path = self._safe_path(key)

        with open(path, "wb") as fh:

            fh.write(data)

        return path

    def get(self, ref: str) -> bytes:

        with open(ref, "rb") as fh:

            return fh.read()

    def open_stream(self, ref: str) -> BinaryIO:

        return open(ref, "rb")

    def delete(self, ref: str) -> None:

        try:

            os.remove(ref)

        except FileNotFoundError:

            pass

class S3Storage(StorageBackend):

    """S3 / S3-compatible (MinIO, R2, Wasabi). Ref format: s3://bucket/key.

    boto3 is imported lazily so dev installs don't need it."""

    def __init__(self, bucket: str, endpoint_url: str | None = None, region: str | None = None):

        import boto3

        self.bucket = bucket

        self._s3 = boto3.client("s3", endpoint_url=endpoint_url, region_name=region)

    def put(self, key: str, data: bytes) -> str:

        clean = key.lstrip("/")

        self._s3.put_object(Bucket=self.bucket, Key=clean, Body=data)

        return f"s3://{self.bucket}/{clean}"

    def _parse(self, ref: str) -> tuple[str, str]:

        assert ref.startswith("s3://")

        bucket, _, key = ref[5:].partition("/")

        return bucket, key

    def get(self, ref: str) -> bytes:

        bucket, key = self._parse(ref)

        return self._s3.get_object(Bucket=bucket, Key=key)["Body"].read()

    def open_stream(self, ref: str) -> BinaryIO:

        bucket, key = self._parse(ref)

        return self._s3.get_object(Bucket=bucket, Key=key)["Body"]

    def delete(self, ref: str) -> None:

        bucket, key = self._parse(ref)

        self._s3.delete_object(Bucket=bucket, Key=key)

_backend: StorageBackend | None = None

def get_storage() -> StorageBackend:

    global _backend

    if _backend is None:

        if settings.storage_backend == "s3":

            _backend = S3Storage(settings.s3_bucket, settings.s3_endpoint_url, settings.s3_region)

        else:

            _backend = LocalStorage(settings.storage_dir)

    return _backend