/*
 * Step 1: Initialize a Spring Boot Project with necessary dependencies.
 * Use Spring Initializr (https://start.spring.io/) for quick setup.
 * Add 'Spring Web' for REST APIs.
 * Add 'Spring Data Redis' or 'Spring Data JPA' if needed for metadata.
 * For vector database clients, add specific dependencies (e.g., 'weaviate-client', 'qdrant-java-client', 'pinecone-java-client').
 */

// build.gradle (Groovy DSL) example for a hypothetical Weaviate integration
// Make sure to replace specific versions with the latest stable releases
plugins {
    id 'org.springframework.boot' version '2.7.5' // Use your desired Spring Boot version
    id 'io.spring.dependency-management' version '1.0.15.RELEASE'
    id 'java'
}

group = 'com.bioengineering'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = '17'

repositories {
    mavenCentral()
}

dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-web'
    // Example: Weaviate client. Adjust for your chosen vector database.
    implementation 'io.weaviate:client:4.0.0' // Check for the latest version

    // Optional: For managing metadata or other persistent data
    // implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
    // runtimeOnly 'com.h2database:h2' // For in-memory database during development

    // Testing dependencies
    testImplementation 'org.springframework.boot:spring-boot-starter-test'
}

tasks.named('test') {
    useJUnitPlatform()
}

/*
 * Step 2: Define Data Transfer Objects (DTOs) for Molecular Embeddings
 * These DTOs represent the structure of data sent to and retrieved from the vector database.
 * Ensure your DTO reflects the actual structure of your molecular data and its vector representation.
 */

package com.bioengineering.embeddings.dto;

import java.util.List;
import java.util.Map;
import java.util.Objects;

public class MolecularEmbeddingDTO {
    private String id; // Unique identifier for the molecule
    private String smiles; // SMILES string representation
    private List<Float> vector; // The molecular embedding vector
    private Map<String, String> properties; // Additional metadata (e.g., CAS number, target protein)

    // Constructors
    public MolecularEmbeddingDTO() {
    }

    public MolecularEmbeddingDTO(String id, String smiles, List<Float> vector, Map<String, String> properties) {
        this.id = id;
        this.smiles = smiles;
        this.vector = vector;
        this.properties = properties;
    }

    // Getters and Setters
    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getSmiles() {
        return smiles;
    }

    public void setSmiles(String smiles) {
        this.smiles = smiles;
    }

    public List<Float> getVector() {
        return vector;
    }

    public void setVector(List<Float> vector) {
        this.vector = vector;
    }

    public Map<String, String> getProperties() {
        return properties;
    }

    public void setProperties(Map<String, String> properties) {
        this.properties = properties;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        MolecularEmbeddingDTO that = (MolecularEmbeddingDTO) o;
        return Objects.equals(id, that.id) && Objects.equals(smiles, that.smiles) && Objects.equals(vector, that.vector) && Objects.equals(properties, that.properties);
    }

    @Override
    public int hashCode() {
        return Objects.hash(id, smiles, vector, properties);
    }

    @Override
    public String toString() {
        return "MolecularEmbeddingDTO{" +
               "id='" + id + '\'' +
               ", smiles='" + smiles + '\'' +
               ", vectorSize=" + (vector != null ? vector.size() : 0) +
               ", properties=" + properties +
               '}';
    }
}

/*
 * Service class for ingesting molecular embeddings into a vector database.
 * This example uses a placeholder 'VectorDatabaseClient' interface.
 * You would implement this interface using your chosen vector database's SDK.
 */

package com.bioengineering.embeddings.service;

