import type * as stream from 'node:stream';
import type { SmartFile, StreamFile } from '@push.rocks/smartfile';

/**
 * Supported archive formats
 */
export type TArchiveFormat = 'tar' | 'tar.gz' | 'tgz' | 'zip' | 'gz' | 'bz2';

/**
 * Compression level (0 = no compression, 9 = maximum compression)
 */
export type TCompressionLevel = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9;

/**
 * Supported MIME types for archive detection
 */
export type TSupportedMime =
  | 'application/gzip'
  | 'application/zip'
  | 'application/x-bzip2'
  | 'application/x-tar'
  | undefined;

/**
 * Entry to add to an archive during creation
 */
export interface IArchiveEntry {
  /** Path within the archive */
  archivePath: string;
  /** Content: string, Buffer, Readable stream, SmartFile, or StreamFile */
  content: string | Buffer | stream.Readable | SmartFile | StreamFile;
  /** Optional size hint for streams (improves performance) */
  size?: number;
  /** Optional file mode/permissions */
  mode?: number;
  /** Optional modification time */
  mtime?: Date;
}

/**
 * Options for creating archives
 */
export interface IArchiveCreationOptions {
  /** Target archive format */
  format: TArchiveFormat;
  /** Compression level (0-9, default depends on format) */
  compressionLevel?: TCompressionLevel;
  /** Base path to strip from file paths in archive */
  basePath?: string;
}

/**
 * Options for extracting archives
 */
export interface IArchiveExtractionOptions {
  /** Target directory for extraction */
  targetDir: string;
  /** Optional filename for single-file archives (gz, bz2) */
  fileName?: string;
  /** Number of leading path components to strip */
  stripComponents?: number;
  /** Filter function to select which entries to extract */
  filter?: (entry: IArchiveEntryInfo) => boolean;
  /** Whether to overwrite existing files */
  overwrite?: boolean;
}

/**
 * Information about an archive entry
 */
export interface IArchiveEntryInfo {
  /** Path of the entry within the archive */
  path: string;
  /** Size in bytes */
  size: number;
  /** Whether this entry is a directory */
  isDirectory: boolean;
  /** Whether this entry is a file */
  isFile: boolean;
  /** Modification time */
  mtime?: Date;
  /** File mode/permissions */
  mode?: number;
}

/**
 * Result of archive analysis
 */
export interface IArchiveInfo {
  /** Detected archive format */
  format: TArchiveFormat | null;
  /** Whether the archive is compressed */
  isCompressed: boolean;
  /** Whether this is a recognized archive format */
  isArchive: boolean;
  /** List of entries (if available without full extraction) */
  entries?: IArchiveEntryInfo[];
}

/**
 * Options for adding a file to a TAR pack stream
 */
export interface IAddFileOptions {
  /** Filename within the archive */
  fileName?: string;
  /** File content */
  content?: string | Buffer | stream.Readable | SmartFile | StreamFile;
  /** Size in bytes (required for streams) */
  byteLength?: number;
  /** Path to file on disk (alternative to content) */
  filePath?: string;
}

/**
 * Bit reader interface for BZIP2 decompression
 */
export interface IBitReader {
  (n: number | null): number | void;
  bytesRead: number;
}

/**
 * Huffman group for BZIP2 decompression
 */
export interface IHuffmanGroup {
  permute: Int32Array;
  limit: Int32Array;
  base: Int32Array;
  minLen: number;
  maxLen: number;
}

/**
 * Entry filter predicate for fluent API
 */
export type TEntryFilter = (entry: IArchiveEntryInfo) => boolean;