/**
 * Stone of Orthanc
 * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics
 * Department, University Hospital of Liege, Belgium
 * Copyright (C) 2017-2019 Osimis S.A., Belgium
 *
 * This program is free software: you can redistribute it and/or
 * modify it under the terms of the GNU Affero General Public License
 * as published by the Free Software Foundation, either version 3 of
 * the License, or (at your option) any later version.
 *
 * This program 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 GNU
 * Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 **/


#pragma once

#include "RadiographyLayer.h"
#include "../Toolbox/OrthancApiClient.h"
#include "Framework/StoneEnumerations.h"

namespace OrthancStone
{
  struct MaskPoint;
  class RadiographyDicomLayer;

  class RadiographyScene :
      public IObserver,
      public IObservable
  {
  public:
    class GeometryChangedMessage :
        public OriginMessage<MessageType_Scene_GeometryChanged, RadiographyScene>
    {
    private:
      RadiographyLayer&        layer_;

    public:
      GeometryChangedMessage(const RadiographyScene& origin,
                             RadiographyLayer& layer) :
        OriginMessage(origin),
        layer_(layer)
      {
      }

      RadiographyLayer& GetLayer() const
      {
        return layer_;
      }
    };

    class ContentChangedMessage :
        public OriginMessage<MessageType_Scene_ContentChanged, RadiographyScene>
    {
    private:
      RadiographyLayer&        layer_;

    public:
      ContentChangedMessage(const RadiographyScene& origin,
                            RadiographyLayer& layer) :
        OriginMessage(origin),
        layer_(layer)
      {
      }

      RadiographyLayer& GetLayer() const
      {
        return layer_;
      }
    };


    class LayerAccessor : public boost::noncopyable
    {
    private:
      RadiographyScene&  scene_;
      size_t             index_;
      RadiographyLayer*  layer_;

    public:
      LayerAccessor(RadiographyScene& scene,
                    size_t index);

      LayerAccessor(RadiographyScene& scene,
                    double x,
                    double y);

      void Invalidate()
      {
        layer_ = NULL;
      }

      bool IsValid() const
      {
        return layer_ != NULL;
      }

      RadiographyScene& GetScene() const;

      size_t GetIndex() const;

      RadiographyLayer& GetLayer() const;
    };


  protected:
    typedef std::map<size_t, RadiographyLayer*>  Layers;

    size_t  countLayers_;
    bool    hasWindowing_;
    float   windowingCenter_;
    float   windowingWidth_;
    Layers  layers_;

  protected:
    RadiographyLayer& RegisterLayer(RadiographyLayer* layer);

    void OnTagsReceived(const OrthancApiClient::BinaryResponseReadyMessage& message);

    void OnFrameReceived(const OrthancApiClient::BinaryResponseReadyMessage& message);
    
    void OnDicomExported(const OrthancApiClient::JsonResponseReadyMessage& message);

    void OnDicomWebReceived(const IWebService::HttpRequestSuccessMessage& message);

  public:
    RadiographyScene(MessageBroker& broker);
    
    virtual ~RadiographyScene();

    bool GetWindowing(float& center,
                      float& width) const;

    void GetWindowingWithDefault(float& center,
                                 float& width) const;

    void SetWindowing(float center,
                      float width);

    PhotometricDisplayMode GetPreferredPhotomotricDisplayMode() const;

    RadiographyLayer& LoadText(const Orthanc::Font& font,
                               const std::string& utf8,
                               RadiographyLayer::Geometry* geometry);
    
    RadiographyLayer& LoadTestBlock(unsigned int width,
                                    unsigned int height,
                                    RadiographyLayer::Geometry* geometry);

    RadiographyLayer& LoadMask(const std::vector<MaskPoint>& corners,
                               const RadiographyDicomLayer& dicomLayer,
                               float foreground,
                               RadiographyLayer::Geometry* geometry);

    RadiographyLayer& LoadAlphaBitmap(Orthanc::ImageAccessor* bitmap,  // takes ownership
                                      RadiographyLayer::Geometry* geometry);

    virtual RadiographyLayer& LoadDicomFrame(OrthancApiClient& orthanc,
                                             const std::string& instance,
                                             unsigned int frame,
                                             bool httpCompression,
                                             RadiographyLayer::Geometry* geometry); // pass NULL if you want default geometry

    RadiographyLayer& LoadDicomWebFrame(IWebService& web);

    void RemoveLayer(size_t layerIndex);

    const RadiographyLayer& GetLayer(size_t layerIndex) const;

    void GetLayersIndexes(std::vector<size_t>& output) const;

    Extent2D GetSceneExtent() const;

    void Render(Orthanc::ImageAccessor& buffer,
                const AffineTransform2D& viewTransform,
                ImageInterpolation interpolation) const;

    bool LookupLayer(size_t& index /* out */,
                     double x,
                     double y) const;
    
    void DrawBorder(CairoContext& context,
                    unsigned int layer,
                    double zoom);

    void GetRange(float& minValue,
                  float& maxValue) const;

    // Export using PAM is faster than using PNG, but requires Orthanc
    // core >= 1.4.3
    void ExportDicom(OrthancApiClient& orthanc,
                     const Orthanc::DicomMap& dicom,
                     const std::string& parentOrthancId,
                     double pixelSpacingX,
                     double pixelSpacingY,
                     bool invert,
                     ImageInterpolation interpolation,
                     bool usePam);

    // temporary version used by VSOL because we need to send the same request at another url
    void ExportToCreateDicomRequest(Json::Value& createDicomRequestContent,
                                    const Orthanc::DicomMap& dicom,
                                    double pixelSpacingX,
                                    double pixelSpacingY,
                                    bool invert,
                                    ImageInterpolation interpolation,
                                    bool usePam);
  };
}