tool

type CompatibilityResult struct {
	// Compatible asset types (can be scanned)
	CompatibleTypes []asset.AssetType

	// Incompatible asset types (will be skipped)
	IncompatibleTypes []asset.AssetType

	// Total counts
	TotalAssetTypes      int
	CompatibleCount      int
	IncompatibleCount    int
	CompatibilityPercent float64

	// Whether any unclassified assets exist
	HasUnclassified   bool
	UnclassifiedCount int
}

type CustomPattern struct {
	Name    string `json:"name"`
	Pattern string `json:"pattern"`
}

type CustomTemplate struct {
	Name    string `json:"name"`
	Path    string `json:"path,omitempty"`    // File path if stored on disk
	Content string `json:"content,omitempty"` // Content if stored in DB
}

type CustomWordlist struct {
	Name string `json:"name"`
	Path string `json:"path"`
}

type EmbeddedCategory struct {
	ID          shared.ID
	Name        string // slug: 'sast', 'dast', etc.
	DisplayName string // 'SAST', 'DAST', etc.
	Icon        string
	Color       string
}

type ExecutionStatus string

type InstallMethod string

type Repository interface {
	// Tool operations (system-wide)
	Create(ctx context.Context, tool *Tool) error
	GetByID(ctx context.Context, id shared.ID) (*Tool, error)
	GetByName(ctx context.Context, name string) (*Tool, error)
	List(ctx context.Context, filter ToolFilter, page pagination.Pagination) (pagination.Result[*Tool], error)
	ListByNames(ctx context.Context, names []string) ([]*Tool, error)
	ListByCategoryID(ctx context.Context, categoryID shared.ID) ([]*Tool, error)
	ListByCategoryName(ctx context.Context, categoryName string) ([]*Tool, error)
	ListByCapability(ctx context.Context, capability string) ([]*Tool, error)
	// FindByCapabilities finds an active tool that matches all required capabilities.
	// Searches platform tools first, then tenant-specific tools.
	// Returns nil if no matching active tool is found.
	FindByCapabilities(ctx context.Context, tenantID shared.ID, capabilities []string) (*Tool, error)
	Update(ctx context.Context, tool *Tool) error
	Delete(ctx context.Context, id shared.ID) error

	// Tenant custom tools operations
	GetByTenantAndID(ctx context.Context, tenantID, id shared.ID) (*Tool, error)
	GetByTenantAndName(ctx context.Context, tenantID shared.ID, name string) (*Tool, error)
	GetPlatformToolByName(ctx context.Context, name string) (*Tool, error)
	ListPlatformTools(ctx context.Context, filter ToolFilter, page pagination.Pagination) (pagination.Result[*Tool], error)
	ListTenantCustomTools(ctx context.Context, tenantID shared.ID, filter ToolFilter, page pagination.Pagination) (pagination.Result[*Tool], error)
	ListAvailableTools(ctx context.Context, tenantID shared.ID, filter ToolFilter, page pagination.Pagination) (pagination.Result[*Tool], error) // Platform + tenant's custom tools
	DeleteTenantTool(ctx context.Context, tenantID, id shared.ID) error

	// Bulk operations
	BulkCreate(ctx context.Context, tools []*Tool) error
	BulkUpdateVersions(ctx context.Context, versions map[shared.ID]VersionInfo) error

	// Statistics
	Count(ctx context.Context, filter ToolFilter) (int64, error)

	// GetAllCapabilities returns all unique capabilities from all tools.
	// Used for dynamic capability validation.
	GetAllCapabilities(ctx context.Context) ([]string, error)
}

type TargetAssetTypeMapping struct {
	ID          shared.ID
	TargetType  string          // e.g., "url", "domain", "ip", "repository"
	AssetType   asset.AssetType // e.g., "website", "domain", "ip_address"
	Priority    int             // Lower = higher priority (10 = primary)
	IsActive    bool
	Description string // Optional description for admin UI
	CreatedAt   time.Time
	UpdatedAt   time.Time
	CreatedBy   *shared.ID // Optional: who created this mapping
}

type TargetMappingFilter struct {
	TargetType  *string  // Filter by specific target type
	AssetType   *string  // Filter by specific asset type
	IsActive    *bool    // Filter by active status
	TargetTypes []string // Filter by multiple target types (IN clause)
	AssetTypes  []string // Filter by multiple asset types (IN clause)
}

