package main

import (
    "context"
    "log"

    "github.com/initializ/guardrails"
    "github.com/initializ/guardrails/models"
)

func main() {
    // Create manager without MongoDB
    manager, err := guardrails.NewGuardrailManager(guardrails.Config{})
    if err != nil {
        log.Fatal(err)
    }

    // Define guardrails config
    sg := &models.StructuredGuardrails{
        PII: &models.PIIConfig{
            Enabled: true,
            Action:  "mask",
            Categories: map[string]models.PIICategoryConfig{
                "ssn":        {Enabled: true, Action: "mask"},
                "creditCard": {Enabled: true, Action: "block"},
                "email":      {Enabled: true, Action: "mask"},
            },
        },
        Security: &models.SecurityConfig{
            JailbreakDetection: &models.ThresholdConfig{
                Enabled:             true,
                ConfidenceThreshold: 50,
                Action:              "block",
            },
        },
    }

    // Evaluate user input — pass config inline
    result, err := manager.InputGate(context.Background(), guardrails.InputRequest{
        Content:              "Hello, my SSN is 123-45-6789",
        ExecutionID:          "exec-123",
        OrgID:                "org-456",
        EntityType:           guardrails.EntityTypeAgent,
        EntityID:             "agent-789",
        UserID:               "user-001",
        ConfigVersion:        1,
        StructuredGuardrails: sg,
    })
    if err != nil {
        log.Fatal(err)
    }

    if result.IsBlocked() {
        log.Printf("Request blocked: %v", result.Violations)
        return
    }

    if result.Decision == guardrails.DecisionMask {
        log.Printf("Using masked content: %s", result.MaskedContent)
    }
}

package main

import (
    "context"
    "log"
    "time"

    "github.com/initializ/guardrails"
    "go.mongodb.org/mongo-driver/mongo"
    "go.mongodb.org/mongo-driver/mongo/options"
)

func main() {
    // Connect to MongoDB
    client, err := mongo.Connect(context.Background(), options.Client().ApplyURI("mongodb://localhost:27017"))
    if err != nil {
        log.Fatal(err)
    }

    // Create guardrail manager with MongoDB
    manager, err := guardrails.NewGuardrailManager(guardrails.Config{
        MongoClient:    client,
        DatabaseName:   "MyApp",
        CollectionName: "AgentConfig",
        CacheTTL:       5 * time.Minute,
        EnableAudit:    true,
    })
    if err != nil {
        log.Fatal(err)
    }

    // Evaluate user input — config loaded from MongoDB
    result, err := manager.InputGate(context.Background(), guardrails.InputRequest{
        Content:     "Hello, my SSN is 123-45-6789",
        ExecutionID: "exec-123",
        OrgID:       "org-456",
        EntityType:  guardrails.EntityTypeAgent,
        EntityID:    "agent-789",
        UserID:      "user-001",
    })
    if err != nil {
        log.Fatal(err)
    }

    if result.IsBlocked() {
        log.Printf("Request blocked: %v", result.Violations)
        return
    }

    if result.Decision == guardrails.DecisionMask {
        log.Printf("Using masked content: %s", result.MaskedContent)
    }
}

result, err := manager.InputGate(ctx, guardrails.InputRequest{
    Content:              userPrompt,
    ExecutionID:          executionID,
    OrgID:                orgID,
    EntityType:           guardrails.EntityTypeAgent,
    EntityID:             entityID,
    UserID:               userID,
    ConfigVersion:        configVersion,
    StructuredGuardrails: sg, // optional, omit for MongoDB-backed mode
})

result, err := manager.ContextGate(ctx, guardrails.ContextRequest{
    Content: combinedContext,
    RAGResults: []guardrails.RAGResult{
        {Content: "...", Source: "doc1.pdf", Score: 0.95},
    },
    ExecutionID:          executionID,
    OrgID:                orgID,
    EntityType:           guardrails.EntityTypeWorkflow,
    EntityID:             workflowID,
    UserID:               userID,
    ConfigVersion:        configVersion,
    StructuredGuardrails: sg,
})

result, err := manager.ToolCallGate(ctx, guardrails.ToolCallRequest{
    SkillID:              "zendesk_create_ticket",
    SkillName:            "Create Zendesk Ticket",
    ToolName:             "create_ticket",
    Parameters:           map[string]interface{}{"subject": "Help needed"},
    RequestBody:          `{"ticket": {"subject": "Help needed"}}`,
    ExecutionID:          executionID,
    OrgID:                orgID,
    EntityType:           guardrails.EntityTypeAssistant,
    EntityID:             assistantID,
    UserID:               userID,
    ConfigVersion:        configVersion,
    StructuredGuardrails: sg,
})

if result.NeedsApproval() {
    // Handle human-in-the-loop approval
    approvalID := result.ApprovalID
    // Wait for approval...
}

result, err := manager.OutputGate(ctx, guardrails.OutputRequest{
    Content:              agentResponse,
    ExecutionID:          executionID,
    OrgID:                orgID,
    EntityType:           guardrails.EntityTypeAgent,
    EntityID:             entityID,
    UserID:               userID,
    ConfigVersion:        configVersion,
    StructuredGuardrails: sg,
})

result, err := manager.StreamGate(ctx, guardrails.StreamRequest{
    ChunkContent:         chunk,
    ChunkIndex:           i,
    IsComplete:           false,
    AccumulatedContent:   fullResponse,
    ExecutionID:          executionID,
    OrgID:                orgID,
    EntityType:           guardrails.EntityTypeAgent,
    EntityID:             entityID,
    UserID:               userID,
    ConfigVersion:        configVersion,
    StructuredGuardrails: sg,
})

switch result.Decision {
case guardrails.DecisionAllow, guardrails.DecisionWarn:
    // Proceed with original content
    processContent(originalContent)

case guardrails.DecisionMask:
    // Use masked content
    processContent(result.MaskedContent)

case guardrails.DecisionReview:
    // Request human approval
    approval := manager.GetApprovalService()
    // Handle approval workflow...

case guardrails.DecisionBlock:
    // Reject request
    return errors.New(result.Violations[0].Description)
}

policy, err := guardrails.CompileStructuredGuardrails(
    guardrails.EntityTypeWorkflow,
    "org-456",
    "workflow-123",
    1,     // configVersion
    false, // enabled (auto-detected from config)
    sg,    // *models.StructuredGuardrails
)

type MyCustomEvaluator struct{}

func (e *MyCustomEvaluator) Name() string {
    return "my_custom_evaluator"
}

func (e *MyCustomEvaluator) SupportedGates() []guardrails.GateType {
    return []guardrails.GateType{guardrails.GateInput, guardrails.GateOutput}
}

func (e *MyCustomEvaluator) Priority() int {
    return 25 // Run after built-in evaluators
}

func (e *MyCustomEvaluator) Evaluate(
    ctx context.Context,
    policy *guardrails.EffectivePolicy,
    payload guardrails.Payload,
) (*guardrails.Result, error) {
    // Your custom logic here
    return &guardrails.Result{
        Decision: guardrails.DecisionAllow,
        Gate:     payload.GetGate(),
    }, nil
}

// Register the evaluator
manager.RegisterEvaluator(&MyCustomEvaluator{})

manager.InvalidateCache(guardrails.EntityTypeAgent, "agent-789", "org-456")