provider

type AnalysisMode string

type BaseClient interface {
	Capabilities() []Capability
	// Init initiates and returns a service client along with additional init config for the builtin provider
	Init(context.Context, logr.Logger, InitConfig) (ServiceClient, InitConfig, error)
}

type Capability struct {
	Name   string
	Input  openapi3.SchemaOrRef
	Output openapi3.SchemaOrRef
}

type Client interface {
	BaseClient
	ServiceClient
}

type CodeSnipProvider struct {
	Providers []engine.CodeSnip
}

type ConditionsByCap struct {
	Cap        string   `json:"cap"`
	Conditions [][]byte `json:"conditions"`
}

type Config struct {
	Name         string       `yaml:"name,omitempty" json:"name,omitempty"`
	BinaryPath   string       `yaml:"binaryPath,omitempty" json:"binaryPath,omitempty"`
	Address      string       `yaml:"address,omitempty" json:"address,omitempty"`
	UseSocket    bool         `yaml:"useSocket,omitempty" json:"useSocket,omitempty"`
	CertPath     string       `yaml:"certPath,omitempty" json:"certPath,omitempty"`
	JWTToken     string       `yaml:"jwtToken,omitempty" json:"jwtToken,omitempty"`
	Proxy        *Proxy       `yaml:"proxyConfig,omitempty" json:"proxyConfig,omitempty"`
	InitConfig   []InitConfig `yaml:"initConfig,omitempty" json:"initConfig,omitempty"`
	ContextLines int
	// PrepareProgressReporter is an optional interface for reporting progress during Prepare() phase.
	// Used by GRPC providers to report progress during provider initialization.
	PrepareProgressReporter PrepareProgressReporter `yaml:"-" json:"-"`
	LogLevel                *int                    `yaml:"logLevel,omitempty" json:"logLevel,omitempty"`
}

type Dep = konveyor.Dep

type DepDAGItem = konveyor.DepDAGItem

type DependencyCondition struct {
	DependencyConditionCap

	Client Client
}

type DependencyConditionCap struct {
	Upperbound string `json:"upperbound,omitempty" title:"Upperbound" description:"Match versions lower than or equal to"`
	Lowerbound string `json:"lowerbound,omitempty" title:"Lowerbound" description:"Match versions greater than or equal to"`
	Name       string `json:"name" title:"Name" description:"Name of the dependency"`

	// NameRegex will be a valid go regex that will be used to
	// search the name of a given dependency.
	// Examples include kubernetes* or jakarta-.*-2.2.
	NameRegex string `json:"name_regex,omitempty" title:"NameRegex" description:"Regex pattern to match the name"`
}

type DependencyLocationResolver interface {
	GetLocation(ctx context.Context, dep konveyor.Dep, depFile string) (engine.Location, error)
}

type ExternalLinks struct {
	URL   string `yaml:"url"`
	Title string `yaml:"title"`
}

type FileChange struct {
	Path    string
	Content string
	Saved   bool
}

type FileSearcher struct {
	BasePath string
	// additional search paths can be added e.g. working copy paths
	AdditionalPaths           []string
	ProviderConfigConstraints IncludeExcludeConstraints
	RuleScopeConstraints      IncludeExcludeConstraints
	// fail on first file operation error
	FailFast bool
	Log      logr.Logger
}

type IncidentContext struct {
	FileURI              uri.URI                `yaml:"fileURI"`
	Effort               *int                   `yaml:"effort,omitempty"`
	LineNumber           *int                   `yaml:"lineNumber,omitempty"`
	Variables            map[string]interface{} `yaml:"variables,omitempty"`
	Links                []ExternalLinks        `yaml:"externalLink,omitempty"`
	CodeLocation         *Location              `yaml:"location,omitempty"`
	IsDependencyIncident bool
}

type IncludeExcludeConstraints struct {
	IncludePathsOrPatterns []string
	ExcludePathsOrPatterns []string
}

