dependency

type Decompiler interface {
	// DecompileIntoProject decompiles a binary artifact into a project directory structure.
	// Used for decompiling application binaries (not dependencies).
	//
	// Returns list of discovered JavaArtifacts from embedded dependencies.
	DecompileIntoProject(context context.Context, binaryPath, projectPath string) ([]JavaArtifact, error)

	// Decompile treats an artifact as a dependency and decompiles it into Maven repository structure.
	// Creates proper groupId/artifactId/version directory hierarchy in the local Maven repository.
	//
	// Returns list of JavaArtifacts including the main artifact and any discovered embedded dependencies.
	Decompile(context context.Context, binaryPath string) ([]JavaArtifact, error)
}

type DecompilerOpts struct {
	DecompileTool string // Absolute path to FernFlower decompiler JAR
	// contains filtered or unexported fields
}

type DecomplierResponse struct {
	Artifacts []JavaArtifact // List of artifacts discovered during decompilation
	// contains filtered or unexported fields
}

type IndexEntry struct {
	Key    string // The search key
	Offset int64  // Byte offset of the line in the data file
	Length int64  // Length of the line in the data file
}

type JavaArtifact struct {
	FoundOnline bool   // Whether the artifact was found in Maven Central or known OSS repositories
	Packaging   string // Archive type: .jar, .war, .ear
	GroupId     string // Maven groupId (e.g., "org.springframework")
	ArtifactId  string // Maven artifactId (e.g., "spring-core")
	Version     string // Maven version (e.g., "5.3.21")
	Sha1        string // SHA1 hash for verification and lookups
}

type Resolver interface {
	// ResolveSources downloads dependency sources and decompiles JARs that lack source artifacts.
	// This is a critical step for enabling deep code analysis, as it ensures the language server
	// has access to all dependency source code.
	//
	// Process:
	//   1. Execute build tool command to download available source JARs
	//   2. Parse output to identify dependencies without sources
	//   3. Locate binary JARs for unresolved dependencies
	//   4. Decompile missing sources using a decompiler (parallel worker pool)
	//   5. Store decompiled sources in appropriate repository structure
	//
	// Parameters:
	//   - ctx: Context for cancellation and timeout control (typically 5-10 minute timeout)
	//
	// Returns:
	//   - sourceLocation (string): Absolute path to project source directory
	//     For source projects: Original project location
	//     For binary artifacts: Path to generated project directory
	//   - dependencyLocation (string): Absolute path to local dependency repository
	//     May be empty string if the build tool uses a different caching mechanism
	//   - error: Error if source resolution fails
	//
	// Example Usage:
	//   resolver, _ := buildTool.GetResolver("/path/to/decompiler.jar")
	//   srcPath, depPath, err := resolver.ResolveSources(ctx)
	//   if err != nil {
	//       // Handle resolution failure
	//   }
	//   // srcPath: Project directory with sources
	//   // depPath: Repository with dependency sources (may be empty)
	//
	// Performance Considerations:
	//   - Uses worker pool for parallel decompilation
	//   - Can take several minutes for large projects with many dependencies
	//   - Progress logged at various verbosity levels
	//   - Individual decompilation failures logged but don't stop overall process
	//
	// Error Handling:
	//   - Returns error if build tool command fails completely
	//   - Returns error if decompiler initialization fails
	//   - Logs individual JAR decompilation failures but continues
	//   - May cache errors to avoid repeated failures
	ResolveSources(ctx context.Context) (sourceLocation string, dependencyLocation string, err error)
}

type ResolverOptions struct {
	// Log is the logger instance for logging resolver operations.
	// Used by all resolver types for progress tracking and error reporting.
	Log logr.Logger

	// Location is the absolute path to the project directory or binary artifact.
	// Points to the root of the project or the binary file to be analyzed.
	Location string

	// DecompileTool is the absolute path to the decompiler JAR.
	// Required by all resolver types for decompiling dependencies without sources.
	DecompileTool string

	// Labeler identifies whether dependencies are open source or internal.
	// Used to determine if remote repository lookups should be attempted.
	Labeler labels.Labeler

	// LocalRepo is the path to the local dependency repository where
	// dependencies and their sources are cached.
	// May not be used by all build tools.
	LocalRepo string

	// BuildFile points to build tool-specific configuration file.
	// May be a settings file or build definition depending on the build tool.
	BuildFile string

	// GlobalBuildFile points to build-tool specific global configuration file
	// May be a settings file or build definition depending on the build tool.
	GlobalBuildFile string

	// Insecure allows insecure HTTPS connections when downloading dependencies.
	// Should only be used in development/testing environments.
	Insecure bool

	// Version is the build tool version detected from the project.
	// Used by some resolvers to determine compatibility requirements.
	Version version.Version

	// Wrapper is the absolute path to the build tool wrapper executable.
	// Used by build tools that support wrapper scripts for reproducible builds.
	Wrapper string

	// JavaHome is the path to the Java installation to use for build tool execution.
	// May be set based on build tool version requirements.
	JavaHome string

	// GradleTaskFile is the path to a custom task file for source download.
	// Optional custom task file to use instead of embedded defaults.
	GradleTaskFile string

	// MavenIndexPath is the path to a Maven index for artifact metadata searches.
	// Used to look up artifact information when identifying dependencies.
	MavenIndexPath string
}