advanced

type AgeRange struct {
	Low  int
	High int
}

type AudioAnalysis struct {
	Transcription string
	Language      string
	TextAnalysis  *ContentAnalysis
}

type BoundingBox struct {
	Left   float64
	Top    float64
	Width  float64
	Height float64
}

type CelebrityMatch struct {
	Name        string
	Confidence  float64
	BoundingBox BoundingBox
	URLs        []string
}

type CombinedAnalysis struct {
	ImageAnalysis *ImageAnalysis
	TextAnalysis  *ContentAnalysis
	Flags         []string
	RiskLevel     string
}

type ComprehendClientInterface interface {
	DetectDominantLanguage(ctx context.Context, params *comprehend.DetectDominantLanguageInput, optFns ...func(*comprehend.Options)) (*comprehend.DetectDominantLanguageOutput, error)
	DetectSentiment(ctx context.Context, params *comprehend.DetectSentimentInput, optFns ...func(*comprehend.Options)) (*comprehend.DetectSentimentOutput, error)
	DetectPiiEntities(ctx context.Context, params *comprehend.DetectPiiEntitiesInput, optFns ...func(*comprehend.Options)) (*comprehend.DetectPiiEntitiesOutput, error)
	DetectEntities(ctx context.Context, params *comprehend.DetectEntitiesInput, optFns ...func(*comprehend.Options)) (*comprehend.DetectEntitiesOutput, error)
	DetectKeyPhrases(ctx context.Context, params *comprehend.DetectKeyPhrasesInput, optFns ...func(*comprehend.Options)) (*comprehend.DetectKeyPhrasesOutput, error)
}

type ContentAnalysis struct {
	ContentID      string
	Sentiment      SentimentAnalysis
	Toxicity       ToxicityAnalysis
	PII            []PIIEntity
	Topics         []Topic
	Language       LanguageDetection
	Threats        []ThreatIndicator
	CustomFlags    []CustomFlag
	AnalyzedAt     time.Time
	ProcessingTime time.Duration
}

type ContentMetadata struct {
	ContentID    string
	AuthorID     string
	AuthorDomain string
	ContentType  ContentType
	Language     string
	Context      string // e.g., "post", "comment", "profile"
	Timestamp    time.Time
	ReplyTo      string // If this is a reply
	Mentions     []string
	Hashtags     []string
	URLs         []string
}

type ContentType string

type CostTracker interface {
	TrackComprehendRequest(operation string, units int)
	TrackTranscribeRequest(jobName string, estimatedMinutes int)
}

type CustomFlag struct {
	Name       string
	Value      any
	Confidence float64
}

type CustomLabel struct {
	Name       string
	Confidence float64
	Parents    []string
}

type DecisionEngine struct {
	// contains filtered or unexported fields
}

type DecisionReason struct {
	Type        string // "toxicity", "explicit", "pattern", "reputation", etc.
	Severity    Severity
	Description string
	Evidence    any // Can be various types of evidence
}

type Emotion struct {
	Type       string // "HAPPY", "SAD", "ANGRY", etc.
	Confidence float64
}

type Engine struct {
	// contains filtered or unexported fields
}

type EngineOptions struct {
	Mode              ModerationMode
	Config            *ModerationConfig
	ComprehendClient  *comprehend.Client
	RekognitionClient *rekognition.Client
	TableName         string
	PatternRepo       PatternRepository
	Logger            *zap.Logger
	CostTracker       CostTracker
	DynamoRM          core.DB
}

type ExplicitContent struct {
	IsExplicit         bool
	NudityScore        float64
	SuggestiveScore    float64
	ViolenceScore      float64
	VisuallyDisturbing float64
	Confidence         float64
}

type FaceAnalysis struct {
	BoundingBox BoundingBox
	Emotions    []Emotion
	AgeRange    AgeRange
	Gender      Gender
	Confidence  float64
}

type FrameAnalysis struct {
	Timestamp     time.Duration
	ImageAnalysis ImageAnalysis
}

