/*
    std::shared_ptr fundamentally manages an object's lifetime through a shared ownership model.
    A control block, separate from the managed object, stores the reference count.
    When the last shared_ptr owning an object is destroyed, the object is automatically deallocated.
*/

#include <iostream>
#include <memory>
#include <string>

class Resource {
public:
    std::string name;
    Resource(const std::string& n) : name(n) {
        std::cout << "Resource created: " << name << "\n";
    }
    ~Resource() {
        std::cout << "Resource destroyed: " << name << "\n";
    }
    void operation() const {
        std::cout << name << " performing operation.\n";
    }
};

// Function demonstrating shared_ptr passing and copy behavior
void processResource(std::shared_ptr<Resource> res) {
    std::cout << "  Inside processResource: use_count = " << res.use_count() << "\n";
    res->operation();
}

int main() {
    std::cout << "--- Part 1: Basic shared_ptr usage ---\n";

    // 1. Creating a shared_ptr with std::make_shared (recommended for efficiency)
    std::shared_ptr<Resource> r1 = std::make_shared<Resource>("Data_A");
    std::cout << "Initial r1: use_count = " << r1.use_count() << "\n";
    r1->operation();

    // 2. Creating another shared_ptr, sharing ownership (copy constructor)
    std::shared_ptr<Resource> r2 = r1; // r2 now shares ownership with r1
    std::cout << "After r2 = r1: r1 use_count = " << r1.use_count() 
              << ", r2 use_count = " << r2.use_count() << "\n";

    // 3. Passing shared_ptr by value (increases ref count)
    processResource(r1);
    std::cout << "After processResource call: r1 use_count = " << r1.use_count() << "\n";

    // 4. Resetting a shared_ptr (decreases ref count)
    r2.reset(); // r2 no longer owns the resource
    std::cout << "After r2.reset(): r1 use_count = " << r1.use_count() 
              << ", r2 is_null = " << (r2 == nullptr ? "true" : "false") << "\n";

    std::cout << "--- End of main scope. Resource_Data_A will be destroyed. ---\n";
    return 0;
}

/*
    std::weak_ptr addresses the critical problem of circular dependencies when using std::shared_ptr.
    It provides a non-owning observation mechanism.
    A weak_ptr can observe a shared_ptr-managed object without incrementing its reference count.
    To safely access the observed object, weak_ptr::lock() must be called, which returns a shared_ptr if the object still exists.
*/

#include <iostream>
#include <memory>
#include <string>
#include <vector>

class Node;

class Node {
public:
    std::string name;
    std::shared_ptr<Node> next;
    std::weak_ptr<Node> prev; // Use weak_ptr to break circular dependency

    Node(const std::string& n) : name(n) {
        std::cout << "Node created: " << name << "\n";
    }
    ~Node() {
        std::cout << "Node destroyed: " << name << "\n";
    }

    void setNext(std::shared_ptr<Node> n) {
        next = n;
    }

    void setPrev(std::shared_ptr<Node> p) {
        prev = p;
    }

    void printConnections() const {
        std::cout << name << " -> Next: ";
        if (next) {
            std::cout << next->name;
        }
        else {
            std::cout << "None";
        }

        std::cout << ", Prev (weak): ";
        if (auto p_locked = prev.lock()) { // Attempt to lock weak_ptr
            std::cout << p_locked->name;
        }
        else {
            std::cout << "Expired";
        }
        std::cout << "\n";
    }
};

