/**
 * Native Maven CLI Testing
 * Tests the Maven registry implementation using the actual mvn CLI
 */

import { expect, tap } from '@git.zone/tstest/tapbundle';
import { tapNodeTools } from '@git.zone/tstest/tapbundle_serverside';
import { SmartRegistry } from '../ts/index.js';
import { createTestRegistry, createTestTokens, createTestPom, createTestJar } from './helpers/registry.js';
import type { IRequestContext, IResponse } from '../ts/core/interfaces.core.js';
import * as http from 'http';
import * as url from 'url';
import * as fs from 'fs';
import * as path from 'path';

// Test context
let registry: SmartRegistry;
let server: http.Server;
let registryUrl: string;
let registryPort: number;
let mavenToken: string;
let testDir: string;
let m2Dir: string;

/**
 * Create HTTP server wrapper around SmartRegistry
 */
async function createHttpServer(
  registryInstance: SmartRegistry,
  port: number
): Promise<{ server: http.Server; url: string }> {
  return new Promise((resolve, reject) => {
    const httpServer = http.createServer(async (req, res) => {
      try {
        // Parse request
        const parsedUrl = url.parse(req.url || '', true);
        const pathname = parsedUrl.pathname || '/';
        const query = parsedUrl.query;

        // Read body
        const chunks: Buffer[] = [];
        for await (const chunk of req) {
          chunks.push(chunk);
        }
        const bodyBuffer = Buffer.concat(chunks);

        // Parse body based on content type
        let body: any;
        if (bodyBuffer.length > 0) {
          const contentType = req.headers['content-type'] || '';
          if (contentType.includes('application/json')) {
            try {
              body = JSON.parse(bodyBuffer.toString('utf-8'));
            } catch (error) {
              body = bodyBuffer;
            }
          } else {
            body = bodyBuffer;
          }
        }

        // Convert to IRequestContext
        const context: IRequestContext = {
          method: req.method || 'GET',
          path: pathname,
          headers: req.headers as Record<string, string>,
          query: query as Record<string, string>,
          body: body,
        };

        // Handle request
        const response: IResponse = await registryInstance.handleRequest(context);

        // Convert IResponse to HTTP response
        res.statusCode = response.status;

        // Set headers
        for (const [key, value] of Object.entries(response.headers || {})) {
          res.setHeader(key, value);
        }

        // Send body
        if (response.body) {
          if (Buffer.isBuffer(response.body)) {
            res.end(response.body);
          } else if (typeof response.body === 'string') {
            res.end(response.body);
          } else {
            res.setHeader('Content-Type', 'application/json');
            res.end(JSON.stringify(response.body));
          }
        } else {
          res.end();
        }
      } catch (error) {
        console.error('Server error:', error);
        res.statusCode = 500;
        res.setHeader('Content-Type', 'application/json');
        res.end(JSON.stringify({ error: 'INTERNAL_ERROR', message: String(error) }));
      }
    });

    httpServer.listen(port, () => {
      const serverUrl = `http://localhost:${port}`;
      resolve({ server: httpServer, url: serverUrl });
    });

    httpServer.on('error', reject);
  });
}

/**
 * Setup Maven settings.xml for authentication
 */
function setupMavenSettings(
  token: string,
  m2DirArg: string,
  serverUrl: string
): string {
  fs.mkdirSync(m2DirArg, { recursive: true });

  const settingsXml = `<?xml version="1.0" encoding="UTF-8"?>
<settings xmlns="http://maven.apache.org/SETTINGS/1.0.0"
          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xsi:schemaLocation="http://maven.apache.org/SETTINGS/1.0.0
          http://maven.apache.org/xsd/settings-1.0.0.xsd">
  <servers>
    <server>
      <id>test-registry</id>
      <username>testuser</username>
      <password>${token}</password>
    </server>
  </servers>
  <profiles>
    <profile>
      <id>test-registry</id>
      <repositories>
        <repository>
          <id>test-registry</id>
          <url>${serverUrl}/maven</url>
          <releases>
            <enabled>true</enabled>
          </releases>
          <snapshots>
            <enabled>true</enabled>
          </snapshots>
        </repository>
      </repositories>
    </profile>
  </profiles>
  <activeProfiles>
    <activeProfile>test-registry</activeProfile>
  </activeProfiles>
</settings>
`;

  const settingsPath = path.join(m2DirArg, 'settings.xml');
  fs.writeFileSync(settingsPath, settingsXml, 'utf-8');

  return settingsPath;
}

/**
 * Create a minimal Maven project for testing
 */
