import { Transform, Writable } from 'node:stream';
import type { pipeline as pipelineType } from 'node:stream/promises';
import type * as zlib from 'node:zlib';
import type { extract as tarExtractType } from 'tar';
import { beforeEach, describe, expect, test, vi } from 'vitest';
import {
  type ArchiveDownloadOptions,
  downloadGitHubArchive,
  isArchiveDownloadSupported,
  type ProgressCallback,
} from '../../../src/core/git/gitHubArchive.js';
import type { GitHubRepoInfo } from '../../../src/core/git/gitRemoteParse.js';
import { RepomixError } from '../../../src/shared/errorHandle.js';

// Mock modules
vi.mock('../../../src/shared/logger');

// Type for the deps parameter of downloadGitHubArchive
interface MockDeps {
  fetch: typeof globalThis.fetch;
  pipeline: typeof pipelineType;
  Transform: typeof Transform;
  tarExtract: typeof tarExtractType;
  createGunzip: typeof zlib.createGunzip;
}

// Simple test data
const mockStreamData = new Uint8Array([0x1f, 0x8b, 0x08, 0x00]); // gzip magic bytes

describe('gitHubArchive', () => {
  let mockFetch: ReturnType<typeof vi.fn<typeof globalThis.fetch>>;
  let mockPipeline: ReturnType<typeof vi.fn<typeof pipelineType>>;
  let mockTarExtract: ReturnType<typeof vi.fn<typeof tarExtractType>>;
  let mockCreateGunzip: ReturnType<typeof vi.fn<typeof zlib.createGunzip>>;
  let mockDeps: MockDeps;

  beforeEach(() => {
    vi.clearAllMocks();

    mockFetch = vi.fn<typeof globalThis.fetch>();
    mockPipeline = vi.fn<typeof pipelineType>().mockResolvedValue(undefined);
    mockTarExtract = vi.fn<typeof tarExtractType>().mockReturnValue(
      new Writable({
        write(_chunk, _enc, cb) {
          cb();
        },
      }) as unknown as ReturnType<typeof tarExtractType>,
    );
    mockCreateGunzip = vi.fn<typeof zlib.createGunzip>().mockReturnValue(
      new Transform({
        transform(chunk, _enc, cb) {
          cb(null, chunk);
        },
      }) as unknown as ReturnType<typeof zlib.createGunzip>,
    );

    mockDeps = {
      fetch: mockFetch,
      pipeline: mockPipeline as unknown as typeof pipelineType,
      Transform,
      tarExtract: mockTarExtract as unknown as typeof tarExtractType,
      createGunzip: mockCreateGunzip as unknown as typeof zlib.createGunzip,
    };
  });

  describe('downloadGitHubArchive', () => {
    const mockRepoInfo: GitHubRepoInfo = {
      owner: 'yamadashy',
      repo: 'repomix',
      ref: 'main',
    };

    const mockTargetDirectory = '/test/target';
    const mockOptions: ArchiveDownloadOptions = {
      timeout: 30000,
      retries: 3,
    };

    const createMockResponse = (overrides: Partial<Response> = {}): Response => {
      return {
        ok: true,
        status: 200,
        headers: new Map([['content-length', mockStreamData.length.toString()]]),
        body: new ReadableStream({
          start(controller) {
            controller.enqueue(mockStreamData);
            controller.close();
          },
        }),
        ...overrides,
      } as unknown as Response;
    };

    test('should successfully download and extract archive', async () => {
      mockFetch.mockResolvedValue(createMockResponse());

      await downloadGitHubArchive(mockRepoInfo, mockTargetDirectory, mockOptions, undefined, mockDeps);

      // Verify fetch was called with tar.gz URL
      expect(mockFetch).toHaveBeenCalledWith(
        'https://github.com/yamadashy/repomix/archive/refs/heads/main.tar.gz',
        expect.objectContaining({
          signal: expect.any(AbortSignal),
        }),
      );

      // Verify tar extract was called with correct options
      expect(mockTarExtract).toHaveBeenCalledWith({
        cwd: mockTargetDirectory,
        strip: 1,
      });

      // Verify streaming pipeline was used
      expect(mockPipeline).toHaveBeenCalledTimes(1);
    });

    test('should handle progress callback', async () => {
      const mockProgressCallback: ProgressCallback = vi.fn();
      mockFetch.mockResolvedValue(createMockResponse());

      await downloadGitHubArchive(mockRepoInfo, mockTargetDirectory, mockOptions, mockProgressCallback, mockDeps);

      expect(mockFetch).toHaveBeenCalled();
      expect(mockPipeline).toHaveBeenCalled();
    });

    test('should retry on network failure', async () => {
      mockFetch
        .mockRejectedValueOnce(new Error('Network error'))
        .mockRejectedValueOnce(new Error('Network error'))
        .mockResolvedValueOnce(createMockResponse());

      await downloadGitHubArchive(mockRepoInfo, mockTargetDirectory, { retries: 2 }, undefined, mockDeps);

      expect(mockFetch).toHaveBeenCalledTimes(3);
    });

    test('should try fallback URLs on 404', async () => {
      mockFetch
        .mockResolvedValueOnce(
          createMockResponse({
            ok: false,
            status: 404,
            headers: new Map(),
            body: null,
          } as unknown as Partial<Response>),
        )
        .mockResolvedValueOnce(createMockResponse());

      const repoInfoNoRef = { owner: 'yamadashy', repo: 'repomix' };

      await downloadGitHubArchive(repoInfoNoRef, mockTargetDirectory, mockOptions, undefined, mockDeps);

      // Should try HEAD first, then master branch
      expect(mockFetch).toHaveBeenCalledWith(
        'https://github.com/yamadashy/repomix/archive/HEAD.tar.gz',
        expect.any(Object),
      );
      expect(mockFetch).toHaveBeenCalledWith(
        'https://github.com/yamadashy/repomix/archive/refs/heads/master.tar.gz',
        expect.any(Object),
      );
    });

    test('should throw error after all retries fail', async () => {
      mockFetch.mockRejectedValue(new Error('Network error'));

      await expect(
        downloadGitHubArchive(mockRepoInfo, mockTargetDirectory, { retries: 2 }, undefined, mockDeps),
      ).rejects.toThrow(RepomixError);

      // 2 retries × 2 URLs (main + tag for "main" ref) = 4 total attempts
      expect(mockFetch).toHaveBeenCalledTimes(4);
    });

    test('should handle extraction error', async () => {
      mockFetch.mockResolvedValue(createMockResponse());
      mockPipeline.mockRejectedValue(new Error('tar extraction failed'));

      await expect(
        downloadGitHubArchive(mockRepoInfo, mockTargetDirectory, { retries: 1 }, undefined, mockDeps),
      ).rejects.toThrow(RepomixError);
    });

    test('should handle missing response body', async () => {
      mockFetch.mockResolvedValue(createMockResponse({ body: null } as unknown as Partial<Response>));

      await expect(
        downloadGitHubArchive(mockRepoInfo, mockTargetDirectory, { retries: 1 }, undefined, mockDeps),
      ).rejects.toThrow(RepomixError);
    });

    test('should handle timeout', async () => {
      mockFetch.mockImplementation(
        (_url: string | URL | Request, init?: RequestInit) =>
          new Promise((resolve, reject) => {
            const timer = setTimeout(() => {
              resolve(createMockResponse());
            }, 100);

            // Respect AbortSignal so timeout actually cancels the fetch
            init?.signal?.addEventListener('abort', () => {
              clearTimeout(timer);
              reject(new DOMException('The operation was aborted', 'AbortError'));
            });
          }),
      );

      const shortTimeout = 50;

      await expect(
        downloadGitHubArchive(
          mockRepoInfo,
          mockTargetDirectory,
          { timeout: shortTimeout, retries: 1 },
          undefined,
          mockDeps,
        ),
      ).rejects.toThrow();
    });
  });

  describe('isArchiveDownloadSupported', () => {
    test('should return true for any GitHub repository', () => {
      const repoInfo: GitHubRepoInfo = {
        owner: 'yamadashy',
        repo: 'repomix',
      };

      const result = isArchiveDownloadSupported(repoInfo);
      expect(result).toBe(true);
    });

    test('should return true for repository with ref', () => {
      const repoInfo: GitHubRepoInfo = {
        owner: 'yamadashy',
        repo: 'repomix',
        ref: 'develop',
      };

      const result = isArchiveDownloadSupported(repoInfo);
      expect(result).toBe(true);
    });
  });
});