import com.bioengineering.embeddings.dto.MolecularEmbeddingDTO;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class MolecularEmbeddingService {

    private final VectorDatabaseClient vectorDatabaseClient;

    public MolecularEmbeddingService(VectorDatabaseClient vectorDatabaseClient) {
        this.vectorDatabaseClient = vectorDatabaseClient;
    }

    /**
     * Ingests a single molecular embedding into the vector database.
     * @param embeddingDTO The DTO containing molecular data and its vector.
     */
    public void ingestEmbedding(MolecularEmbeddingDTO embeddingDTO) {
        // Validate DTO content before ingestion
        if (embeddingDTO.getId() == null || embeddingDTO.getVector() == null || embeddingDTO.getVector().isEmpty()) {
            throw new IllegalArgumentException("Molecular embedding ID and vector cannot be null or empty.");
        }
        vectorDatabaseClient.upsert(embeddingDTO.getId(), embeddingDTO.getVector(), embeddingDTO.getProperties());
        System.out.println("Ingested embedding for ID: " + embeddingDTO.getId());
    }

    /**
     * Ingests a batch of molecular embeddings for efficiency.
     * @param embeddingDTOs A list of DTOs containing molecular data and their vectors.
     */
    public void ingestEmbeddingsBatch(List<MolecularEmbeddingDTO> embeddingDTOs) {
        if (embeddingDTOs == null || embeddingDTOs.isEmpty()) {
            System.out.println("No embeddings to ingest in batch.");
            return;
        }
        vectorDatabaseClient.batchUpsert(embeddingDTOs);
        System.out.println("Ingested batch of " + embeddingDTOs.size() + " embeddings.");
    }
}

// Placeholder interface for a Vector Database Client
// In a real application, this would be an actual client like WeaviateClient, QdrantClient, etc.
package com.bioengineering.embeddings.service;

import java.util.List;
import java.util.Map;

public interface VectorDatabaseClient {
    void upsert(String id, List<Float> vector, Map<String, String> properties);
    void batchUpsert(List<MolecularEmbeddingDTO> embeddings);
    List<MolecularEmbeddingDTO> findSimilar(List<Float> queryVector, int limit, Map<String, String> filterProperties);
}

/*
 * Step 3: Develop a Spring Boot REST Controller for Molecular Embedding Search.
 * This controller will expose endpoints for clients to query molecular embeddings.
 * We focus on similarity search (k-NN) and filtered search capabilities.
 */

package com.bioengineering.api.controller;

import com.bioengineering.embeddings.dto.MolecularEmbeddingDTO;
import com.bioengineering.embeddings.service.MolecularEmbeddingService;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

import java.util.List;
import java.util.Map;

@RestController
@RequestMapping("/api/v1/molecular-embeddings")
public class MolecularEmbeddingController {

    private final MolecularEmbeddingService molecularEmbeddingService; // Assume this service handles vector DB interaction

    public MolecularEmbeddingController(MolecularEmbeddingService molecularEmbeddingService) {
        this.molecularEmbeddingService = molecularEmbeddingService;
    }

    /**
     * Endpoint to ingest a single molecular embedding.
     * POST /api/v1/molecular-embeddings
     * Request Body: MolecularEmbeddingDTO
     */
    @PostMapping
    public ResponseEntity<String> ingestSingleEmbedding(@RequestBody MolecularEmbeddingDTO embeddingDTO) {
        try {
            molecularEmbeddingService.ingestEmbedding(embeddingDTO);
            return ResponseEntity.status(HttpStatus.CREATED).body("Embedding for ID " + embeddingDTO.getId() + " ingested successfully.");
        } catch (IllegalArgumentException e) {
            return ResponseEntity.badRequest().body(e.getMessage());
        } catch (Exception e) {
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("Failed to ingest embedding: " + e.getMessage());
        }
    }

    /**
     * Endpoint to ingest a batch of molecular embeddings.
     * POST /api/v1/molecular-embeddings/batch
     * Request Body: List<MolecularEmbeddingDTO>
     */
    @PostMapping("/batch")
    public ResponseEntity<String> ingestBatchEmbeddings(@RequestBody List<MolecularEmbeddingDTO> embeddingDTOs) {
        try {
            molecularEmbeddingService.ingestEmbeddingsBatch(embeddingDTOs);
            return ResponseEntity.status(HttpStatus.CREATED).body("Batch ingestion successful for " + embeddingDTOs.size() + " embeddings.");
        } catch (IllegalArgumentException e) {
            return ResponseEntity.badRequest().body(e.getMessage());
        } catch (Exception e) {
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("Failed to ingest batch: " + e.getMessage());
        }
    }

