package com.acumenvelocity.ath.integration;
   
   import java.io.BufferedReader;
   import java.io.BufferedWriter;
   import java.io.IOException;
   import java.io.InputStreamReader;
   import java.io.OutputStream;
   import java.io.OutputStreamWriter;
   import java.net.HttpURLConnection;
  import java.net.URL;
  import java.nio.charset.StandardCharsets;
  import java.nio.file.Files;
  import java.nio.file.Path;
  
  import org.junit.jupiter.api.BeforeAll;
  import org.junit.jupiter.api.TestInstance;
  
  import com.fasterxml.jackson.databind.JsonNode;
  import com.fasterxml.jackson.databind.ObjectMapper;
  import com.fasterxml.jackson.databind.SerializationFeature;
  import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
  
  @TestInstance(TestInstance.Lifecycle.PER_CLASS)
  public abstract class BaseIntegrationTest {
    protected static final String BASE_URL = "http://localhost:8080/api";
    protected static final String SOLR_URL = "http://localhost:8983/solr";
    protected static final ObjectMapper objectMapper = new ObjectMapper()
        .registerModule(new JavaTimeModule())
        .disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);
  
  //  private static Process dockerComposeProcess;
    private static final int MAX_STARTUP_WAIT_SECONDS = 120;
  
  //  @BeforeAll
  //  public void setUpDockerEnvironment() throws Exception {
  //    System.out.println("Starting Docker Compose environment...");
  //    System.out.println("This may take a few minutes on first run (building images)...\n");
  //
  //    // Get the docker-compose.yml path
  //    Path dockerComposePath = Paths.get("./docker/docker-compose.yml").toAbsolutePath()
  //        .normalize();
  //
  //    if (!Files.exists(dockerComposePath)) {
  //      throw new FileNotFoundException("docker-compose.yml not found at: " + dockerComposePath);
  //    }
  //
  //    // Start docker-compose with output redirected to console
  //    ProcessBuilder processBuilder = new ProcessBuilder(
  //        "docker",
  //        "compose",
  //        "-f", dockerComposePath.toString(),
  //        "up",
  //        "-d",
  //        "--build",
  //        "--remove-orphans");
  //
  //    processBuilder.directory(dockerComposePath.getParent().toFile());
  //
  //    // Redirect output to console instead of consuming it
  //    processBuilder.inheritIO();
  //
  //    System.out.println("Running: " + String.join(" ", processBuilder.command()));
  //    System.out.println("Working directory: " + processBuilder.directory());
  //    System.out.println();
  //
  //    dockerComposeProcess = processBuilder.start();
  //    int exitCode = dockerComposeProcess.waitFor();
  //
  //    if (exitCode != 0) {
  //      throw new RuntimeException("Docker Compose failed to start (exit code: " + exitCode + ")");
  //    }
  //
  //    System.out
  //        .println("\nDocker Compose containers started, waiting for services to be healthy...");
  //
  //    // Wait for services to be healthy
  //    waitForServices();
  //
  //    System.out.println("Docker Compose environment is ready\n");
  //  }
    
    @BeforeAll
    public void setUpDockerEnvironment() throws Exception {
      System.out.println("Docker Compose must be started manually");
      System.out.println("This may take a few minutes on first run (building images)...\n");
  
      // Wait for services to be healthy
      waitForServices();
  
      System.out.println("Docker Compose environment is ready\n");
    }
  
    // @AfterAll
    // public void tearDownDockerEnvironment() throws Exception {
    // System.out.println("\nStopping Docker Compose environment...");
    //
    // Path dockerComposePath = Paths.get("./docker/docker-compose.yml").toAbsolutePath()
    // .normalize();
    //
   // ProcessBuilder processBuilder = new ProcessBuilder(
   // "docker",
   // "compose",
   // "-f", dockerComposePath.toString(),
   // "down",
   // "-v");
   //
   // processBuilder.directory(dockerComposePath.getParent().toFile());
   // processBuilder.inheritIO();
   //
   // Process process = processBuilder.start();
   // process.waitFor(30, TimeUnit.SECONDS);
   //
   // if (dockerComposeProcess != null && dockerComposeProcess.isAlive()) {
   // dockerComposeProcess.destroy();
   // }
   //
   // System.out.println("Docker Compose environment stopped");
   // }
 
   private void waitForServices() throws Exception {
     System.out.println("Waiting for services to be healthy...");
     System.out.println("Checking: " + BASE_URL + "/version");
     System.out.println("Checking: " + SOLR_URL + "/admin/info/system");
 
     long startTime = System.currentTimeMillis();
     long timeout = MAX_STARTUP_WAIT_SECONDS * 1000;
     int attemptCount = 0;
 
     while (System.currentTimeMillis() - startTime < timeout) {
       attemptCount++;
       boolean apiHealthy = isServiceHealthy(BASE_URL + "/version");
       boolean solrHealthy = isServiceHealthy(SOLR_URL + "/admin/info/system");
 
       if (apiHealthy && solrHealthy) {
         System.out.println("\n✓ All services are healthy after " + attemptCount + " attempts");
         return;
       }
 
       // Print status every 5 attempts
       if (attemptCount % 5 == 0) {
         System.out.print(".");
         System.out.flush();
       }
 
       // Print detailed status every 15 attempts
       if (attemptCount % 15 == 0) {
         long elapsed = (System.currentTimeMillis() - startTime) / 1000;
         System.out.println();
         System.out.println("  [" + elapsed + "s] API: " + (apiHealthy ? "✓" : "✗") +
             ", Solr: " + (solrHealthy ? "✓" : "✗"));
       }
 
       Thread.sleep(2000);
     }
 
     throw new RuntimeException(
         "Services did not become healthy within " + MAX_STARTUP_WAIT_SECONDS + " seconds");
   }
 
   private boolean isServiceHealthy(String urlString) {
     try {
       URL url = new URL(urlString);
       HttpURLConnection connection = (HttpURLConnection) url.openConnection();
       connection.setRequestMethod("GET");
       connection.setConnectTimeout(5000);
       connection.setReadTimeout(5000);
 
       int responseCode = connection.getResponseCode();
       connection.disconnect();
 
       return responseCode == 200;
     } catch (Exception e) {
       return false;
     }
   }
 
   // HTTP Helper Methods
 
   protected HttpResponse sendGetRequest(String endpoint) throws IOException {
     return sendRequest("GET", endpoint, null, null);
   }
 
   protected HttpResponse sendPostRequest(String endpoint, String jsonBody) throws IOException {
     return sendRequest("POST", endpoint, jsonBody, "application/json");
   }
 
   protected HttpResponse sendPutRequest(String endpoint, String jsonBody) throws IOException {
     return sendRequest("PUT", endpoint, jsonBody, "application/json");
   }
 
   protected HttpResponse sendDeleteRequest(String endpoint) throws IOException {
     return sendRequest("DELETE", endpoint, null, null);
   }
 
   protected HttpResponse sendMultipartRequest(String endpoint, MultipartRequestBody body)
       throws IOException {
     String boundary = "----IntegrationTestBoundary" + System.currentTimeMillis();
 
     URL url = new URL(BASE_URL + endpoint);
     HttpURLConnection connection = (HttpURLConnection) url.openConnection();
     connection.setRequestMethod("POST");
     connection.setDoOutput(true);
     connection.setRequestProperty("Content-Type", "multipart/form-data; boundary=" + boundary);
 
     try (OutputStream out = connection.getOutputStream();
         BufferedWriter writer = new BufferedWriter(
             new OutputStreamWriter(out, StandardCharsets.UTF_8))) {
 
       for (MultipartRequestBody.Part part : body.getParts()) {
         writer.write("--" + boundary + "\r\n");
 
         if (part.isFile()) {
           writer.write("Content-Disposition: form-data; name=\"" + part.getName() +
               "\"; filename=\"" + part.getFileName() + "\"\r\n");
           writer.write("Content-Type: " + part.getContentType() + "\r\n\r\n");
           writer.flush();
 
           Files.copy(part.getFilePath(), out);
           writer.write("\r\n");
         } else {
           writer.write("Content-Disposition: form-data; name=\"" + part.getName() + "\"\r\n\r\n");
           writer.write(part.getValue() + "\r\n");
         }
       }
 
       writer.write("--" + boundary + "--\r\n");
       writer.flush();
     }
 
     return getResponse(connection);
   }
 
   protected HttpResponse sendPutMultipartRequest(String endpoint, MultipartRequestBody body)
       throws IOException {
     String boundary = "----IntegrationTestBoundary" + System.currentTimeMillis();
 
     URL url = new URL(BASE_URL + endpoint);
     HttpURLConnection connection = (HttpURLConnection) url.openConnection();
     connection.setRequestMethod("PUT");
     connection.setDoOutput(true);
     connection.setRequestProperty("Content-Type", "multipart/form-data; boundary=" + boundary);
 
     try (OutputStream out = connection.getOutputStream();
         BufferedWriter writer = new BufferedWriter(
             new OutputStreamWriter(out, StandardCharsets.UTF_8))) {
 
       for (MultipartRequestBody.Part part : body.getParts()) {
         writer.write("--" + boundary + "\r\n");
 
         if (part.isFile()) {
           writer.write("Content-Disposition: form-data; name=\"" + part.getName() +
               "\"; filename=\"" + part.getFileName() + "\"\r\n");
           writer.write("Content-Type: " + part.getContentType() + "\r\n\r\n");
           writer.flush();
 
           Files.copy(part.getFilePath(), out);
           writer.write("\r\n");
         } else {
           writer.write("Content-Disposition: form-data; name=\"" + part.getName() + "\"\r\n\r\n");
           writer.write(part.getValue() + "\r\n");
         }
       }
 
       writer.write("--" + boundary + "--\r\n");
       writer.flush();
     }
 
     return getResponse(connection);
   }
 
   private HttpResponse sendRequest(String method, String endpoint, String body, String contentType)
       throws IOException {
     URL url = new URL(BASE_URL + endpoint);
     HttpURLConnection connection = (HttpURLConnection) url.openConnection();
     connection.setRequestMethod(method);
 
     if (body != null && contentType != null) {
       connection.setDoOutput(true);
       connection.setRequestProperty("Content-Type", contentType);
 
       try (OutputStream os = connection.getOutputStream()) {
         os.write(body.getBytes(StandardCharsets.UTF_8));
       }
     }
 
     return getResponse(connection);
   }
 
   private HttpResponse getResponse(HttpURLConnection connection) throws IOException {
     int statusCode = connection.getResponseCode();
     String responseBody;
 
     try (BufferedReader br = new BufferedReader(
         new InputStreamReader(
             statusCode >= 400 ? connection.getErrorStream() : connection.getInputStream(),
             StandardCharsets.UTF_8))) {
       StringBuilder response = new StringBuilder();
       String line;
       while ((line = br.readLine()) != null) {
         response.append(line);
       }
       responseBody = response.toString();
     }
 
     connection.disconnect();
     return new HttpResponse(statusCode, responseBody);
   }
 
   // Utility Methods
 
   protected JsonNode parseJson(String json) throws IOException {
     return objectMapper.readTree(json);
   }
 
   protected String toJson(Object obj) throws IOException {
     return objectMapper.writeValueAsString(obj);
   }
 
   protected void waitForAsyncOperation(String statusEndpoint, int maxWaitSeconds) throws Exception {
     long startTime = System.currentTimeMillis();
     long timeout = maxWaitSeconds * 1000;
 
     while (System.currentTimeMillis() - startTime < timeout) {
       HttpResponse response = sendGetRequest(statusEndpoint);
 
       if (response.getStatusCode() == 200) {
         JsonNode json = parseJson(response.getBody());
         String status = json.get("status").asText();
 
         if (status.equals("IMPORT_COMPLETED") || status.equals("EXPORT_COMPLETED")) {
           return;
         } else if (status.equals("FAILED")) {
           throw new RuntimeException("Operation failed: " + json.get("error_message").asText());
         }
       }
 
       Thread.sleep(1000);
     }
 
     throw new RuntimeException("Operation did not complete within " + maxWaitSeconds + " seconds");
   }
 
   // Inner Classes
 
   protected static class HttpResponse {
     private final int statusCode;
     private final String body;
 
     public HttpResponse(int statusCode, String body) {
       this.statusCode = statusCode;
       this.body = body;
     }
 
     public int getStatusCode() {
       return statusCode;
     }
 
     public String getBody() {
       return body;
     }
   }
 
   protected static class MultipartRequestBody {
     private final java.util.List<Part> parts = new java.util.ArrayList<>();
 
     public void addPart(String name, String value) {
       parts.add(new Part(name, value));
     }
 
     public void addFilePart(String name, String fileName, Path filePath, String contentType) {
       parts.add(new Part(name, fileName, filePath, contentType));
     }
 
     public java.util.List<Part> getParts() {
       return parts;
     }
 
     protected static class Part {
       private final String name;
       private final String value;
       private final String fileName;
       private final Path filePath;
       private final String contentType;
       private final boolean isFile;
 
       public Part(String name, String value) {
         this.name = name;
         this.value = value;
         this.fileName = null;
         this.filePath = null;
         this.contentType = null;
         this.isFile = false;
       }
 
       public Part(String name, String fileName, Path filePath, String contentType) {
         this.name = name;
         this.value = null;
         this.fileName = fileName;
         this.filePath = filePath;
         this.contentType = contentType;
         this.isFile = true;
       }
 
       public String getName() {
         return name;
       }
 
       public String getValue() {
         return value;
       }
 
       public String getFileName() {
         return fileName;
       }
 
       public Path getFilePath() {
         return filePath;
       }
 
       public String getContentType() {
         return contentType;
       }
 
       public boolean isFile() {
         return isFile;
       }
     }
   }
 }