/*
 * Custom Deleters for std::unique_ptr
 * Focus: Exclusive ownership of file handles
 * We demonstrate using a lambda for file closing.
 */

#include <iostream>
#include <memory>   // For std::unique_ptr
#include <cstdio>   // For FILE, fopen, fclose

// 1. Define a type alias for the file pointer and its deleter
// This pattern clarifies intent and simplifies unique_ptr declarations.
// The deleter must be part of the unique_ptr's type.
using FilePtr = std::unique_ptr<FILE, decltype(&fclose)>;

// We could also define a custom deleter struct, which can be useful
// for more complex stateful deleters or reusability.
struct FileCloser {
    void operator()(FILE* file) const {
        if (file) {
            std::cout << "Closing file via FileCloser struct.\n";
            fclose(file);
        }
    }
};

// 2. Main function to demonstrate custom deleters
int main() {
    std::cout << "--- Demonstrating unique_ptr with Custom Deleters ---\n\n";

    // Example 1: Using a lambda as a custom deleter for a file
    // The lambda captures nothing and takes a FILE*.
    // unique_ptr's second template argument (the deleter type) is deduced.
    std::cout << "Opening 'example.txt' with lambda deleter...\n";
    FILE* rawFile = fopen("example.txt", "w");
    if (rawFile) {
        std::unique_ptr<FILE, void(*)(FILE*)> fileGuard(rawFile, [](FILE* f) {
            std::cout << "Closing 'example.txt' with lambda deleter.\n";
            fclose(f);
        });
        fprintf(rawGuard.get(), "Hello from unique_ptr with lambda!\n");
        std::cout << "File 'example.txt' written and will be closed automatically.\n";
    } else {
        std::cerr << "Error: Could not open example.txt\n";
    }
    std::cout << "\n";

    // Example 2: Using a function pointer as a custom deleter
    // We must explicitly specify the deleter's type in the unique_ptr template.
    std::cout << "Opening 'another.txt' with function pointer deleter...\n";
    FILE* anotherRawFile = fopen("another.txt", "w");
    if (anotherRawFile) {
        // Note: The deleter type for unique_ptr with a function pointer is 'void(*)(FILE*)'
        FilePtr anotherFileGuard(anotherRawFile, &fclose);
        fprintf(anotherFileGuard.get(), "Hello from unique_ptr with function pointer!\n");
        std::cout << "File 'another.txt' written and will be closed automatically.\n";
    } else {
        std::cerr << "Error: Could not open another.txt\n";
    }
    std::cout << "\n";

    // Example 3: Using a custom deleter struct (function object)
    std::cout << "Opening 'struct_example.txt' with FileCloser struct...\n";
    FILE* structRawFile = fopen("struct_example.txt", "w");
    if (structRawFile) {
        // The deleter type for unique_ptr with a function object is the type of the object itself.
        std::unique_ptr<FILE, FileCloser> structFileGuard(structRawFile, FileCloser());
        fprintf(structFileGuard.get(), "Hello from unique_ptr with a custom struct!\n");
        std::cout << "File 'struct_example.txt' written and will be closed automatically.\n";
    } else {
        std::cerr << "Error: Could not open struct_example.txt\n";
    }
    std::cout << "\n";

    std::cout << "All unique_ptr instances are now out of scope.\n";
    return 0;
}

/*
 * Custom Deleters for std::shared_ptr
 * Focus: Shared ownership of a C-style allocated buffer.
 * We demonstrate using a lambda for custom deallocation logic.
 */

#include <iostream>
#include <memory>   // For std::shared_ptr
#include <vector>   // For std::vector (to represent some data)
#include <mutex>    // For std::mutex, to show a deleter can manage other resources

// 1. A dummy resource that requires custom cleanup, e.g., from a C API
void* allocate_c_buffer(size_t size) {
    std::cout << "Allocating C-style buffer of size " << size << " bytes.\n";
    return malloc(size);
}

