package regulatory

import "bugulma/backend/internal/domain"

// RegulatoryAnalysis represents regulatory requirements and compliance
type RegulatoryAnalysis struct {
	RequiresPermit   bool    `json:"requires_permit"`
	PermitType       string  `json:"permit_type"`
	EstimatedCost    float64 `json:"estimated_cost"`
	TimeToObtainDays int     `json:"time_to_obtain_days"`
	ComplianceScore  float64 `json:"compliance_score"`
	RiskPenalty      float64 `json:"risk_penalty"`
}

// Service provides regulatory analysis functionality
type Service struct{}

// NewService creates a new regulatory analysis service
func NewService() *Service {
	return &Service{}
}

// AnalyzeRegulatory performs regulatory compliance analysis
func (s *Service) AnalyzeRegulatory(resourceType domain.ResourceType) *RegulatoryAnalysis {
	analysis := &RegulatoryAnalysis{}

	// Determine if permit is required
	analysis.RequiresPermit = s.requiresPermit(resourceType)

	// Get permit type
	analysis.PermitType = s.getPermitType(resourceType)

	// Estimate costs and timeline
	analysis.EstimatedCost, analysis.TimeToObtainDays = s.estimatePermitCostAndTime(resourceType)

	// Calculate compliance score
	analysis.ComplianceScore = s.calculateComplianceScore(resourceType)

	// Calculate risk penalty
	analysis.RiskPenalty = s.calculateRegulatoryPenalty(resourceType)

	return analysis
}

func (s *Service) requiresPermit(resourceType domain.ResourceType) bool {
	switch resourceType {
	case domain.TypeBiowaste, domain.TypeCO2, domain.TypeWater:
		return true
	default:
		return false
	}
}

func (s *Service) getPermitType(resourceType domain.ResourceType) string {
	switch resourceType {
	case domain.TypeBiowaste:
		return "Waste Management Permit"
	case domain.TypeCO2:
		return "Gas Transport License"
	case domain.TypeWater:
		return "Water Discharge Permit"
	default:
		return "None"
	}
}

func (s *Service) estimatePermitCostAndTime(resourceType domain.ResourceType) (float64, int) {
	switch resourceType {
	case domain.TypeBiowaste:
		return 15000, 90 // €15k, 90 days
	case domain.TypeCO2:
		return 25000, 120 // €25k, 120 days
	case domain.TypeWater:
		return 10000, 60 // €10k, 60 days
	default:
		return 0, 0
	}
}

func (s *Service) calculateComplianceScore(resourceType domain.ResourceType) float64 {
	switch resourceType {
	case domain.TypeHeat, domain.TypeSteam:
		return 0.9 // Generally low regulatory burden
	case domain.TypeWater:
		return 0.7 // Moderate compliance requirements
	case domain.TypeBiowaste, domain.TypeCO2:
		return 0.5 // High compliance requirements
	default:
		return 0.8
	}
}

func (s *Service) calculateRegulatoryPenalty(resourceType domain.ResourceType) float64 {
	switch resourceType {
	case domain.TypeBiowaste:
		return 0.6
	case domain.TypeCO2, domain.TypeWater:
		return 0.4
	case domain.TypeHeat, domain.TypeSteam:
		return 0.2
	default:
		return 0.3
	}
}