type TargetMappingRepository interface {
	// CRUD operations
	Create(ctx context.Context, mapping *TargetAssetTypeMapping) error
	GetByID(ctx context.Context, id shared.ID) (*TargetAssetTypeMapping, error)
	Update(ctx context.Context, mapping *TargetAssetTypeMapping) error
	Delete(ctx context.Context, id shared.ID) error
	List(ctx context.Context, filter TargetMappingFilter, page pagination.Pagination) (pagination.Result[*TargetAssetTypeMapping], error)

	// Compatibility check methods
	// GetAssetTypesForTargets returns all asset types that can be scanned by the given target types.
	// Example: GetAssetTypesForTargets(["url", "domain"]) -> ["website", "web_application", "domain", "subdomain"]
	GetAssetTypesForTargets(ctx context.Context, targetTypes []string) ([]asset.AssetType, error)

	// GetTargetsForAssetType returns all target types that can scan the given asset type.
	// Example: GetTargetsForAssetType("website") -> ["url"]
	GetTargetsForAssetType(ctx context.Context, assetType asset.AssetType) ([]string, error)

	// CanToolScanAssetType checks if a tool (via its supported_targets) can scan a specific asset type.
	// Returns true if any of the tool's target types map to the asset type.
	CanToolScanAssetType(ctx context.Context, targetTypes []string, assetType asset.AssetType) (bool, error)

	// GetIncompatibleAssetTypes returns asset types from the list that CANNOT be scanned
	// by any of the given target types.
	GetIncompatibleAssetTypes(ctx context.Context, targetTypes []string, assetTypes []asset.AssetType) ([]asset.AssetType, error)

	// GetCompatibleAssetTypes returns asset types from the list that CAN be scanned
	// by at least one of the given target types.
	GetCompatibleAssetTypes(ctx context.Context, targetTypes []string, assetTypes []asset.AssetType) ([]asset.AssetType, error)
}

type TenantToolConfig struct {
	ID       shared.ID
	TenantID shared.ID
	ToolID   shared.ID

	// Configuration override (merged with tool's DefaultConfig)
	Config map[string]any

	// Custom templates (e.g., Nuclei templates)
	CustomTemplates []CustomTemplate

	// Custom patterns (e.g., GF patterns, regex patterns)
	CustomPatterns []CustomPattern

	// Custom wordlists
	CustomWordlists []CustomWordlist

	// Status
	IsEnabled bool

	// Audit
	UpdatedBy *shared.ID
	CreatedAt time.Time
	UpdatedAt time.Time
}

type TenantToolConfigFilter struct {
	TenantID  shared.ID
	ToolID    *shared.ID
	IsEnabled *bool
}

type TenantToolConfigRepository interface {
	// CRUD operations
	Create(ctx context.Context, config *TenantToolConfig) error
	GetByID(ctx context.Context, id shared.ID) (*TenantToolConfig, error)
	GetByTenantAndTool(ctx context.Context, tenantID, toolID shared.ID) (*TenantToolConfig, error)
	List(ctx context.Context, filter TenantToolConfigFilter, page pagination.Pagination) (pagination.Result[*TenantToolConfig], error)
	Update(ctx context.Context, config *TenantToolConfig) error
	Delete(ctx context.Context, id shared.ID) error

	// Upsert - Create or update config
	Upsert(ctx context.Context, config *TenantToolConfig) error

	// Get effective config (merged default + tenant override)
	GetEffectiveConfig(ctx context.Context, tenantID, toolID shared.ID) (map[string]any, error)

	// List all enabled tools for a tenant
	ListEnabledTools(ctx context.Context, tenantID shared.ID) ([]*TenantToolConfig, error)

	// List all tools with their tenant-specific enabled status
	// Returns tools joined with tenant configs, where is_enabled defaults to true if no config exists
	ListToolsWithConfig(ctx context.Context, tenantID shared.ID, filter ToolFilter, page pagination.Pagination) (pagination.Result[*ToolWithConfig], error)

	// Bulk enable/disable tools for tenant
	BulkEnable(ctx context.Context, tenantID shared.ID, toolIDs []shared.ID) error
	BulkDisable(ctx context.Context, tenantID shared.ID, toolIDs []shared.ID) error
}