function createMavenProject(
  projectDir: string,
  groupId: string,
  artifactId: string,
  version: string,
  registryUrl: string
): void {
  fs.mkdirSync(projectDir, { recursive: true });

  const pomXml = `<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
         http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>${groupId}</groupId>
  <artifactId>${artifactId}</artifactId>
  <version>${version}</version>
  <packaging>jar</packaging>
  <name>${artifactId}</name>
  <description>Test Maven project for SmartRegistry CLI tests</description>

  <distributionManagement>
    <repository>
      <id>test-registry</id>
      <url>${registryUrl}/maven</url>
    </repository>
    <snapshotRepository>
      <id>test-registry</id>
      <url>${registryUrl}/maven</url>
    </snapshotRepository>
  </distributionManagement>

  <build>
    <plugins>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>3.8.1</version>
        <configuration>
          <source>1.8</source>
          <target>1.8</target>
        </configuration>
      </plugin>
    </plugins>
  </build>
</project>
`;

  fs.writeFileSync(path.join(projectDir, 'pom.xml'), pomXml, 'utf-8');

  // Create minimal Java source
  const srcDir = path.join(projectDir, 'src', 'main', 'java', 'com', 'test');
  fs.mkdirSync(srcDir, { recursive: true });

  const javaSource = `package com.test;

public class Main {
    public static void main(String[] args) {
        System.out.println("Hello from SmartRegistry test!");
    }
}
`;
  fs.writeFileSync(path.join(srcDir, 'Main.java'), javaSource, 'utf-8');
}

/**
 * Run Maven command with custom settings
 */
async function runMavenCommand(
  command: string,
  cwd: string
): Promise<{ stdout: string; stderr: string; exitCode: number }> {
  const settingsPath = path.join(m2Dir, 'settings.xml');
  const fullCommand = `cd "${cwd}" && mvn -s "${settingsPath}" ${command}`;

  try {
    const result = await tapNodeTools.runCommand(fullCommand);
    return {
      stdout: result.stdout || '',
      stderr: result.stderr || '',
      exitCode: result.exitCode || 0,
    };
  } catch (error: any) {
    return {
      stdout: error.stdout || '',
      stderr: error.stderr || String(error),
      exitCode: error.exitCode || 1,
    };
  }
}

/**
 * Cleanup test directory
 */
function cleanupTestDir(dir: string): void {
  if (fs.existsSync(dir)) {
    fs.rmSync(dir, { recursive: true, force: true });
  }
}

// ========================================================================
// TESTS
// ========================================================================

tap.test('Maven CLI: should verify mvn is installed', async () => {
  try {
    const result = await tapNodeTools.runCommand('mvn -version');
    console.log('Maven version output:', result.stdout.substring(0, 200));
    expect(result.exitCode).toEqual(0);
  } catch (error) {
    console.log('Maven CLI not available, skipping native CLI tests');
    // Skip remaining tests if Maven is not installed
    tap.skip.test('Maven CLI: remaining tests skipped - mvn not available');
    return;
  }
});

tap.test('Maven CLI: should setup registry and HTTP server', async () => {
  // Create registry
  registry = await createTestRegistry();
  const tokens = await createTestTokens(registry);
  mavenToken = tokens.mavenToken;

  expect(registry).toBeInstanceOf(SmartRegistry);
  expect(mavenToken).toBeTypeOf('string');

  // Use port 37000 (avoids conflicts with other tests)
  registryPort = 37000;
  const serverSetup = await createHttpServer(registry, registryPort);
  server = serverSetup.server;
  registryUrl = serverSetup.url;

  expect(server).toBeDefined();
  expect(registryUrl).toEqual(`http://localhost:${registryPort}`);

  // Setup test directory
  testDir = path.join(process.cwd(), '.nogit', 'test-maven-cli');
  cleanupTestDir(testDir);
  fs.mkdirSync(testDir, { recursive: true });

  // Setup .m2 directory
  m2Dir = path.join(testDir, '.m2');
  fs.mkdirSync(m2Dir, { recursive: true });

  // Setup Maven settings
  const settingsPath = setupMavenSettings(mavenToken, m2Dir, registryUrl);
  expect(fs.existsSync(settingsPath)).toEqual(true);
});

tap.test('Maven CLI: should verify server is responding', async () => {
  // Check server is up by doing a direct HTTP request
  const response = await fetch(`${registryUrl}/maven/`);
  expect(response.status).toBeGreaterThanOrEqual(200);
  expect(response.status).toBeLessThan(500);
});

tap.test('Maven CLI: should deploy a JAR artifact', async () => {
  const groupId = 'com.test';
  const artifactId = 'test-artifact';
  const version = '1.0.0';

  const projectDir = path.join(testDir, 'test-project');
  createMavenProject(projectDir, groupId, artifactId, version, registryUrl);

  // Build and deploy
  const result = await runMavenCommand('clean package deploy -DskipTests', projectDir);
  console.log('mvn deploy output:', result.stdout.substring(0, 500));
  console.log('mvn deploy stderr:', result.stderr.substring(0, 500));

  expect(result.exitCode).toEqual(0);
});

