binpkg

type BinaryFormat int

type BinaryPackage struct {
	// Package is the package metadata
	Package *pkg.Package

	// Format is the binary package format (GPKG or TBZ2)
	Format BinaryFormat

	// Path is the file path to the binary package
	Path string

	// Size is the package file size in bytes
	Size int64

	// Checksum is the SHA256 checksum
	Checksum string

	// Signature is the package signature (optional)
	Signature *Signature

	// BuildInfo contains build-time metadata
	BuildInfo *BuildMetadata
}

type BinaryPackageBuilder struct {
	// Package is the installed package to build from
	Package *state.InstalledPackage

	// WorkDir is the temporary directory for building
	WorkDir string

	// OutputDir is where the final package will be placed
	OutputDir string

	// Format is the binary package format (GPKG or TBZ2)
	Format BinaryFormat

	// Compression is the compression type
	Compression CompressionType

	// Signer is optional package signer
	Signer PackageSigner

	// IncludeBuildLog includes build.log in package metadata
	IncludeBuildLog bool

	// Verbose enables detailed logging
	Verbose bool
}

type Binhost struct {
	// URI is the binhost location
	URI string

	// Type is the binhost type (local, http, etc)
	Type BinhostType

	// Packages is the list of available packages
	Packages []*BinaryPackage

	// LastSync is when the binhost was last synchronized
	LastSync time.Time
}

type BinhostManager struct {
	// Root is the binhost root directory
	Root string

	// Packages is the list of packages in binhost
	Packages []*BinaryPackage

	// Verbose enables detailed logging
	Verbose bool

	// IndexFormat is the Packages index format (portage or gentoo)
	IndexFormat string
}

type BinhostType int

type BinhostUploader interface {
	// Upload uploads a binary package
	Upload(pkg *BinaryPackage) error

	// UploadFile uploads a single file
	UploadFile(localPath, remotePath string) error

	// UploadDirectory uploads an entire directory
	UploadDirectory(localDir, remoteDir string) error
}

type BuildMetadata struct {
	// BuildDate is when the package was built
	BuildDate time.Time

	// BuildHost is the hostname where it was built
	BuildHost string

	// CFLAGS are the C compiler flags used
	CFLAGS string

	// CXXFLAGS are the C++ compiler flags used
	CXXFLAGS string

	// LDFLAGS are the linker flags used
	LDFLAGS string

	// USE contains the USE flags used during build
	USE []string

	// Features contains Portage features enabled during build
	Features []string

	// EAPI is the EAPI version
	EAPI string

	// Repository is the repository (e.g., "gentoo")
	Repository string

	// Size is the installed size in bytes
	Size int64
}

type BuildOptions struct {
	// IncludeBuildLog includes build.log in package
	IncludeBuildLog bool

	// IncludeDebugInfo includes debug symbols
	IncludeDebugInfo bool

	// StripBinaries strips binaries to reduce size
	StripBinaries bool

	// VerifyChecksums verifies file checksums before packing
	VerifyChecksums bool

	// SignPackage enables package signing
	SignPackage bool

	// SignatureType is GPG or SSH
	SignatureType SignatureType
}

type CompressionType int

type GPGSigner struct {
	// KeyID is the GPG key ID to use for signing
	KeyID string

	// Passphrase for unlocking private key (optional)
	Passphrase string

	// GPGPath is path to gpg binary (default: "gpg")
	GPGPath string

	// Armor enables ASCII armored output
	Armor bool
}

type GPKGWriter struct {
	// OutputPath is the path for the output .gpkg.tar file
	OutputPath string

	// Compression is the compression type
	Compression CompressionType

	// Verbose enables detailed logging
	Verbose bool
	// contains filtered or unexported fields
}

type HTTPUploader struct {
	// BaseURL is the binhost base URL (e.g., "https://binhost.example.com")
	BaseURL string

	// Auth is HTTP authentication
	Username string
	Password string

	// HTTPClient is the underlying HTTP client
	HTTPClient *http.Client

	// Method is HTTP method (PUT or POST)
	Method string

	// UseMultipart enables multipart/form-data for POST
	UseMultipart bool

	// Verbose enables detailed logging
	Verbose bool
}

type PackageSigner interface {
	// Sign signs a package file and returns signature
	Sign(packagePath string) (*Signature, error)

	// Verify verifies a package signature
	Verify(packagePath string, signature *Signature) error
}

type RSASigner struct {
	// PrivateKey is the RSA private key
	PrivateKey *rsa.PrivateKey

	// KeyPath is path to RSA private key file (PEM format)
	KeyPath string
}

type SSHSigner struct {
	// KeyPath is path to SSH private key
	KeyPath string

	// Passphrase for encrypted keys (optional)
	Passphrase string

	// SSHKeygenPath is path to ssh-keygen binary (default: "ssh-keygen")
	SSHKeygenPath string
}

type SSHUploader struct {
	// Host is the SSH host (e.g., "[email protected]")
	Host string

	// RemoteDir is the remote binhost directory
	RemoteDir string

	// KeyPath is path to SSH private key
	KeyPath string

	// Port is SSH port (default: 22)
	Port int

	// SCPPath is path to scp binary (default: "scp")
	SCPPath string

	// Verbose enables detailed logging
	Verbose bool
}

type SelectionResult struct {
	// UseBinary indicates whether to use binary package
	UseBinary bool

	// BinaryPackage is the selected binary package (if UseBinary is true)
	BinaryPackage *BinaryPackage

	// Binhost is the binhost containing the package (if UseBinary is true)
	Binhost *Binhost

	// Reason explains why this selection was made
	Reason string

	// Score is the compatibility score (0.0-1.0)
	Score float64
}

type SelectionStrategy int

type Selector struct {
	// Options configures selection behavior
	Options SelectorOptions

	// Binhosts is the list of available binhosts
	Binhosts []*Binhost
}

type SelectorOptions struct {
	// Strategy is the selection strategy
	Strategy SelectionStrategy

	// RequiredUSE are the USE flags that must be present
	RequiredUSE []string

	// MaxAge is the maximum age for binary packages (0 = no limit)
	MaxAge time.Duration

	// MinCoverage is minimum USE flag match percentage (0.0-1.0)
	// A value of 1.0 means all USE flags must match exactly
	MinCoverage float64

	// AllowUntrusted allows packages without valid signatures
	AllowUntrusted bool

	// PreferLocal prefers local binhost over remote
	PreferLocal bool
}

type Signature struct {
	// Type is the signature type (GPG, SSH, etc)
	Type SignatureType

	// KeyID is the signing key identifier
	KeyID string

	// Signature is the actual signature data
	Data []byte

	// Created is when the signature was created
	Created time.Time
}

type SignatureType int

type Stats struct {
	TotalBinhosts  int
	TotalPackages  int
	LocalPackages  int
	RemotePackages int
	OldestPackage  time.Time
	NewestPackage  time.Time
	AverageAge     time.Duration
}

type TBZ2Writer struct {
	// OutputPath is the path for the output .tbz2 file
	OutputPath string

	// Verbose enables detailed logging
	Verbose bool
}

type UploadOptions struct {
	// ResumeSupport enables resume for interrupted uploads
	ResumeSupport bool

	// ProgressCallback is called with upload progress (0-100)
	ProgressCallback func(percent int)

	// Timeout is the upload timeout
	Timeout time.Duration

	// RetryCount is number of retries on failure
	RetryCount int

	// VerifyChecksum verifies file checksum after upload
	VerifyChecksum bool
}

type XPAK struct {
	// Entries maps metadata keys to values
	Entries map[string][]byte
}