type Gender struct {
	Value      string // "Male", "Female"
	Confidence float64
}

type GlobalConfig interface {
	GetDisableAWSModeration() bool
	GetDisableComprehend() bool
	GetDisableRekognition() bool
}

type ImageAnalysis struct {
	ImageURL       string
	Explicit       ExplicitContent
	Violence       ViolenceDetection
	Text           []TextInImage
	Objects        []ObjectDetection
	Faces          []FaceAnalysis
	Celebrities    []CelebrityMatch
	CustomLabels   []CustomLabel
	AnalyzedAt     time.Time
	ProcessingTime time.Duration
}

type ImageAnalyzer struct {
	// contains filtered or unexported fields
}

type ImageAnalyzerInterface interface {
	AnalyzeImage(ctx context.Context, imageURL string, metadata ContentMetadata) (*ImageAnalysis, error)
}

type LanguageDetection struct {
	LanguageCode string // e.g., "en", "es", "fr"
	Confidence   float64
}

type ModerationAction string

type ModerationAnalysis struct {
	ContentMetadata ContentMetadata
	TextAnalysis    *ContentAnalysis
	ImageAnalysis   *ImageAnalysis
	VideoAnalysis   *VideoAnalysis
	PatternMatches  []PatternMatch
	ReputationScore *ReputationScore
	ThreatMatches   []ThreatMatch
}

type ModerationConfig struct {
	// Thresholds
	ToxicityThreshold   float64
	ExplicitThreshold   float64
	ViolenceThreshold   float64
	ConfidenceThreshold float64

	// Actions
	AutoRemoveThreshold float64
	QuarantineThreshold float64
	FlagThreshold       float64

	// Reputation
	ReputationDecayRate   float64
	BadActorThreshold     float64
	TrustedActorThreshold float64

	// Performance
	MaxAnalysisTime time.Duration
	EnableCaching   bool
	CacheTTL        time.Duration

	// Features
	EnableTextAnalysis      bool
	EnableImageAnalysis     bool
	EnableVideoAnalysis     bool
	EnablePatternMatching   bool
	EnableReputationScoring bool
	EnableThreatSharing     bool

	// AWS Configuration
	ComprehendRegion  string
	RekognitionRegion string
	S3Bucket          string // Added S3 bucket for storing images

	// Cost controls
	MaxMonthlySpend    float64
	EnableCostTracking bool
}

type ModerationDecision struct {
	ContentID       string
	Decision        ModerationAction
	Confidence      float64
	Reasons         []DecisionReason
	RequiresReview  bool
	ReviewPriority  int // 1-10, higher is more urgent
	Recommendations []string
	ExpiresAt       time.Time // For temporary actions
	DecidedAt       time.Time
}

type ModerationEngine interface {
	// Content analysis
	AnalyzeContent(content string, metadata ContentMetadata) (*ContentAnalysis, error)
	AnalyzeImage(imageURL string, metadata ContentMetadata) (*ImageAnalysis, error)
	AnalyzeVideo(videoURL string, metadata ContentMetadata) (*VideoAnalysis, error)

	// Pattern management
	CreatePattern(pattern *ModerationPattern) error
	UpdatePattern(patternID string, pattern *ModerationPattern) error
	DeletePattern(patternID string) error
	GetPatterns(filter PatternFilter) ([]*ModerationPattern, error)

	// Reputation management
	GetReputationScore(actorID string) (*ReputationScore, error)
	UpdateReputation(actorID string, event ReputationEvent) error

	// Threat intelligence
	ShareThreat(threat *ThreatIntel) error
	GetSharedThreats(since time.Time) ([]*ThreatIntel, error)

	// Decision making
	MakeDecision(analysis *ModerationAnalysis) (*ModerationDecision, error)

	// Reporting
	GetModerationStats(timeRange TimeRange) (*ModerationStats, error)
	GetFalsePositiveRate(timeRange TimeRange) (float64, error)
}