    /**
     * Endpoint for molecular similarity search (k-NN).
     * POST /api/v1/molecular-embeddings/search-similar
     * Request Body: A DTO containing the query vector and search parameters (e.g., limit, filters)
     */
    @PostMapping("/search-similar")
    public ResponseEntity<List<MolecularEmbeddingDTO>> searchSimilarEmbeddings(@RequestBody SearchRequestDTO searchRequest) {
        try {
            // The service method will interact with the VectorDatabaseClient
            List<MolecularEmbeddingDTO> results = molecularEmbeddingService.findSimilarEmbeddings(searchRequest.getQueryVector(), searchRequest.getLimit(), searchRequest.getFilterProperties());
            if (results.isEmpty()) {
                return ResponseEntity.noContent().build();
            }
            return ResponseEntity.ok(results);
        } catch (Exception e) {
            System.err.println("Error during similarity search: " + e.getMessage());
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
        }
    }
}

/*
 * DTO for search requests, carrying the query vector and other parameters.
 */
package com.bioengineering.api.controller;

import java.util.List;
import java.util.Map;

public class SearchRequestDTO {
    private List<Float> queryVector;
    private int limit; // Number of similar results to return
    private Map<String, String> filterProperties; // Optional: for filtered searches

    // Constructors, Getters, Setters
    public SearchRequestDTO() {}

    public SearchRequestDTO(List<Float> queryVector, int limit, Map<String, String> filterProperties) {
        this.queryVector = queryVector;
        this.limit = limit;
        this.filterProperties = filterProperties;
    }

    public List<Float> getQueryVector() {
        return queryVector;
    }

    public void setQueryVector(List<Float> queryVector) {
        this.queryVector = queryVector;
    }

    public int getLimit() {
        return limit;
    }

    public void setLimit(int limit) {
        this.limit = limit;
    }

    public Map<String, String> getFilterProperties() {
        return filterProperties;
    }

    public void setFilterProperties(Map<String, String> filterProperties) {
        this.filterProperties = filterProperties;
    }
}

/*
 * Extend the MolecularEmbeddingService to include search methods.
 */
package com.bioengineering.embeddings.service;

import com.bioengineering.embeddings.dto.MolecularEmbeddingDTO;
import org.springframework.stereotype.Service;

import java.util.Collections;
import java.util.List;
import java.util.Map;

@Service
public class MolecularEmbeddingService {

    private final VectorDatabaseClient vectorDatabaseClient;

    public MolecularEmbeddingService(VectorDatabaseClient vectorDatabaseClient) {
        this.vectorDatabaseClient = vectorDatabaseClient;
    }

    // Existing ingest methods...
    public void ingestEmbedding(MolecularEmbeddingDTO embeddingDTO) { /* ... */ }
    public void ingestEmbeddingsBatch(List<MolecularEmbeddingDTO> embeddingDTOs) { /* ... */ }

    /**
     * Performs a similarity search in the vector database.
     * @param queryVector The embedding vector of the molecule to search for.
     * @param limit The maximum number of similar results to return.
     * @param filterProperties Optional properties to filter results (e.g., target_protein=kinase).
     * @return A list of similar molecular embeddings.
     */
    public List<MolecularEmbeddingDTO> findSimilarEmbeddings(List<Float> queryVector, int limit, Map<String, String> filterProperties) {
        if (queryVector == null || queryVector.isEmpty()) {
            throw new IllegalArgumentException("Query vector cannot be null or empty for similarity search.");
        }
        System.out.println("Searching for similar embeddings with limit " + limit + " and filters: " + filterProperties);
        // Delegate to the actual vector database client implementation
        return vectorDatabaseClient.findSimilar(queryVector, limit, filterProperties);
    }
}

