#pragma region CPL License
/*
Nuclex Native Framework
Copyright (C) 2002-2013 Nuclex Development Labs

This library is free software; you can redistribute it and/or
modify it under the terms of the IBM Common Public License as
published by the IBM Corporation; either version 1.0 of the
License, or (at your option) any later version.

This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
IBM Common Public License for more details.

You should have received a copy of the IBM Common Public
License along with this library
*/
#pragma endregion // CPL License

#ifndef NUCLEX_GRAPHICS_RASTERIZATION_DIRECT3D11OBSERVERMANAGER_H
#define NUCLEX_GRAPHICS_RASTERIZATION_DIRECT3D11OBSERVERMANAGER_H

#include "Nuclex/Graphics/Config.h"
#include "Direct3D11Api.h"

#include <set>
#include <mutex>

namespace Nuclex { namespace Graphics { namespace Rasterization {

  // ------------------------------------------------------------------------------------------- //

  class Direct3D11RasterizerResources;

  // ------------------------------------------------------------------------------------------- //

}}} // namespace Nuclex::Graphics::Rasterization

namespace Nuclex { namespace Graphics { namespace Rasterization {

  // ------------------------------------------------------------------------------------------- //

  /// <summary>Manages resources of the holder's specialized type</summary>
  /// <typeparam name="TAgnostic">Agnostic resource observers are attached to</typeparam>
  /// <typeparam name="TObserver">Observer that maintains the Direct3D 11 resource</typeparam>
  template<typename TAgnostic, typename TObserver> class Direct3D11ObserverManager {

    /// <summary>Initializes a new resource holder</summary>
    /// <param name="resources">Resource manager the observers will belong to</param>
    protected: Direct3D11ObserverManager(Direct3D11RasterizerResources *resources) :
      resources(resources) {}

    /// <summary>Frees all resources owned by the instance</summary>
    public: ~Direct3D11ObserverManager() {}

    /// <summary>Kills all observers of the resource holder</summary>
    protected: void EvictAll() {
      while(!this->observers.empty()) {
        ObserverSet::iterator iterator = this->observers.begin();
        TObserver *observer = *iterator;
        Evict(observer->GetResource(), observer);
      }
    }

    /// <summary>Retrieves the resource's attached observer</summary>
    /// <param name="resource">
    ///   Resource whose currently attached observer will be returned
    /// </param>
    /// <returns>The observer currently attached to the specified resource</returns>
    protected: TObserver *Get(TAgnostic *resource) {
      auto observer = resource->GetObserver(this);
      return static_cast<TObserver *>(observer); // downcast
    }

    /// <summary>Attaches an observer to the resource or returns its current one</summary>
    /// <param name="resource">
    ///   Resource an observer will be attached to or whose current observer will be returned
    /// </param>
    /// <returns>The observer for the specified resource</returns>
    protected: TObserver *Prepare(TAgnostic *resource) {
      auto observer = resource->GetObserver(this);
      if(observer == nullptr) {
        TObserver *d3dObserver = new TObserver(*this->resources, resource);
        this->observers.insert(d3dObserver);
        resource->AttachObserver(this, d3dObserver);
        return d3dObserver;
      } else {
        return static_cast<TObserver *>(observer); // downcast
      }
    }

    /// <summary>Kills the observer for the specified resource</summary>
    /// <param name="resource">Resource whose observer will be killed</param>
    /// <param name="observer">Observer that will be killed, if known</param>
    protected: void Evict(TAgnostic *resource, TObserver *observer = nullptr) {
      // If the caller didn't know the observer, look it up. We may find that there
      // is no observer attached in that case, meaning the resource is already evicted.
      if(observer == nullptr) {
        observer = static_cast<TObserver *>(resource->GetObserver(this));
        if(observer == nullptr) {
          return; // Has already been evicted
        }
      }

      // Remove the observer from our tracking set and kill it.
      ObserverSet::iterator iterator = this->observers.find(observer);
      if(iterator == this->observers.end()) {
        throw std::logic_error("Internal observer management error");
      } else {
        this->observers.erase(iterator);
        resource->DetachObserver(this);
        delete observer;
      }
    }

    /// <summary>A set of observers for the resource</summary>
    private: typedef std::set<TObserver *> ObserverSet;

    /// <summary>Observers for vertex buffers the user has created</summary>
    private: ObserverSet observers;
    /// <summary>Resource manager for which this holder is managing a resource</summary>
    private: Direct3D11RasterizerResources *resources;

  };

  // ------------------------------------------------------------------------------------------- //

}}} // namespace Nuclex::Graphics::Rasterization

#endif // NUCLEX_GRAPHICS_RASTERIZATION_DIRECT3D11OBSERVERMANAGER_H