# File: app.py
# Description: Basic FastAPI application for a vector search microservice.
# This example uses a mock vector store and embedding model for demonstration.
# In a real-world scenario, integrate with a robust vector database (e.g., Milvus, Weaviate, Pinecone, Faiss)
# and a pre-trained biological embedding model (e.g., ProtBERT, ESM).

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
from typing import List, Dict, Any
import numpy as np

# Initialize FastAPI application
app = FastAPI(
    title="Bio Vector Search API",
    description="API for searching biological vector embeddings",
    version="1.0.0"
)

# Mock data for demonstration
# In a real system, this would be loaded from a persistent vector database.
# We simulate 1000 biological entities, each with a 768-dimensional embedding.
# Embeddings are randomly generated for illustrative purposes.
# Metadata could include protein IDs, gene names, experimental conditions, etc.
NUM_VECTORS = 1000
VECTOR_DIMENSION = 768

mock_vectors = np.random.rand(NUM_VECTORS, VECTOR_DIMENSION).astype(np.float32)
mock_metadata = [{
    "id": f"entity_{i}",
    "name": f"Bio-Entity {i}",
    "type": "Protein" if i % 2 == 0 else "Gene",
    "sequence_length": np.random.randint(50, 1000)
} for i in range(NUM_VECTORS)]

def load_vector_store():
    """Loads or connects to the vector store."""
    # In production, this would initialize a client for Milvus, Weaviate, etc.
    # For this mock, we just return our in-memory data.
    print("INFO: Initializing mock vector store...")
    return mock_vectors, mock_metadata

# Load vector store globally once at startup
VECTOR_DB, METADATA = load_vector_store()

class QueryRequest(BaseModel):
    query_vector: List[float]
    top_k: int = 10
    # Additional filters could be added here, e.g., {'type': 'Protein'}
    filters: Dict[str, Any] = {}

class SearchResult(BaseModel):
    id: str
    score: float
    metadata: Dict[str, Any]

@app.get("/health")
async def health_check():
    """Endpoint to check API health."""
    return {"status": "healthy", "vector_count": len(VECTOR_DB)}

@app.post("/search", response_model=List[SearchResult])
async def search_vectors(request: QueryRequest):
    """Performs a similarity search against the biological vector store."""
    if len(request.query_vector) != VECTOR_DIMENSION:
        raise HTTPException(status_code=400, detail=f"Query vector dimension must be {VECTOR_DIMENSION}")

    query_vec = np.array(request.query_vector).astype(np.float32)

    # Simple cosine similarity calculation (or dot product for normalized vectors)
    # In a real vector database, this is handled by optimized indexing structures.
    similarities = np.dot(VECTOR_DB, query_vec) / (np.linalg.norm(VECTOR_DB, axis=1) * np.linalg.norm(query_vec))

    # Get top_k indices
    top_k_indices = np.argsort(similarities)[::-1][:request.top_k]

    results = []
    for i in top_k_indices:
        entity_metadata = METADATA[i]
        # Apply filters (basic example)
        filter_match = True
        for k, v in request.filters.items():
            if entity_metadata.get(k) != v:
                filter_match = False
                break
        
        if filter_match:
            results.append(SearchResult(
                id=entity_metadata["id"],
                score=float(similarities[i]),
                metadata=entity_metadata
            ))
    
    return results

# To run this locally for testing:
# uvicorn app:app --host 0.0.0.0 --port 8000 --reload

# File: Dockerfile
# Description: Dockerfile to containerize the FastAPI application.
# Uses a multi-stage build for a smaller final image.

# --- Stage 1: Build Environment ---
FROM python:3.9-slim-buster AS builder

# Set working directory
WORKDIR /app

