package graph

import (
	"context"

	"bugulma/backend/internal/domain"
)

// Calculator is the main interface for graph operations
type Calculator interface {
	// Resource chain operations
	FindResourceChains(ctx context.Context, resourceType domain.ResourceType, maxLength int, minValue float64) ([]*ResourceChain, error)

	// Symbiosis network operations
	FindSymbiosisNetworks(ctx context.Context, minOrgs int, maxSize int) ([]*SymbiosisNetwork, error)

	// Path finding operations
	FindOptimalResourcePaths(ctx context.Context, sourceOrgID, targetOrgID string, resourceType domain.ResourceType, maxHops int) ([]*ResourceChain, error)

	// Network analysis operations
	AnalyzeNetworkCentrality(ctx context.Context) (map[string]*CentralityMetrics, error)
	GetNetworkStatistics(ctx context.Context) (*NetworkStatistics, error)
	FindCircularEconomyCycles(ctx context.Context) ([]*CircularEconomyCycle, error)
}

// GraphCalculator implements the Calculator interface with proper separation of concerns
type GraphCalculator struct {
	config          *Config
	traversal       *Traversal
	pathFinder      *PathFinder
	networkAnalyzer *NetworkAnalyzer
}

// NewGraphCalculator creates a new graph calculator with all dependencies
func NewGraphCalculator(
	config *Config,
	traversal *Traversal,
	pathFinder *PathFinder,
	networkAnalyzer *NetworkAnalyzer,
) Calculator {
	return &GraphCalculator{
		config:          config,
		traversal:       traversal,
		pathFinder:      pathFinder,
		networkAnalyzer: networkAnalyzer,
	}
}

// FindResourceChains finds chains of resource flows
func (gc *GraphCalculator) FindResourceChains(
	ctx context.Context,
	resourceType domain.ResourceType,
	maxLength int,
	minValue float64,
) ([]*ResourceChain, error) {
	return gc.traversal.FindResourceChains(ctx, resourceType, maxLength, minValue)
}

// FindSymbiosisNetworks identifies interconnected industrial symbiosis networks
func (gc *GraphCalculator) FindSymbiosisNetworks(
	ctx context.Context,
	minOrgs int,
	maxSize int,
) ([]*SymbiosisNetwork, error) {
	return gc.traversal.FindSymbiosisNetworks(ctx, minOrgs, maxSize)
}

// FindOptimalResourcePaths finds the most cost-effective paths
func (gc *GraphCalculator) FindOptimalResourcePaths(
	ctx context.Context,
	sourceOrgID string,
	targetOrgID string,
	resourceType domain.ResourceType,
	maxHops int,
) ([]*ResourceChain, error) {
	return gc.pathFinder.FindOptimalResourcePaths(ctx, sourceOrgID, targetOrgID, resourceType, maxHops)
}

// AnalyzeNetworkCentrality calculates centrality measures
func (gc *GraphCalculator) AnalyzeNetworkCentrality(ctx context.Context) (map[string]*CentralityMetrics, error) {
	return gc.networkAnalyzer.AnalyzeNetworkCentrality(ctx)
}

// GetNetworkStatistics provides overall network statistics
func (gc *GraphCalculator) GetNetworkStatistics(ctx context.Context) (*NetworkStatistics, error) {
	return gc.networkAnalyzer.GetNetworkStatistics(ctx)
}

// FindCircularEconomyCycles finds circular resource flow cycles
func (gc *GraphCalculator) FindCircularEconomyCycles(ctx context.Context) ([]*CircularEconomyCycle, error) {
	return gc.networkAnalyzer.FindCircularEconomyCycles(ctx)
}