// 2. Main function to demonstrate custom deleters with shared_ptr
int main() {
    std::cout << "--- Demonstrating shared_ptr with Custom Deleters ---\n\n";

    // Example 1: Managing a C-style allocated buffer with a lambda deleter
    // shared_ptr's deleter does NOT affect its type, unlike unique_ptr.
    std::cout << "Managing a C-style buffer...\n";
    {
        void* buffer = allocate_c_buffer(128);
        if (buffer) {
            // The deleter is a lambda that captures nothing and calls free().
            // The type of the deleter is NOT part of std::shared_ptr's type.
            std::shared_ptr<void> sharedBuffer(buffer, [](void* p) {
                std::cout << "Deallocating C-style buffer via shared_ptr deleter.\n";
                free(p);
            });

            // We can create copies, and the buffer will be freed only when the last shared_ptr goes out of scope.
            std::shared_ptr<void> anotherRef = sharedBuffer;
            std::cout << "Shared buffer has " << sharedBuffer.use_count() << " owners.\n";

            // Simulate some usage
            // static_cast<char*>(sharedBuffer.get())[0] = 'A'; // For demonstration
            // ...

            std::cout << "Leaving inner scope. Buffer will be deallocated when all shared_ptr instances are gone.\n";
        }
    }
    std::cout << "Buffer management complete.\n\n";

    // Example 2: Managing a mutex lock with shared_ptr
    // This demonstrates managing a *stateful* resource's lifetime.
    std::cout << "Managing a mutex lock/unlock with shared_ptr...\n";
    std::mutex myMutex;
    {
        // We 'lock' the mutex and immediately manage its 'unlock' with shared_ptr.
        // The deleter ensures myMutex.unlock() is called only when the last reference dies.
        myMutex.lock(); // Acquire the resource
        std::cout << "Mutex locked. Creating shared_ptr guard.\n";

        std::shared_ptr<std::mutex> lockGuard(&myMutex, [](std::mutex* m) {
            std::cout << "Mutex unlocking via shared_ptr deleter.\n";
            m->unlock();
        });

        std::shared_ptr<std::mutex> anotherLockRef = lockGuard;
        std::cout << "Lock guard has " << lockGuard.use_count() << " owners.\n";

        // Simulate critical section operations...
        std::cout << "Performing critical operations...\n";

        std::cout << "Leaving critical section scope.\n";
    }
    std::cout << "Mutex management complete. Mutex is now guaranteed unlocked.\n\n";

    std::cout << "All shared_ptr instances are now out of scope.\n";
    return 0;
}

/*
 * Advanced Patterns and Pitfalls for Custom Deleters
 * Focus: Stateful deleters, type erasure, and common mistakes.
 * We demonstrate a stateful deleter for a resource that needs connection ID.
 */

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

// Simulate an external resource that requires a connection ID for cleanup
struct ConnectionHandle {
    int id; // Represents a unique connection identifier
    std::string name;
    ConnectionHandle(int i, std::string n) : id(i), name(std::move(n)) {
        std::cout << "Connection " << name << " (ID: " << id << ") acquired.\n";
    }
    // No destructor needed as cleanup is external.
};

// 1. Stateful Custom Deleter for ConnectionHandle
// This deleter needs to know the connection ID to properly release the resource.
struct ConnectionReleaser {
    int connectionId; // State captured by the deleter

    explicit ConnectionReleaser(int id) : connectionId(id) {
        std::cout << "  ConnectionReleaser created for ID: " << connectionId << ".\n";
    }

    void operator()(ConnectionHandle* handle) const {
        if (handle) {
            std::cout << "  Releasing Connection " << handle->name << " (ID: " << connectionId << ") via custom deleter.\n";
            // In a real scenario, this would call an external API like `release_connection(connectionId, handle)`
            delete handle; // Delete the ConnectionHandle object itself if it was heap-allocated
        }
    }
};

// Simulate a function that acquires a ConnectionHandle
std::shared_ptr<ConnectionHandle> acquireConnection(int id, const std::string& name) {
    // We create the ConnectionHandle on the heap to manage its deletion.
    ConnectionHandle* handle = new ConnectionHandle(id, name);
    // The deleter captures the ID to use during release.
    return std::shared_ptr<ConnectionHandle>(handle, ConnectionReleaser(id));
}

int main() {
    std::cout << "--- Advanced Custom Deleter Patterns and Pitfalls ---\n\n";

    // Example 1: Stateful Deleter with std::shared_ptr
    std::cout << "Activating a stateful deleter for a connection...\n";
    {
        auto conn1 = acquireConnection(101, "DatabaseConnection");
        std::cout << "  Connection 101 reference count: " << conn1.use_count() << "\n";

        auto conn2 = acquireConnection(102, "NetworkSocket");
        std::cout << "  Connection 102 reference count: " << conn2.use_count() << "\n";

        // Create a copy of conn1, the deleter state is also copied implicitly.
        std::shared_ptr<ConnectionHandle> conn1_copy = conn1;
        std::cout << "  Connection 101 reference count after copy: " << conn1.use_count() << "\n";

        std::cout << "Leaving scope for connections.\n";
    }
    std::cout << "Connections released by their respective deleters.\n\n";

    // Pitfall: Using delete for non-heap resources or wrong deleter for type
    // This is a common error to actively avoid.
    // We'll just print a warning here instead of causing a crash.
    std::cout << "--- Common Pitfalls ---\n";
    std::cout << "  Pitfall 1: Using default delete for non-heap resource (e.g., stack allocated or C-API handle without matching free/close)\n";
    std::cout << "  std::unique_ptr<int> ptr(new int(5)); // OK
";
    std::cout << "  int stack_var = 10;
";
    std::cout << "  // std::unique_ptr<int> bad_ptr(&stack_var); // DANGER: Calls delete on stack memory! AVOID!\n";

    std::cout << "  Pitfall 2: Type mismatch between smart pointer and deleter.\n";
    std::cout << "  // std::unique_ptr<char, decltype(&free)> char_ptr(new char[10], free); // Free expects void*, not char* implicitly with unique_ptr, careful!
";
    std::cout << "  std::cout << "  (Best practice: use `std::unique_ptr<void, decltype(&free)>` for `malloc`/`free`.)\n";

    return 0;
}