tap.test('Maven CLI: should verify artifact in registry via API', async () => {
  const groupId = 'com.test';
  const artifactId = 'test-artifact';
  const version = '1.0.0';

  // Maven path: /maven/{groupId path}/{artifactId}/{version}/{artifactId}-{version}.jar
  const jarPath = `/maven/com/test/${artifactId}/${version}/${artifactId}-${version}.jar`;
  const response = await fetch(`${registryUrl}${jarPath}`, {
    headers: { Authorization: `Bearer ${mavenToken}` },
  });

  expect(response.status).toEqual(200);

  const jarData = await response.arrayBuffer();
  expect(jarData.byteLength).toBeGreaterThan(0);
});

tap.test('Maven CLI: should verify POM in registry', async () => {
  const groupId = 'com.test';
  const artifactId = 'test-artifact';
  const version = '1.0.0';

  const pomPath = `/maven/com/test/${artifactId}/${version}/${artifactId}-${version}.pom`;
  const response = await fetch(`${registryUrl}${pomPath}`, {
    headers: { Authorization: `Bearer ${mavenToken}` },
  });

  expect(response.status).toEqual(200);

  const pomContent = await response.text();
  expect(pomContent).toContain(groupId);
  expect(pomContent).toContain(artifactId);
  expect(pomContent).toContain(version);
});

tap.test('Maven CLI: should verify checksums exist', async () => {
  const artifactId = 'test-artifact';
  const version = '1.0.0';

  // Check JAR checksums
  const basePath = `/maven/com/test/${artifactId}/${version}/${artifactId}-${version}.jar`;

  // MD5
  const md5Response = await fetch(`${registryUrl}${basePath}.md5`, {
    headers: { Authorization: `Bearer ${mavenToken}` },
  });
  expect(md5Response.status).toEqual(200);

  // SHA1
  const sha1Response = await fetch(`${registryUrl}${basePath}.sha1`, {
    headers: { Authorization: `Bearer ${mavenToken}` },
  });
  expect(sha1Response.status).toEqual(200);
});

tap.test('Maven CLI: should deploy second version', async () => {
  const groupId = 'com.test';
  const artifactId = 'test-artifact';
  const version = '2.0.0';

  const projectDir = path.join(testDir, 'test-project-v2');
  createMavenProject(projectDir, groupId, artifactId, version, registryUrl);

  const result = await runMavenCommand('clean package deploy -DskipTests', projectDir);
  console.log('mvn deploy v2 output:', result.stdout.substring(0, 500));

  expect(result.exitCode).toEqual(0);
});

tap.test('Maven CLI: should verify metadata.xml exists', async () => {
  const artifactId = 'test-artifact';

  // Maven metadata is stored at /maven/{groupId path}/{artifactId}/maven-metadata.xml
  const metadataPath = `/maven/com/test/${artifactId}/maven-metadata.xml`;
  const response = await fetch(`${registryUrl}${metadataPath}`, {
    headers: { Authorization: `Bearer ${mavenToken}` },
  });

  expect(response.status).toEqual(200);

  const metadataXml = await response.text();
  expect(metadataXml).toContain(artifactId);
  expect(metadataXml).toContain('1.0.0');
  expect(metadataXml).toContain('2.0.0');
});

tap.test('Maven CLI: should resolve dependency from registry', async () => {
  const groupId = 'com.consumer';
  const artifactId = 'consumer-app';
  const version = '1.0.0';

  const projectDir = path.join(testDir, 'consumer-project');
  fs.mkdirSync(projectDir, { recursive: true });

  // Create a consumer project that depends on our test artifact
  const pomXml = `<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
         http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>${groupId}</groupId>
  <artifactId>${artifactId}</artifactId>
  <version>${version}</version>
  <packaging>jar</packaging>

  <repositories>
    <repository>
      <id>test-registry</id>
      <url>${registryUrl}/maven</url>
    </repository>
  </repositories>

  <dependencies>
    <dependency>
      <groupId>com.test</groupId>
      <artifactId>test-artifact</artifactId>
      <version>1.0.0</version>
    </dependency>
  </dependencies>
</project>
`;

  fs.writeFileSync(path.join(projectDir, 'pom.xml'), pomXml, 'utf-8');

  // Try to resolve dependencies
  const result = await runMavenCommand('dependency:resolve', projectDir);
  console.log('mvn dependency:resolve output:', result.stdout.substring(0, 500));

  expect(result.exitCode).toEqual(0);
});

tap.postTask('cleanup maven cli tests', async () => {
  // Stop server
  if (server) {
    await new Promise<void>((resolve) => {
      server.close(() => resolve());
    });
  }

  // Cleanup test directory
  if (testDir) {
    cleanupTestDir(testDir);
  }

  // Destroy registry
  if (registry) {
    registry.destroy();
  }
});

export default tap.start();