/*
 * Step 4: Configure connection pooling for the Vector Database Client.
 * This enhances performance by reusing connections, reducing overhead.
 * The configuration details depend heavily on the specific vector database client library.
 * Here's a conceptual example, illustrating the idea with a placeholder config.
 */

// application.yml (Spring Boot configuration for a hypothetical client)
# Assuming a Weaviate client configuration
weaviate:
  client:
    host: localhost
    port: 8080
    scheme: http
    connection-pool:
      max-connections: 20
      max-pending-requests: 100
      connection-timeout-ms: 10000
      read-timeout-ms: 30000

// Example of how you might configure and use connection pooling in a Spring @Configuration class
package com.bioengineering.config;

import com.bioengineering.embeddings.service.VectorDatabaseClient;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.beans.factory.annotation.Value;

// Placeholder for an actual Weaviate client setup example
// In a real application, you would instantiate the actual client library here
// For Weaviate, this would involve `io.weaviate.client.WeaviateClient`
// and `io.weaviate.client.Config` with `withConnectionTimeout` etc.

@Configuration
public class VectorDatabaseClientConfig {

    @Value("${weaviate.client.host:localhost}")
    private String host;

    @Value("${weaviate.client.port:8080}")
    private int port;

    @Value("${weaviate.client.scheme:http}")
    private String scheme;

    @Value("${weaviate.client.connection-pool.max-connections:20}")
    private int maxConnections;

    @Value("${weaviate.client.connection-pool.connection-timeout-ms:10000}")
    private long connectionTimeoutMs;

    @Value("${weaviate.client.connection-pool.read-timeout-ms:30000}")
    private long readTimeoutMs;

    @Bean
    public VectorDatabaseClient vectorDatabaseClient() {
        // This is a placeholder. Replace with actual client initialization
        // For Weaviate, it might look like:
        /*
        io.weaviate.client.Config config = new io.weaviate.client.Config(
            scheme, host + ":" + port
        ).withConnectionTimeout(connectionTimeoutMs)
         .withReadTimeout(readTimeoutMs);
        return new ActualWeaviateClientImplementation(config, maxConnections);
        */
        System.out.println("Initializing VectorDatabaseClient with pool settings: " +
                           "maxConnections=" + maxConnections + ", " +
                           "connectionTimeoutMs=" + connectionTimeoutMs + ", " +
                           "readTimeoutMs=" + readTimeoutMs);
        return new PlaceholderVectorDatabaseClient(host, port, scheme, maxConnections, connectionTimeoutMs, readTimeoutMs);
    }

    // A very basic placeholder implementation of VectorDatabaseClient for demonstration
    static class PlaceholderVectorDatabaseClient implements VectorDatabaseClient {
        // ... (constructor and methods from interface, simplified for placeholder)
        private final String host;
        private final int port;
        private final String scheme;
        private final int maxConnections;
        private final long connectionTimeoutMs;
        private final long readTimeoutMs;

        public PlaceholderVectorDatabaseClient(String host, int port, String scheme, int maxConnections, long connectionTimeoutMs, long readTimeoutMs) {
            this.host = host;
            this.port = port;
            this.scheme = scheme;
            this.maxConnections = maxConnections;
            this.connectionTimeoutMs = connectionTimeoutMs;
            this.readTimeoutMs = readTimeoutMs;
        }

        @Override
        public void upsert(String id, List<Float> vector, Map<String, String> properties) {
            System.out.println("Placeholder upsert for ID: " + id + " via client with pool settings.");
        }

        @Override
        public void batchUpsert(List<MolecularEmbeddingDTO> embeddings) {
            System.out.println("Placeholder batch upsert for " + embeddings.size() + " embeddings.");
        }

        @Override
        public List<MolecularEmbeddingDTO> findSimilar(List<Float> queryVector, int limit, Map<String, String> filterProperties) {
            System.out.println("Placeholder similarity search for " + queryVector.size() + " dimensions, limit " + limit + ", filters " + filterProperties);
            return Collections.emptyList(); // Return empty list for placeholder
        }
    }
}

