/**
 * SecureLifeAnalogy.cpp
 * 
 * A metaphorical exploration of how security principles apply to everyday life,
 * written as a way to help developers understand security mindsets.
 * 
 * Demonstrates how defensive thinking applies both to code and life.
 * 
 * Author: Security Expert
 */

#include <iostream>
#include <vector>
#include <string>
#include <memory>
#include <random>
#include <chrono>
#include <algorithm>
#include <stdexcept>

class LifeDecision {
private:
    std::string decision_context;
    int risk_level; // 1-10 scale
    bool validated;
    
    // Simulating entropy source for decision randomness
    std::mt19937 rng;
    
    // Validate input before processing - classic security principle
    bool validateInput(const std::string& input) {
        // Check for empty input - null check in real code
        if (input.empty()) {
            std::cerr << "[VALIDATION ERROR] Empty context provided" << std::endl;
            return false;
        }
        
        // Check for overly long input - buffer overflow prevention in real code
        if (input.length() > 1000) {
            std::cerr << "[VALIDATION ERROR] Input too long, possible overflow attack" << std::endl;
            return false;
        }
        
        // Check for potentially dangerous content - injection prevention in real code
        if (input.find(";") != std::string::npos || 
            input.find("--") != std::string::npos) {
            std::cerr << "[VALIDATION ERROR] Potentially malicious input detected" << std::endl;
            return false;
        }
        
        return true;
    }

public:
    LifeDecision(const std::string& context, int risk) : 
        decision_context(""), 
        risk_level(0),
        validated(false),
        rng(std::chrono::steady_clock::now().time_since_epoch().count()) {
        
        // Always validate before assigning - classic secure coding pattern
        validated = validateInput(context);
        if (validated) {
            decision_context = context;
            // Bound check risk level - range validation
            risk_level = std::max(1, std::min(10, risk));
        }
    }
    
    bool makeDecision() {
        // Fail closed - default secure position
        if (!validated) {
            std::cerr << "[SECURITY ERROR] Cannot make decision with unvalidated context" << std::endl;
            return false;
        }
        
        // Calculate risk threshold based on risk level
        // Higher risk = higher threshold to approve
        int threshold = 50 + (risk_level * 5);
        
        // Generate random number for decision
        std::uniform_int_distribution<int> dist(1, 100);
        int random_value = dist(rng);
        
        // Decision logic with audit trail - logging in real security systems
        std::cout << "[DECISION AUDIT] Context: " << decision_context << std::endl;
        std::cout << "[DECISION AUDIT] Risk Level: " << risk_level << "/10" << std::endl;
        std::cout << "[DECISION AUDIT] Approval Threshold: " << threshold << "%" << std::endl;
        std::cout << "[DECISION AUDIT] Random Value: " << random_value << std::endl;
        
        return random_value > threshold;
    }
};

class SecureLifeAnalogy {
private:
    std::vector<std::unique_ptr<LifeDecision>> decisions;
    
    // Principle of least privilege - each method does only what it needs
    void explainSecurityMindset() {
        std::cout << "\n=== THE SECURITY MINDSET IN LIFE ===" << std::endl;
        std::cout << "1. Trust nothing, verify everything" << std::endl;
        std::cout << "2. Assume hostile environment" << std::endl;
        std::cout << "3. Defense in depth - multiple layers of protection" << std::endl;
        std::cout << "4. Fail closed - default to safety" << std::endl;
        std::cout << "5. Principle of least privilege" << std::endl;
    }
    
public:
    void run() {
        explainSecurityMindset();
        
        try {
            // Safe object creation with smart pointers - memory safety
            decisions.push_back(std::make_unique<LifeDecision>("Clicking an email link", 8));
            decisions.push_back(std::make_unique<LifeDecision>("Sharing personal info with friend", 4));
            decisions.push_back(std::make_unique<LifeDecision>("Using public WiFi", 7));
            decisions.push_back(std::make_unique<LifeDecision>("Reusing a password", 9));
            decisions.push_back(std::make_unique<LifeDecision>("", 5)); // Should fail validation
            
            std::cout << "\n=== LIFE DECISIONS THROUGH SECURITY LENS ===" << std::endl;
            
            // Process each decision safely
            for (const auto& decision : decisions) {
                bool result = decision->makeDecision();
                std::cout << "Decision result: " << (result ? "APPROVED" : "DENIED") << "\n" << std::endl;
            }
            
        } catch (const std::exception& e) {
            // Exception handling - error management in secure systems
            std::cerr << "[CRITICAL ERROR] " << e.what() << std::endl;
        }
    }
};

int main() {
    SecureLifeAnalogy secureLife;
    secureLife.run();
    return 0;
}