int main() {
    std::cout << "--- Part 2: Addressing Circular Dependencies with std::weak_ptr ---\n";

    // Simulate circular dependency using raw shared_ptr first (would cause leak)
    /*
    std::shared_ptr<Node> nodeA = std::make_shared<Node>("NodeA");
    std::shared_ptr<Node> nodeB = std::make_shared<Node>("NodeB");

    nodeA->next = nodeB;
    nodeB->next = nodeA;

    // At this point, nodeA points to nodeB, nodeB points to nodeA.
    // Both ref counts will be 2. When main scope ends, ref counts drop to 1, but never 0.
    // Resources NodeA and NodeB would leak.
    */

    // Correct approach using std::weak_ptr
    std::shared_ptr<Node> nodeX = std::make_shared<Node>("NodeX");
    std::shared_ptr<Node> nodeY = std::make_shared<Node>("NodeY");

    nodeX->setNext(nodeY); // nodeX owns nodeY
    nodeY->setPrev(nodeX); // nodeY observes nodeX with weak_ptr, no ownership asserted

    std::cout << "nodeX use_count: " << nodeX.use_count() << "\n"; // Expected 1 (owned by main)
    std::cout << "nodeY use_count: " << nodeY.use_count() << "\n"; // Expected 2 (owned by main and nodeX->next)

    nodeX->printConnections();
    nodeY->printConnections();

    // Demonstrate weak_ptr behavior after object destruction
    std::cout << "\nCreating a temporary shared_ptr for demonstration...\n";
    std::shared_ptr<Node> tempNode = std::make_shared<Node>("TempNode");
    std::weak_ptr<Node> weakToTemp = tempNode;

    std::cout << "Weak pointer to TempNode is valid: " << (weakToTemp.lock() ? "true" : "false") << "\n";
    tempNode.reset(); // Destroy the shared_ptr, TempNode object is now gone.
    std::cout << "Weak pointer to TempNode is valid after reset: " << (weakToTemp.lock() ? "true" : "false") << "\n";

    std::cout << "--- End of main scope. NodeX and NodeY will be destroyed. ---\n";
    return 0;
}

/*
    Optimizing smart pointer usage involves selecting the correct type and deployment strategy.
    std::make_shared is generally preferred over direct 'new' for efficiency and exception safety.
    Factory functions centralize object creation and return smart pointers, enforcing consistent ownership.
*/

#include <iostream>
#include <memory>
#include <string>
#include <vector>

class DataProcessor {
public:
    std::string id;
    DataProcessor(const std::string& i) : id(i) {
        std::cout << "DataProcessor created: " << id << "\n";
    }
    ~DataProcessor() {
        std::cout << "DataProcessor destroyed: " << id << "\n";
    }
    void process() const {
        std::cout << id << " processing data.\n";
    }
};

// Factory function to create DataProcessor objects as shared_ptr
std::shared_ptr<DataProcessor> createProcessor(const std::string& id) {
    std::cout << "  [Factory] Creating DataProcessor with ID: " << id << "\n";
    // Using std::make_shared for optimal allocation
    return std::make_shared<DataProcessor>(id);
}

// Example of receiving a shared_ptr (e.g., in a system component)
void consumeProcessor(std::shared_ptr<DataProcessor> processor) {
    std::cout << "  [Consumer] Received processor: " << processor->id 
              << ", use_count = " << processor.use_count() << "\n";
    processor->process();
}

int main() {
    std::cout << "--- Part 3: Strategic Deployment & Best Practices ---\n";

    // 1. Using std::make_shared (recommended)
    std::shared_ptr<DataProcessor> processor1 = std::make_shared<DataProcessor>("Proc_A");
    std::cout << "processor1 use_count: " << processor1.use_count() << "\n";

    // 2. Using a factory function for controlled creation
    std::shared_ptr<DataProcessor> processor2 = createProcessor("Proc_B");
    std::cout << "processor2 use_count after factory: " << processor2.use_count() << "\n";

    // 3. Passing shared_ptr by value to a function that needs shared ownership
    consumeProcessor(processor1); // Increments use count temporarily
    std::cout << "processor1 use_count after consumeProcessor: " << processor1.use_count() << "\n";

    // 4. Choosing the right smart pointer (brief conceptual example)
    // If DataProcessor was uniquely owned, we'd use std::unique_ptr.
    // std::unique_ptr<DataProcessor> uniqueProcessor = std::make_unique<DataProcessor>("UniqueProc");
    // uniqueProcessor->process();

    // If a raw pointer is passed to a function that only observes and doesn't manage lifetime:
    // void observeProcessor(DataProcessor* p) { p->process(); }
    // observeProcessor(processor1.get()); // Get raw pointer for observation only

    std::cout << "--- End of main scope. Processors will be destroyed. ---\n";
    return 0;
}