/*
 * Step 5: Implement comprehensive error handling and logging.
 * A global exception handler in Spring Boot catches exceptions across the application
 * and returns consistent, meaningful error responses.
 */

package com.bioengineering.api.exception;

import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.context.request.WebRequest;
import org.springframework.web.servlet.mvc.method.annotation.ResponseEntityExceptionHandler;

import java.time.LocalDateTime;
import java.util.LinkedHashMap;
import java.util.Map;

// Custom exception for application-specific errors
class MolecularEmbeddingProcessingException extends RuntimeException {
    public MolecularEmbeddingProcessingException(String message) {
        super(message);
    }
    public MolecularEmbeddingProcessingException(String message, Throwable cause) {
        super(message, cause);
    }
}

@ControllerAdvice
public class GlobalExceptionHandler extends ResponseEntityExceptionHandler {

    @ExceptionHandler(MolecularEmbeddingProcessingException.class)
    public ResponseEntity<Object> handleMolecularEmbeddingProcessingException(MolecularEmbeddingProcessingException ex, WebRequest request) {
        Map<String, Object> body = new LinkedHashMap<>();
        body.put("timestamp", LocalDateTime.now());
        body.put("message", ex.getMessage());
        body.put("details", request.getDescription(false));
        return new ResponseEntity<>(body, HttpStatus.BAD_REQUEST);
    }

    @ExceptionHandler(Exception.class)
    public ResponseEntity<Object> handleAllExceptions(Exception ex, WebRequest request) {
        Map<String, Object> body = new LinkedHashMap<>();
        body.put("timestamp", LocalDateTime.now());
        body.put("message", "An unexpected error occurred: " + ex.getMessage());
        body.put("details", request.getDescription(false));
        return new ResponseEntity<>(body, HttpStatus.INTERNAL_SERVER_ERROR);
    }

    // You can add more specific exception handlers here (e.g., for VectorDatabaseClient specific exceptions)
}

/*
 * Example of structured logging in a service class.
 * Use SLF4J with Logback (Spring Boot's default) for robust logging.
 */
package com.bioengineering.embeddings.service;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;

import java.util.List;
import java.util.Map;

@Service
public class AnotherMolecularEmbeddingService {

    private static final Logger logger = LoggerFactory.getLogger(AnotherMolecularEmbeddingService.class);

    private final VectorDatabaseClient vectorDatabaseClient;

    public AnotherMolecularEmbeddingService(VectorDatabaseClient vectorDatabaseClient) {
        this.vectorDatabaseClient = vectorDatabaseClient;
    }

    public List<MolecularEmbeddingDTO> findSimilarEmbeddingsWithLogging(List<Float> queryVector, int limit, Map<String, String> filterProperties) {
        logger.info("Attempting similarity search. Query vector size: {}, Limit: {}, Filters: {}",
                    queryVector != null ? queryVector.size() : 0, limit, filterProperties);
        try {
            if (queryVector == null || queryVector.isEmpty()) {
                logger.warn("Invalid query: queryVector is null or empty. Returning empty list.");
                throw new MolecularEmbeddingProcessingException("Query vector cannot be null or empty.");
            }
            List<MolecularEmbeddingDTO> results = vectorDatabaseClient.findSimilar(queryVector, limit, filterProperties);
            logger.debug("Similarity search completed. Found {} results.", results.size());
            return results;
        } catch (MolecularEmbeddingProcessingException e) {
            logger.error("Application-specific error during similarity search: {}", e.getMessage(), e);
            throw e; // Re-throw to be handled by GlobalExceptionHandler
        } catch (Exception e) {
            logger.error("Unexpected error during similarity search: {}", e.getMessage(), e);
            throw new MolecularEmbeddingProcessingException("Error processing similarity search request.", e); // Wrap and re-throw
        }
    }
}