#pragma once

#ifndef STUDIOPALETTE_INCLUDED

#define STUDIOPALETTE_INCLUDED

#include "tpalette.h"

#include "toonz/tproject.h"

// #include "tfilepath.h"

#undef DVAPI

#undef DVVAR

#ifdef TOONZLIB_EXPORTS

#define DVAPI DV_EXPORT_API

#define DVVAR DV_EXPORT_VAR

#else

#define DVAPI DV_IMPORT_API

#define DVVAR DV_IMPORT_VAR

#endif

class TPalette;

class TImage;

class TColorStyle;

class DVAPI StudioPalette

    : public TProjectManager::Listener {  // singleton; methods can throw

                                          // exceptions

public:

  class Listener {

  public:

    virtual void onStudioPaletteTreeChange() {}

    virtual void onStudioPaletteMove(const TFilePath &dstPath,

                                     const TFilePath &srcPath) {}

    virtual void onStudioPaletteChange(const TFilePath &palette) {}

    virtual ~Listener() {}

  };

  class Palette {  // serve per il drag&drop

    TFilePath m_palettePath;

  public:

    Palette(const TFilePath &path) : m_palettePath(path) {}

    const TFilePath &getPath() const { return m_palettePath; }

  };

  static StudioPalette *instance();

  ~StudioPalette();

  TPalette *getPalette(const TFilePath &path, bool loadRefImg = false);

  int getChildren(std::vector<tfilepath> &fps, const TFilePath &folderPath);</tfilepath>

  int getChildCount(const TFilePath &folderPath);

  bool isFolder(const TFilePath &path);

  bool isPalette(const TFilePath &path);

  bool isReadOnly(const TFilePath &path);

  bool isLevelPalette(const TFilePath &path);

  bool hasGlobalName(const TFilePath &path);

  // ritorna il nome del folder creato

  TFilePath createFolder(const TFilePath &parentFolderPath);

  void createFolder(const TFilePath &parentFolderPath, std::wstring name);

  // ritorna il nome della palette creata;

  // se paletteName != "" prova ad assegnare quel nome. Se esiste gia'

  // aggiunge un suffisso

  TFilePath createPalette(const TFilePath &folderPath,

                          std::string paletteName = "");

  // DOESN'T get ownership

  void setPalette(const TFilePath &palettePath, const TPalette *palette,

                  bool notifyPaletteChanged);

  void deletePalette(const TFilePath &palettePath);

  void deleteFolder(const TFilePath &folderPath);

  TFilePath importPalette(const TFilePath &dstFolder, const TFilePath &srcPath);

  void movePalette(const TFilePath &dstPath, const TFilePath &srcPath);

  TFilePath getLevelPalettesRoot();

  TFilePath getProjectPalettesRoot();

  // TFilePath getRefImage(const TFilePath palettePath);

  bool updateLinkedColors(TPalette *palette);

  void setStylesGlobalNames(TPalette *palette);

  TFilePath getPalettePath(std::wstring paletteId);

  TPalette *getPalette(std::wstring paletteId);

  TColorStyle *getStyle(std::wstring styleId);

  // se lo stile ha un nome globale restituisce il nome della studio palette e

  // l'indice

  // dello stile linkato

  // (altrimenti restituisce (TFilePath(),-1))

  std::pair<tfilepath, int=""> getSourceStyle(TColorStyle *cs);</tfilepath,>

  void addListener(Listener *listener);

  void removeListener(Listener *listener);

  void notifyTreeChange();

  void notifyMove(const TFilePath &dstPath, const TFilePath &srcPath);

  void notifyPaletteChange(const TFilePath &name);

  // bruttacchietto.

  static bool isEnabled() { return m_enabled; };

  static void enable(bool enabled);

  void save(const TFilePath &path, TPalette *palette);

  void removeEntry(const std::wstring paletteId);

  void addEntry(const std::wstring paletteId, const TFilePath &path);

  // TProjectManager::Listener

  void onProjectSwitched() override;

  void onProjectChanged() override;

private:

  StudioPalette();

  TFilePath m_root;

  std::map<std::wstring, tfilepath=""> m_table;</std::wstring,>

  std::vector<listener *=""> m_listeners;</listener>

  TPalette *load(const TFilePath &path);

  static bool m_enabled;

};

#endif