import { describe, it, expect, beforeAll, afterAll } from 'vitest';
import { exec } from 'child_process';
import { promisify } from 'util';

const execAsync = promisify(exec);

/**
 * Docker Stack Integration Tests
 * Tests the full Docker Compose stack deployment
 */
describe('Docker Stack Integration Tests', () => {
  const TIMEOUT = 120000; // 2 minutes for Docker operations
  const HEALTH_CHECK_RETRIES = 30;
  const HEALTH_CHECK_INTERVAL = 2000;

  /**
   * Helper function to execute Docker Compose commands
   */
  async function dockerCompose(command: string): Promise<string> {
    const { stdout } = await execAsync(`docker compose ${command}`, {
      cwd: process.cwd(),
    });
    return stdout;
  }

  /**
   * Helper function to check if a service is healthy
   */
  async function waitForService(
    serviceName: string,
    retries = HEALTH_CHECK_RETRIES,
  ): Promise<boolean> {
    for (let i = 0; i < retries; i++) {
      try {
        const { stdout } = await execAsync(
          `docker compose ps --format json ${serviceName}`,
        );
        const serviceInfo = JSON.parse(stdout);

        if (
          serviceInfo.Health === 'healthy' ||
          serviceInfo.State === 'running'
        ) {
          return true;
        }
      } catch (error) {
        // Service not ready yet
      }

      await new Promise((resolve) => setTimeout(resolve, HEALTH_CHECK_INTERVAL));
    }
    return false;
  }

  /**
   * Helper function to check HTTP endpoint
   */
  async function checkHttpEndpoint(url: string): Promise<boolean> {
    try {
      const response = await fetch(url);
      return response.ok;
    } catch (error) {
      return false;
    }
  }

  describe('Core Services', () => {
    beforeAll(async () => {
      // Ensure clean state
      await dockerCompose('down -v').catch(() => {});
    }, TIMEOUT);

    afterAll(async () => {
      // Cleanup
      await dockerCompose('down -v').catch(() => {});
    }, TIMEOUT);

    it(
      'should start PostgreSQL with health check',
      async () => {
        // Start only PostgreSQL
        await dockerCompose('up -d postgres');

        // Wait for service to be healthy
        const isHealthy = await waitForService('postgres');
        expect(isHealthy).toBe(true);

        // Verify container is running
        const ps = await dockerCompose('ps postgres');
        expect(ps).toContain('mosaic-postgres');
        expect(ps).toContain('Up');
      },
      TIMEOUT,
    );

    it(
      'should start Valkey with health check',
      async () => {
        // Start Valkey
        await dockerCompose('up -d valkey');

        // Wait for service to be healthy
        const isHealthy = await waitForService('valkey');
        expect(isHealthy).toBe(true);

        // Verify container is running
        const ps = await dockerCompose('ps valkey');
        expect(ps).toContain('mosaic-valkey');
        expect(ps).toContain('Up');
      },
      TIMEOUT,
    );

    it(
      'should have proper network configuration',
      async () => {
        // Check if mosaic-internal network exists
        const { stdout } = await execAsync('docker network ls');
        expect(stdout).toContain('mosaic-internal');
        expect(stdout).toContain('mosaic-public');
      },
      TIMEOUT,
    );

    it(
      'should have proper volume configuration',
      async () => {
        // Check if volumes are created
        const { stdout } = await execAsync('docker volume ls');
        expect(stdout).toContain('mosaic-postgres-data');
        expect(stdout).toContain('mosaic-valkey-data');
      },
      TIMEOUT,
    );
  });

  describe('Application Services', () => {
    beforeAll(async () => {
      // Start core services first
      await dockerCompose('up -d postgres valkey');
      await waitForService('postgres');
      await waitForService('valkey');
    }, TIMEOUT);

    afterAll(async () => {
      await dockerCompose('down -v').catch(() => {});
    }, TIMEOUT);

    it(
      'should start API service with dependencies',
      async () => {
        // Start API
        await dockerCompose('up -d api');

        // Wait for API to be healthy
        const isHealthy = await waitForService('api');
        expect(isHealthy).toBe(true);

        // Verify API is accessible
        const apiHealthy = await checkHttpEndpoint('http://localhost:3001/health');
        expect(apiHealthy).toBe(true);
      },
      TIMEOUT,
    );

    it(
      'should start Web service with dependencies',
      async () => {
        // Ensure API is running
        await dockerCompose('up -d api');
        await waitForService('api');

        // Start Web
        await dockerCompose('up -d web');

        // Wait for Web to be healthy
        const isHealthy = await waitForService('web');
        expect(isHealthy).toBe(true);

        // Verify Web is accessible
        const webHealthy = await checkHttpEndpoint('http://localhost:3000');
        expect(webHealthy).toBe(true);
      },
      TIMEOUT,
    );
  });

  describe('Optional Services (Profiles)', () => {
    afterAll(async () => {
      await dockerCompose('down -v').catch(() => {});
    }, TIMEOUT);

    it(
      'should start Authentik services with profile',
      async () => {
        // Start Authentik services using profile
        await dockerCompose('--profile authentik up -d');

        // Wait for Authentik dependencies
        await waitForService('authentik-postgres');
        await waitForService('authentik-redis');

        // Verify Authentik server starts
        const isHealthy = await waitForService('authentik-server');
        expect(isHealthy).toBe(true);

        // Verify Authentik is accessible
        const authentikHealthy = await checkHttpEndpoint(
          'http://localhost:9000/-/health/live/',
        );
        expect(authentikHealthy).toBe(true);
      },
      TIMEOUT,
    );

    it(
      'should start Ollama service with profile',
      async () => {
        // Start Ollama using profile
        await dockerCompose('--profile ollama up -d ollama');

        // Wait for Ollama to start
        const isHealthy = await waitForService('ollama');
        expect(isHealthy).toBe(true);

        // Verify Ollama is accessible
        const ollamaHealthy = await checkHttpEndpoint(
          'http://localhost:11434/api/tags',
        );
        expect(ollamaHealthy).toBe(true);
      },
      TIMEOUT,
    );
  });

  describe('Full Stack', () => {
    it(
      'should start entire stack with all services',
      async () => {
        // Clean slate
        await dockerCompose('down -v').catch(() => {});

        // Start all core services (without profiles)
        await dockerCompose('up -d');

        // Wait for all core services
        const postgresHealthy = await waitForService('postgres');
        const valkeyHealthy = await waitForService('valkey');
        const apiHealthy = await waitForService('api');
        const webHealthy = await waitForService('web');

        expect(postgresHealthy).toBe(true);
        expect(valkeyHealthy).toBe(true);
        expect(apiHealthy).toBe(true);
        expect(webHealthy).toBe(true);

        // Verify all services are running
        const ps = await dockerCompose('ps');
        expect(ps).toContain('mosaic-postgres');
        expect(ps).toContain('mosaic-valkey');
        expect(ps).toContain('mosaic-api');
        expect(ps).toContain('mosaic-web');
      },
      TIMEOUT * 2,
    );
  });

  describe('Service Dependencies', () => {
    beforeAll(async () => {
      await dockerCompose('down -v').catch(() => {});
    }, TIMEOUT);

    afterAll(async () => {
      await dockerCompose('down -v').catch(() => {});
    }, TIMEOUT);

    it(
      'should enforce dependency order',
      async () => {
        // Start web service (should auto-start dependencies)
        await dockerCompose('up -d web');

        // Wait a bit for services to start
        await new Promise((resolve) => setTimeout(resolve, 10000));

        // Verify all dependencies are running
        const ps = await dockerCompose('ps');
        expect(ps).toContain('mosaic-postgres');
        expect(ps).toContain('mosaic-valkey');
        expect(ps).toContain('mosaic-api');
        expect(ps).toContain('mosaic-web');
      },
      TIMEOUT,
    );
  });

  describe('Container Labels', () => {
    beforeAll(async () => {
      await dockerCompose('up -d postgres valkey');
    }, TIMEOUT);

    afterAll(async () => {
      await dockerCompose('down -v').catch(() => {});
    }, TIMEOUT);

    it('should have proper labels on containers', async () => {
      // Check PostgreSQL labels
      const { stdout: pgLabels } = await execAsync(
        'docker inspect mosaic-postgres --format "{{json .Config.Labels}}"',
      );
      const pgLabelsObj = JSON.parse(pgLabels);
      expect(pgLabelsObj['com.mosaic.service']).toBe('database');
      expect(pgLabelsObj['com.mosaic.description']).toBeDefined();

      // Check Valkey labels
      const { stdout: valkeyLabels } = await execAsync(
        'docker inspect mosaic-valkey --format "{{json .Config.Labels}}"',
      );
      const valkeyLabelsObj = JSON.parse(valkeyLabels);
      expect(valkeyLabelsObj['com.mosaic.service']).toBe('cache');
      expect(valkeyLabelsObj['com.mosaic.description']).toBeDefined();
    });

  describe('Failure Scenarios', () => {
    const TIMEOUT = 120000;

    beforeAll(async () => {
      await dockerCompose('down -v').catch(() => {});
    }, TIMEOUT);

    afterAll(async () => {
      await dockerCompose('down -v').catch(() => {});
    }, TIMEOUT);

    it(
      'should handle service restart after crash',
      async () => {
        await dockerCompose('up -d postgres');
        await waitForService('postgres');

        const { stdout: containerName } = await execAsync(
          'docker compose ps -q postgres',
        );
        const trimmedName = containerName.trim();

        await execAsync(`docker kill ${trimmedName}`);

        await new Promise((resolve) => setTimeout(resolve, 3000));

        await dockerCompose('up -d postgres');

        const isHealthy = await waitForService('postgres');
        expect(isHealthy).toBe(true);
      },
      TIMEOUT,
    );

    it(
      'should handle port conflict gracefully',
      async () => {
        try {
          const { stdout } = await execAsync(
            'docker run -d -p 5432:5432 --name port-blocker postgres:17-alpine',
          );

          await dockerCompose('up -d postgres').catch((error) => {
            expect(error.message).toContain('port is already allocated');
          });
        } finally {
          await execAsync('docker rm -f port-blocker').catch(() => {});
        }
      },
      TIMEOUT,
    );

    it(
      'should handle invalid volume mount paths',
      async () => {
        try {
          await execAsync(
            'docker run -d --name invalid-mount -v /nonexistent/path:/data postgres:17-alpine',
          );

          const { stdout } = await execAsync(
            'docker ps -a -f name=invalid-mount --format "{{.Status}}"',
          );

          expect(stdout).toBeDefined();
        } catch (error) {
          expect(error).toBeDefined();
        } finally {
          await execAsync('docker rm -f invalid-mount').catch(() => {});
        }
      },
      TIMEOUT,
    );

    it(
      'should handle network partition scenarios',
      async () => {
        await dockerCompose('up -d postgres valkey');
        await waitForService('postgres');
        await waitForService('valkey');

        const { stdout: postgresContainer } = await execAsync(
          'docker compose ps -q postgres',
        );
        const trimmedPostgres = postgresContainer.trim();

        await execAsync(
          `docker network disconnect mosaic-internal ${trimmedPostgres}`,
        );

        await new Promise((resolve) => setTimeout(resolve, 2000));

        await execAsync(
          `docker network connect mosaic-internal ${trimmedPostgres}`,
        );

        const isHealthy = await waitForService('postgres');
        expect(isHealthy).toBe(true);
      },
      TIMEOUT,
    );

    it(
      'should handle container out of memory scenario',
      async () => {
        try {
          const { stdout } = await execAsync(
            'docker run -d --name mem-limited --memory="10m" postgres:17-alpine',
          );

          await new Promise((resolve) => setTimeout(resolve, 5000));

          const { stdout: status } = await execAsync(
            'docker inspect mem-limited --format "{{.State.Status}}"',
          );

          expect(['exited', 'running']).toContain(status.trim());
        } finally {
          await execAsync('docker rm -f mem-limited').catch(() => {});
        }
      },
      TIMEOUT,
    );

    it(
      'should handle disk space issues gracefully',
      async () => {
        await dockerCompose('up -d postgres');
        await waitForService('postgres');

        const { stdout } = await execAsync('docker system df');
        expect(stdout).toContain('Images');
        expect(stdout).toContain('Containers');
        expect(stdout).toContain('Volumes');
      },
      TIMEOUT,
    );

    it(
      'should handle service dependency failures',
      async () => {
        await dockerCompose('up -d postgres').catch(() => {});

        const { stdout: postgresContainer } = await execAsync(
          'docker compose ps -q postgres',
        );
        const trimmedPostgres = postgresContainer.trim();

        if (trimmedPostgres) {
          await execAsync(`docker stop ${trimmedPostgres}`);

          try {
            await dockerCompose('up -d api');
          } catch (error) {
            expect(error).toBeDefined();
          }

          await dockerCompose('start postgres').catch(() => {});
          await waitForService('postgres');

          await dockerCompose('up -d api');
          const apiHealthy = await waitForService('api');
          expect(apiHealthy).toBe(true);
        }
      },
      TIMEOUT,
    );

    it(
      'should recover from corrupted volume data',
      async () => {
        await dockerCompose('up -d postgres');
        await waitForService('postgres');

        await dockerCompose('down');

        await execAsync('docker volume rm mosaic-postgres-data').catch(() => {});

        await dockerCompose('up -d postgres');
        const isHealthy = await waitForService('postgres');
        expect(isHealthy).toBe(true);
      },
      TIMEOUT,
    );
  });
});