/*
    std::enable_shared_from_this allows an object to obtain a shared_ptr to itself.
    This is crucial for objects that are themselves managed by shared_ptr but need to pass out shared_ptr references to themselves.
    Directly using 'this' to construct a shared_ptr leads to undefined behavior and multiple control blocks.
    Weak_ptr can also be used for caches or observer patterns where the observable might outlive the observer.
*/

#include <iostream>
#include <memory>
#include <string>
#include <vector>

class EventPublisher; // Forward declaration

// Demonstrating std::enable_shared_from_this
class MyObject : public std::enable_shared_from_this<MyObject> {
public:
    std::string id;
    MyObject(const std::string& i) : id(i) {
        std::cout << "MyObject created: " << id << "\n";
    }
    ~MyObject() {
        std::cout << "MyObject destroyed: " << id << "\n";
    }

    // Function that needs to return a shared_ptr to 'this'
    std::shared_ptr<MyObject> getSharedPointerToThis() {
        return shared_from_this(); // Correct way
    }

    // WRONG: Avoid this - creates a new control block, leading to double-free
    // std::shared_ptr<MyObject> getBadSharedPointerToThis() {
    //     return std::shared_ptr<MyObject>(this);
    // }
};

// Demonstrating weak_ptr in an observer pattern (e.g., UI element observing a model)
class UIElement {
public:
    std::string name;
    std::weak_ptr<EventPublisher> publisher;

    UIElement(const std::string& n) : name(n) {
        std::cout << "UIElement created: " << name << "\n";
    }
    ~UIElement() {
        std::cout << "UIElement destroyed: " << name << "\n";
    }

    void update() const {
        if (auto pub = publisher.lock()) {
            std::cout << name << " updated, observing publisher: " << pub->name << "\n";
        }
        else {
            std::cout << name << " updated, publisher has expired.\n";
        }
    }
};

class EventPublisher {
public:
    std::string name;
    // In a real scenario, this would be a list of weak_ptr to UIElement
    // For simplicity, we just show a name connection

    EventPublisher(const std::string& n) : name(n) {
        std::cout << "EventPublisher created: " << name << "\n";
    }
    ~EventPublisher() {
        std::cout << "EventPublisher destroyed: " << name << "\n";
    }
};

int main() {
    std::cout << "--- Part 4: Advanced Scenarios & Pitfalls ---\n";

    // 1. std::enable_shared_from_this
    std::shared_ptr<MyObject> obj1 = std::make_shared<MyObject>("Obj_X");
    std::cout << "obj1 use_count: " << obj1.use_count() << "\n";

    std::shared_ptr<MyObject> obj2 = obj1->getSharedPointerToThis();
    std::cout << "obj1 use_count after getSharedPointerToThis: " << obj1.use_count() << "\n";
    std::cout << "obj2 use_count: " << obj2.use_count() << "\n";

    // obj1->getBadSharedPointerToThis(); // If uncommented, would lead to double-free/crash

    // 2. weak_ptr in an observer pattern
    std::cout << "\n--- Weak_ptr in Observer Pattern ---\n";
    std::shared_ptr<EventPublisher> pub = std::make_shared<EventPublisher>("AppPublisher");
    std::shared_ptr<UIElement> ui1 = std::make_shared<UIElement>("MainMenu");
    std::shared_ptr<UIElement> ui2 = std::make_shared<UIElement>("StatusBar");

    ui1->publisher = pub; // UI observes publisher (weakly)
    ui2->publisher = pub;

    ui1->update();
    ui2->update();

    std::cout << "Publisher use_count before reset: " << pub.use_count() << "\n";
    pub.reset(); // Publisher is destroyed. UI elements should reflect this.

    ui1->update(); // Should indicate publisher has expired

    std::cout << "--- End of main scope. Objects will be destroyed. ---\n";
    return 0;
}