type ModerationError struct {
	Code    string
	Message string
	Details map[string]any
}

type ModerationEvent struct {
	Type       string
	Confidence float64
	Timestamp  time.Duration
}

type ModerationMetrics struct {
	// contains filtered or unexported fields
}

type ModerationMode string

type ModerationPattern struct {
	ID          string
	Name        string
	Description string
	Pattern     string  // Regex or keyword pattern
	Type        string  // "regex", "keyword", "phrase"
	Category    string  // Primary category
	Severity    float64 // 0.0 to 1.0
	Action      ModerationAction
	Flags       []string // Additional flags or categories
	CreatedBy   string
	CreatedAt   time.Time
	UpdatedAt   time.Time
	Active      bool
	HitCount    int64
	LastHit     time.Time
}

type ModerationStats struct {
	TimeRange         TimeRange
	TotalAnalyzed     int64
	ActionCounts      map[ModerationAction]int64
	CategoryCounts    map[string]int64
	SeverityCounts    map[Severity]int64
	AverageConfidence float64
	FalsePositives    int64
	TruePositives     int64
	ResponseTime      time.Duration
}

type NoOpImageAnalyzer struct {
	// contains filtered or unexported fields
}

type NoOpTextAnalyzer struct {
	// contains filtered or unexported fields
}

type NoOpVideoAnalyzer struct {
	// contains filtered or unexported fields
}

type ObjectDetection struct {
	Name        string
	Confidence  float64
	BoundingBox BoundingBox
	Parents     []string
}

type PIIEntity struct {
	Type       string // e.g., "EMAIL", "PHONE", "SSN", "CREDIT_CARD"
	Text       string
	BeginIndex int
	EndIndex   int
	Confidence float64
}

type PatternFilter struct {
	Category    string  // Single category filter
	Type        string  // Pattern type filter
	Active      *bool   // Active status filter
	MinSeverity float64 // Minimum severity filter
	Limit       int     // Result limit
	CreatedBy   string  // Filter by creator
}

type PatternMatch struct {
	PatternID   string
	PatternName string
	MatchText   string
	Location    string // Where in content
	Confidence  float64
}

type PatternMatcher struct {
	// contains filtered or unexported fields
}

type PatternRepository interface {
	CreatePattern(ctx context.Context, pattern *ModerationPattern) error
	UpdatePattern(ctx context.Context, patternID string, pattern *ModerationPattern) error
	DeletePattern(ctx context.Context, patternID string) error
	GetPattern(ctx context.Context, patternID string) (*ModerationPattern, error)
	GetPatterns(ctx context.Context, filter PatternFilter) ([]*ModerationPattern, error)
	IncrementHitCount(ctx context.Context, patternID string) error
	LoadActivePatterns(ctx context.Context) ([]*ModerationPattern, error)
}

type PatternStats struct {
	PatternID   string
	PatternName string
	HitCount    int64
	LastHit     time.Time
}

type RealtimeStats struct {
	Uptime          time.Duration
	TotalAnalyzed   int64
	AnalysisRate    float64 // per second
	AllowRate       float64
	FlagRate        float64
	RemoveRate      float64
	QuarantineRate  float64
	AvgResponseTime time.Duration
	P95ResponseTime time.Duration
}

type RekognitionCostTracker interface {
	TrackRekognitionRequest(operation string, imageCount int)
}

type ReputationEvent struct {
	EventType   string // "violation", "false_positive", "good_content", "user_report"
	Severity    Severity
	Description string
	Timestamp   time.Time
}

type ReputationFactor struct {
	Factor      string  // e.g., "content_violations", "user_reports", "false_positives"
	Impact      float64 // Positive or negative impact on score
	Description string
}

type ReputationHistoryItem struct {
	Timestamp   time.Time
	EventType   string
	Severity    Severity
	Description string
	Impact      float64
}

