#pragma once

#include <CoreFoundation/CoreFoundation.h>
#include <CoreFoundation/CFPlugInCOM.h>
#include <utility>

/// A smart pointer that can manage the lifecycle of Core Foundation objects.
template <typename T>
class CFPointer {
public:
  CFPointer() : storage(nullptr) {}

  CFPointer(T pointer) : storage(toStorageType(pointer)) {
    if (storage) {
      CFRetain(storage);
    }
  }

  CFPointer(const CFPointer& other) : storage(other.storage) {
    if (CFTypeRef ptr = storage) {
      CFRetain(ptr);
    }
  }

  CFPointer(CFPointer&& other) : storage(std::exchange(other.storage, nullptr)) {}

  ~CFPointer() {
    if (CFTypeRef pointer = storage) {
      CFRelease(pointer);
    }
  }

  static inline CFPointer<T> adopt(T CF_RELEASES_ARGUMENT ptr) { return CFPointer<T>(ptr, CFPointer<T>::Adopt); }

  T get() const { return fromStorageType(storage); }

  CFPointer& operator=(CFPointer other) {
    swap(other);
    return *this;
  }

  T* operator&() {
    if (CFTypeRef pointer = storage) {
      CFRelease(pointer);
    }
    return (T*)&storage;
  }
  operator bool() const { return storage != nullptr; }

  void reset() {
    if (storage) {
      CFRelease(storage);
      storage = nullptr;
    }
  }

private:
  CFTypeRef storage;

  enum AdoptTag { Adopt };
  CFPointer(T ptr, AdoptTag) : storage(toStorageType(ptr)) {}

  inline CFTypeRef toStorageType(CFTypeRef ptr) const { return (CFTypeRef)ptr; }

  inline T fromStorageType(CFTypeRef pointer) const { return (T)pointer; }

  void swap(CFPointer& other) { std::swap(storage, other.storage); }
};

/// A smart pointer that can manage the lifecycle of CoreFoundation IUnknown objects.
template <typename T>
class IUnknownPointer {
public:
  IUnknownPointer() : _storage(nullptr) {}

  IUnknownPointer(T** pointer) : _storage(toStorageType(pointer)) {
    if (_storage) {
      (*pointer)->AddRef(pointer);
    }
  }

  IUnknownPointer(const IUnknownPointer& other) : _storage(other._storage) {
    if (IUnknownVTbl** ptr = _storage) {
      (*ptr)->AddRef(ptr);
    }
  }
  IUnknownPointer& operator=(const IUnknownPointer& other) {
    if (IUnknownVTbl** pointer = _storage) {
      (*pointer)->Release(pointer);
    }
    _storage = other._storage;
    if (IUnknownVTbl** ptr = _storage) {
      (*ptr)->AddRef(ptr);
    }
    return *this;
  }

  IUnknownPointer(IUnknownPointer&& other) : _storage(std::exchange(other._storage, nullptr)) {}

  ~IUnknownPointer() {
    if (IUnknownVTbl** pointer = _storage) {
      (*pointer)->Release(pointer);
    }
  }

  static inline IUnknownPointer<T> adopt(T** ptr) { return IUnknownPointer<T>(ptr, IUnknownPointer<T>::Adopt); }

  T* get() const { return fromStorageType(_storage); }

  T* operator->() const { return get(); }
  T** storage() const { return (T**)_storage; }
  LPVOID* operator&() {
    if (IUnknownVTbl** pointer = _storage) {
      printf("%p RELEASE %d\n", pointer, (*pointer)->Release(pointer));
    }
    return (LPVOID*)&_storage;
  }
  operator bool() const { return _storage != nullptr; }

private:
  IUnknownVTbl** _storage;

  enum AdoptTag { Adopt };
  IUnknownPointer(T** ptr, AdoptTag) : _storage(toStorageType(ptr)) {}

  inline IUnknownVTbl** toStorageType(T** ptr) const { return (IUnknownVTbl**)ptr; }

  inline T* fromStorageType(IUnknownVTbl** pointer) const { return *(T**)pointer; }

  void swap(IUnknownPointer& other) { std::swap(_storage, other._storage); }
};