type InitConfig struct {
	// This is the location of the code base that the
	// Provider will be responisble for parsing
	// TODO: rootUri, which is what this maps to in the LSP spec, is deprecated.
	// We should instead use workspaceFolders.
	Location string `yaml:"location,omitempty" json:"location,omitempty"`

	// This is the path to look for the dependencies for the project.
	// It is relative to the Location
	// TODO: This only allows for one directory for dependencies. Use DependencyFolders instead
	DependencyPath string `yaml:"dependencyPath,omitempty" json:"dependencyPath,omitempty"`

	AnalysisMode AnalysisMode `yaml:"analysisMode" json:"analysisMode"`

	// This will have to be defined for each provider
	ProviderSpecificConfig map[string]interface{} `yaml:"providerSpecificConfig,omitempty" json:"providerSpecificConfig,omitempty"`

	Proxy *Proxy `yaml:"proxyConfig,omitempty" json:"proxyConfig,omitempty"`

	// This will be unusable connecting over a network but can be used in code.
	RPC RPCClient `yaml:"-" json:"-"`

	PipeName string `yaml:"pipeName" json:"pipeName"`

	// Given a pipe name for the init config, we will use that pipe and connect to an already inited provider.
	Initialized bool `yaml:"initialized" json:"initialized"`

	// LogLevel for the provider logger verbosity
	LogLevel *int `yaml:"logLevel,omitempty" json:"logLevel,omitempty"`

	// PrepareProgressReporter is an optional interface for reporting progress during Prepare() phase.
	// If provided, the provider will call ReportProgress() as it processes files during symbol cache population.
	PrepareProgressReporter PrepareProgressReporter `yaml:"-" json:"-"`
}

type InternalInit interface {
	ProviderInit(context.Context, []InitConfig) ([]InitConfig, error)
}

type InternalProviderClient interface {
	InternalInit
	Client
}

type Location struct {
	StartPosition Position
	EndPosition   Position
}

type Position struct {
	/*Line defined:
	 * Line position in a document (zero-based).
	 * If a line number is greater than the number of lines in a document, it defaults back to the number of lines in the document.
	 * If a line number is negative, it defaults to 0.
	 */
	Line float64 `json:"line"`

	/*Character defined:
	 * Character offset on a line in a document (zero-based). Assuming that the line is
	 * represented as a string, the `character` value represents the gap between the
	 * `character` and `character + 1`.
	 *
	 * If the character value is greater than the line length it defaults back to the
	 * line length.
	 * If a line number is negative, it defaults to 0.
	 */
	Character float64 `json:"character"`
}

type PrepareProgressEvent struct {
	ProviderName   string
	FilesProcessed int
	TotalFiles     int
}

type PrepareProgressReporter interface {
	// ReportProgress reports progress for a specific provider.
	// providerName: Name of the provider (e.g., "nodejs", "java")
	// filesProcessed: Number of files processed so far
	// totalFiles: Total number of files to process
	ReportProgress(providerName string, filesProcessed, totalFiles int)
}

type PrepareProgressStreamer interface {
	// StartProgressStream creates and returns a channel for streaming progress events.
	// The returned channel will receive progress events during Prepare() phase.
	StartProgressStream() <-chan *PrepareProgressEvent

	// StopProgressStream stops the progress stream and closes the channel.
	StopProgressStream()
}

type ProviderCondition struct {
	Client           ServiceClient
	Capability       string
	ConditionInfo    interface{}
	Rule             engine.Rule
	Ignore           bool
	DepLabelSelector *labels.LabelSelector[*Dep]
}

type ProviderContext struct {
	Tags             map[string]interface{}          `yaml:"tags"`
	Template         map[string]engine.ChainTemplate `yaml:"template"`
	RuleID           string                          `yaml:"ruleID"`
	DepLabelSelector string                          `yaml:"depLabelSelector,omitempty"`
}

type ProviderEvaluateResponse struct {
	Matched         bool                   `yaml:"matched"`
	Incidents       []IncidentContext      `yaml:"incidents"`
	TemplateContext map[string]interface{} `yaml:"templateContext"`
}

type Proxy httpproxy.Config

type RPCClient interface {
	Call(context.Context, string, any) *jsonrpc2.AsyncCall
	Notify(context.Context, string, any) error
	Close() error
}

type SearchCriteria struct {
	Patterns           []string
	ConditionFilepaths []string
}

type Server interface {
	// This will start the GRPC server and will wait until the context is cancelled.
	Start(context.Context) error
}

type ServiceClient interface {
	// Prepare will pass all conditions to the provider before evaluation
	// so that the provider can pre-process conditions for faster responses
	Prepare(ctx context.Context, conditionsByCap []ConditionsByCap) error

	// Evaluate will evaluate a condition and return a response
	Evaluate(ctx context.Context, cap string, conditionInfo []byte) (ProviderEvaluateResponse, error)

	Stop()

	// GetDependencies will get the dependencies
	// It is the responsibility of the provider to determine how that is done
	GetDependencies(ctx context.Context) (map[uri.URI][]*Dep, error)
	// GetDependencies will get the dependencies and return them as a linked list
	// Top level items are direct dependencies, the rest are indirect dependencies
	GetDependenciesDAG(ctx context.Context) (map[uri.URI][]DepDAGItem, error)
	// Used to notify changes to files in the project
	NotifyFileChanges(ctx context.Context, changes ...FileChange) error
}

type Startable interface {
	Start(context.Context) error
}

type UnimplementedDependenciesComponent struct{}