type TenantToolStats struct {
	TenantID       shared.ID
	TotalRuns      int64
	SuccessfulRuns int64
	FailedRuns     int64
	TotalFindings  int64
	ToolBreakdown  []ToolStats
}

type Tool struct {
	ID          shared.ID
	TenantID    *shared.ID // nil = platform tool, UUID = tenant custom tool
	Name        string     // Unique identifier: 'semgrep', 'nuclei', etc.
	DisplayName string
	Description string
	LogoURL     string
	CategoryID  *shared.ID // Foreign key to tool_categories table

	// Installation
	InstallMethod InstallMethod
	InstallCmd    string
	UpdateCmd     string

	// Version tracking
	VersionCmd     string // Command to check version
	VersionRegex   string // Regex to extract version from output
	CurrentVersion string // Currently installed version
	LatestVersion  string // Latest available version

	// Configuration
	ConfigFilePath string         // Path to config file, e.g., '/root/.config/nuclei/config.yaml'
	ConfigSchema   map[string]any // JSON Schema for validating tool config
	DefaultConfig  map[string]any // Default configuration

	// Capabilities this tool provides (maps to agent capabilities)
	Capabilities []string

	// Supported input/output
	SupportedTargets []string // 'url', 'domain', 'ip', 'file', 'repository', 'container'
	OutputFormats    []string // 'json', 'sarif', 'csv', 'txt'

	// Documentation
	DocsURL   string
	GithubURL string

	// Status
	IsActive  bool // Tool is available for use
	IsBuiltin bool // System tool vs custom installed

	// Metadata
	Tags     []string
	Metadata map[string]any

	// Audit
	CreatedBy *shared.ID // User who created the tool (for custom tools)
	CreatedAt time.Time
	UpdatedAt time.Time
}

type ToolExecution struct {
	ID       shared.ID
	TenantID shared.ID
	ToolID   shared.ID
	AgentID  *shared.ID

	// Execution context
	PipelineRunID *shared.ID
	StepRunID     *shared.ID

	// Status
	Status ExecutionStatus

	// Input/Output
	InputConfig   map[string]any
	TargetsCount  int
	FindingsCount int
	OutputSummary map[string]any
	ErrorMessage  string

	// Timing
	StartedAt   time.Time
	CompletedAt *time.Time
	DurationMs  int

	CreatedAt time.Time
}

type ToolExecutionFilter struct {
	TenantID      shared.ID
	ToolID        *shared.ID
	AgentID       *shared.ID
	PipelineRunID *shared.ID
	Status        *ExecutionStatus
}

type ToolExecutionRepository interface {
	Create(ctx context.Context, execution *ToolExecution) error
	GetByID(ctx context.Context, id shared.ID) (*ToolExecution, error)
	List(ctx context.Context, filter ToolExecutionFilter, page pagination.Pagination) (pagination.Result[*ToolExecution], error)
	Update(ctx context.Context, execution *ToolExecution) error

	// Statistics
	GetToolStats(ctx context.Context, tenantID, toolID shared.ID, days int) (*ToolStats, error)
	GetTenantStats(ctx context.Context, tenantID shared.ID, days int) (*TenantToolStats, error)
}

type ToolFilter struct {
	CategoryID   *shared.ID // Filter by category_id (FK to tool_categories)
	CategoryName *string    // Filter by category name (via join with tool_categories)
	Capabilities []string
	IsActive     *bool
	IsBuiltin    *bool
	Search       string
	Tags         []string

	// Tenant filtering
	TenantID        *shared.ID // Filter by specific tenant's custom tools
	IncludePlatform bool       // Include platform tools (tenant_id IS NULL)
	OnlyPlatform    bool       // Only platform tools (tenant_id IS NULL)
	OnlyCustom      bool       // Only custom tools (tenant_id IS NOT NULL)
}

type ToolStats struct {
	ToolID         shared.ID
	TotalRuns      int64
	SuccessfulRuns int64
	FailedRuns     int64
	TotalFindings  int64
	AvgDurationMs  int64
}

type ToolWithConfig struct {
	Tool            *Tool
	Category        *EmbeddedCategory // Embedded category info for UI grouping
	TenantConfig    *TenantToolConfig
	EffectiveConfig map[string]any
	IsEnabled       bool
	IsAvailable     bool // True if at least one agent (tenant or platform) supports this tool
}

type VersionInfo struct {
	CurrentVersion string
	LatestVersion  string
}