# Install build dependencies
RUN apt-get update && apt-get install -y --no-install-recommends \
    build-essential \
    gcc \
    && rm -rf /var/lib/apt/lists/*

# Copy poetry.lock and pyproject.toml files to cache dependencies
COPY pyproject.toml poetry.lock* ./

# Install Poetry
RUN pip install poetry

# Install project dependencies
RUN poetry install --no-root --no-dev

# --- Stage 2: Runtime Environment ---
FROM python:3.9-slim-buster AS runtime

# Set working directory
WORKDIR /app

# Copy only the installed dependencies from the builder stage
COPY --from=builder /usr/local/lib/python3.9/site-packages /usr/local/lib/python3.9/site-packages
COPY --from=builder /usr/local/bin/poetry /usr/local/bin/poetry
# Copy the application code
COPY app.py ./

# Expose the port the API runs on
EXPOSE 8000

# Command to run the application using Uvicorn
# Adjust workers based on CPU cores for optimal performance
CMD ["poetry", "run", "uvicorn", "app:app", "--host", "0.0.0.0", "--port", "8000", "--workers", "4"]

# --- Required project files (pyproject.toml, poetry.lock) ---
# pyproject.toml (example)
# [tool.poetry]
# name = "bio-vector-search"
# version = "0.1.0"
# description = ""
# authors = ["Your Name <you@example.com>"]
# readme = "README.md"
# packages = [{include = "bio_vector_search"}]

# [tool.poetry.dependencies]
# python = "^3.9"
# fastapi = "^0.104.1"
# uvicorn = {extras = ["standard"], version = "^0.23.2"}
# numpy = "^1.26.1"
# pydantic = "^2.5.0"

# [build-system]
# requires = ["poetry-core"]
# build-backend = "poetry.core.masonry.api"]

# To build the Docker image:
# docker build -t bio-vector-search-api:latest .

# To run the Docker container:
# docker run -d -p 8000:8000 bio-vector-search-api:latest

# File: k8s-deployment.yaml
# Description: Kubernetes Deployment and Service definitions for the vector search microservice.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: bio-vector-search-deployment
  labels:
    app: bio-vector-search
spec:
  replicas: 3 # Activate 3 instances for high availability and load balancing
  selector:
    matchLabels:
      app: bio-vector-search
  template:
    metadata:
      labels:
        app: bio-vector-search
    spec:
      containers:
      - name: bio-vector-search-container
        image: bio-vector-search-api:latest # Ensure this image is available in your registry (e.g., pushed to Docker Hub or GCR)
        ports:
        - containerPort: 8000
        resources:
          requests:
            memory: "1Gi"
            cpu: "500m"
          limits:
            memory: "2Gi"
            cpu: "1"
        livenessProbe:
          httpGet:
            path: /health
            port: 8000
          initialDelaySeconds: 15
          periodSeconds: 20
        readinessProbe:
          httpGet:
            path: /health
            port: 8000
          initialDelaySeconds: 5
          periodSeconds: 10
--- # Separate YAML documents with three dashes

apiVersion: v1
kind: Service
metadata:
  name: bio-vector-search-service
spec:
  selector:
    app: bio-vector-search
  ports:
    - protocol: TCP
      port: 80
      targetPort: 8000
  type: ClusterIP # Use LoadBalancer for external access in cloud environments

# To deploy to Kubernetes:
# kubectl apply -f k8s-deployment.yaml

# To verify deployment:
# kubectl get deployments
# kubectl get pods -l app=bio-vector-search
# kubectl get service bio-vector-search-service

# To test (if using ClusterIP, port-forward first):
# kubectl port-forward service/bio-vector-search-service 8080:80
# Then access via http://localhost:8080/health or send POST request to /search

# Example of a Kubernetes HorizontalPodAutoscaler (HPA) definition
# Description: Automatically scales the number of pods based on CPU utilization.
# For advanced monitoring, integrate with Prometheus and Grafana, and use Loki for centralized logging.

apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: bio-vector-search-hpa
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: bio-vector-search-deployment
  minReplicas: 3
  maxReplicas: 10 # Define maximum replicas to prevent uncontrolled scaling
  metrics:
  - type: Resource
    resource:
      name: cpu
      target:
        type: Utilization
        averageUtilization: 70 # Scale up when average CPU utilization exceeds 70%

# To deploy the HPA:
# kubectl apply -f k8s-hpa.yaml

# To check HPA status:
# kubectl get hpa

# Example of structured logging in Python (within app.py or a dedicated logger module)
# import logging
# import json
# from pythonjsonlogger import jsonlogger

# logger = logging.getLogger('bio_vector_search')
# logger.setLevel(logging.INFO)
# logHandler = logging.StreamHandler()
# formatter = jsonlogger.JsonFormatter('%(asctime)s %(levelname)s %(name)s %(message)s')
# logHandler.setFormatter(formatter)
# logger.addHandler(logHandler)

# Inside a function:
# logger.info("Vector search initiated", extra={'query_length': len(request.query_vector), 'top_k': request.top_k})
# logger.error("Search failed", extra={'error_code': 500, 'details': str(e)})