type ReputationScore struct {
	ActorID            string
	Score              float64 // 0.0 to 100.0
	Level              string  // "trusted", "normal", "suspicious", "bad_actor"
	ViolationCount     int
	FalsePositiveCount int
	ContentCount       int
	LastViolation      time.Time
	Factors            []ReputationFactor
	UpdatedAt          time.Time
}

type ReputationScorer struct {
	// contains filtered or unexported fields
}

type SentimentAnalysis struct {
	Sentiment  string  // POSITIVE, NEGATIVE, NEUTRAL, MIXED
	Positive   float64 // 0.0 to 1.0
	Negative   float64
	Neutral    float64
	Mixed      float64
	Confidence float64
}

type Severity string

type Signal struct {
	Type       string
	Severity   Severity
	Score      float64
	Confidence float64
	Evidence   any
}

type TextAnalyzer struct {
	// contains filtered or unexported fields
}

type TextAnalyzerInterface interface {
	AnalyzeText(ctx context.Context, text string, metadata ContentMetadata) (*ContentAnalysis, error)
}

type TextInImage struct {
	Text        string
	Confidence  float64
	BoundingBox BoundingBox
}

type ThreatIndicator struct {
	Type        string // e.g., "VIOLENCE", "SELF_HARM", "TERRORISM"
	Severity    Severity
	Confidence  float64
	Evidence    []string
	ActionItems []string
}

type ThreatIntel struct {
	ID           string
	ThreatType   string
	Indicators   []string // Hashes, patterns, domains, etc.
	Severity     Severity
	Description  string
	SourceDomain string
	FirstSeen    time.Time
	LastSeen     time.Time
	HitCount     int64
	Confidence   float64
	TTL          time.Duration
}

type ThreatIntelRepository interface {
	ShareThreat(ctx context.Context, threat *repositories.ThreatIntel) error
	GetSharedThreats(ctx context.Context, since time.Time) ([]*repositories.ThreatIntel, error)
	GetThreatsByType(ctx context.Context, threatType string, limit int) ([]*repositories.ThreatIntel, error)
	UpdateThreatConfidence(ctx context.Context, threatID string, newConfidence float64) error
	IncrementHitCount(ctx context.Context, threatID string) error
	LoadActiveThreats(ctx context.Context) ([]*repositories.ThreatIntel, error)
	GetThreatByID(ctx context.Context, threatID string) (*repositories.ThreatIntel, error)
	GetIndicatorThreat(ctx context.Context, indicator string) (string, error)
}

type ThreatIntelligence struct {
	// contains filtered or unexported fields
}

type ThreatMatch struct {
	ThreatID   string
	ThreatType string
	Indicator  string
	Confidence float64
}

type TimeRange struct {
	Start time.Time
	End   time.Time
}

type Topic struct {
	Name     string
	Score    float64
	Category string
}

type ToxicCategory struct {
	Category   string // e.g., "PROFANITY", "HATE_SPEECH", "THREAT"
	Score      float64
	Confidence float64
}

type ToxicityAnalysis struct {
	IsToxic        bool
	ToxicityScore  float64 // 0.0 to 1.0
	Categories     []ToxicCategory
	TargetedGroups []string
	Confidence     float64
}

type TranscriptionResult struct {
	Transcription string
	Language      string
	Confidence    float64
	JobName       string
	Duration      time.Duration
}

type TranscriptionService struct {
	// contains filtered or unexported fields
}

type VideoAnalysis struct {
	VideoURL       string
	Frames         []FrameAnalysis
	Audio          AudioAnalysis
	Duration       time.Duration
	AnalyzedAt     time.Time
	ProcessingTime time.Duration
}

type VideoAnalyzer struct {
	// contains filtered or unexported fields
}

type VideoAnalyzerInterface interface {
	AnalyzeVideo(ctx context.Context, videoURL string, metadata ContentMetadata) (*VideoAnalysis, error)
}

type ViolenceDetection struct {
	HasViolence     bool
	WeaponsDetected []string
	BloodScore      float64
	ViolenceScore   float64
	Confidence      float64
}