#pragma region CPL License
/*
Nuclex Engine
Copyright (C) 2002-2008 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

#include "Nuclex/Text/TextServer.h"
#include "Nuclex/Text/FontCodec.h"
#include "Nuclex/Support/Exception.h"

namespace Nuclex { namespace Text {

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

  namespace {

    /// <summary>Enumerates a list of font codecs</summary>
    class InternalFontCodecEnumerator : public TextServer::CodecEnumerator {

      /// <summary>Map of codecs keyed by their names</summary>
      private: typedef std::map<string, shared_ptr<FontCodec> > CodecMap;

      /// <summary>Initializes a new FontCodecEnumerator</summary>
      /// <param name="codecs">Codecs that will be enumerated by the new enumerator</param>
      public: InternalFontCodecEnumerator(const CodecMap &Codecs) :
        m_Codecs(Codecs),
        m_CodecIt(Codecs.end()),
        m_CodecEnd(Codecs.end()) {}

      /// <summary>Releases all memory owned by a FontCodecEnumerator</summary>
      public: virtual ~InternalFontCodecEnumerator() {}

      //
      // CodecEnumerator implementation
      //

      /// <summary>Advances to the next entry in the enumeration</summary>
      /// <returns>
      ///   True if there was a next entry, false if the end of the enumerator was reached
      /// </returns>
      public: bool next() {
        if(m_CodecIt == m_CodecEnd)
          m_CodecIt = m_Codecs.begin();
        else
          ++m_CodecIt;

        return (m_CodecIt != m_CodecEnd);
      }

      /// <summary>Gets the font codec at the enumerator's current position</summary>
      /// <returns>The font codec at the enumerator's current position</returns>
      public: const shared_ptr<FontCodec> &get() const { return m_CodecIt->second; }

      /// <summary>Map containing the codecs being enumerated</summary>
      /// <remarks>
      ///   This is an internal implementation that directly references the map of codecs
      ///   from the text server for efficiency and simplicity.
      /// </remarks>
      private: const CodecMap &m_Codecs;
      /// <summary>STL iterator pointing to the enumerator's current codec</summary>
      private: CodecMap::const_iterator m_CodecIt;
      /// <summary>STL iterator pointing to the end of the codec map</summary>
      private: CodecMap::const_iterator m_CodecEnd;

    };

  } // anonymous namespace

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

  namespace {

    /// <summary>Enumerates over a list of fonts</summary>
    class InternalFontEnumerator : public TextServer::FontEnumerator {

      /// <summary>Maps a series of fonts by their names</summary>
      private: typedef std::map<string, shared_ptr<Font> > FontMap;

      /// <summary>Initializes a new font enumerator</summary>
      /// <param name="Fonts">Map containing the fonts to enumerate</param>
      public: InternalFontEnumerator(const FontMap &Fonts) :
        m_Fonts(Fonts),
        m_FontIt(Fonts.begin()),
        m_FontEnd(Fonts.end()) {}

      /// <summary>Releases all memory owned by a font enumerator
      public: virtual ~InternalFontEnumerator() {}

      //
      // FontEnumerator implementation
      //
      
      /// <summary>Advance the enumerator to the next entry</summary>
      /// <returns>
      ///   True if there was a next entry, false if the end of the enumerator was reached
      /// </returns>
      public: bool next() {
        if(m_FontIt == m_FontEnd)
          m_FontIt = m_Fonts.begin();
        else
          ++m_FontIt;

        return (m_FontIt != m_FontEnd);
      }

      /// <summary>Gets the font at the enumerator's current position</summary>
      /// <returns>The font at the enumerator's current position</returns>
      const shared_ptr<Font> &get() const { return m_FontIt->second; }

      /// <summary>Map containing the fonts being enumerated</summary>
      /// <remarks>
      ///   This is an internal implementation that directly references the map of fonts
      ///   from the text server for efficiency and simplicity.
      /// </remarks>
      private: const FontMap &m_Fonts;
      /// <summary>STL iterator pointing to the enumerator's current font</summary>
      private: FontMap::const_iterator m_FontIt;
      /// <summary>STL iterator pointing to the end of the font map</summary>
      private: FontMap::const_iterator m_FontEnd;

    };

  } // namespace

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

  const shared_ptr<FontCodec> &TextServer::getCodec(const string &sName) const {
    CodecMap::const_iterator CodecIt = m_Codecs.find(sName);
    if(CodecIt == m_Codecs.end()) {
      throw ItemNotFoundException(
        "Nuclex::Text::TextServer::getCodec()",
        string("Font codec not found: '") + sName + "'"
      );
    }

    return CodecIt->second;
  }

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

  void TextServer::addCodec(const string &sName, const shared_ptr<FontCodec> &spCodec) {
    CodecMap::iterator CodecIt = m_Codecs.find(sName);
    if(CodecIt != m_Codecs.end())
      CodecIt->second = spCodec;
    else
      m_Codecs.insert(CodecMap::value_type(sName, spCodec));
  }

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

  void TextServer::removeCodec(const string &sName) {
    CodecMap::iterator CodecIt = m_Codecs.find(sName);
    if(CodecIt == m_Codecs.end()) {
      throw ItemNotFoundException(
        "Nuclex::Text::TextServer::removeCodec()",
        string("Font codec not found: '") + sName + "'"
      );
    }

    m_Codecs.erase(CodecIt);
  }

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

  void TextServer::clearCodecs() {
    m_Codecs.clear();
  }

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

  shared_ptr<TextServer::CodecEnumerator> TextServer::enumCodecs() const {
    return shared_ptr<TextServer::CodecEnumerator>(
      new InternalFontCodecEnumerator(m_Codecs)
    );
  }

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

  shared_ptr<Font> TextServer::loadFont(
    const shared_ptr<Storage::Stream> &spSource,
    const string &sExtension,
    size_t nSize
  ) const {
    CodecMap::const_iterator CodecEnd = m_Codecs.end();
    for(
      CodecMap::const_iterator CodecIt = m_Codecs.begin();
      CodecIt != CodecEnd;
      CodecIt++
    ) {
      if(CodecIt->second->canLoadFont(spSource, sExtension)) {
        return CodecIt->second->loadFont(spSource, sExtension, nSize);
      }
    }

    throw UnsupportedFontFormatException(
      "Nuclex::Text::TextServer::loadFont()", "Unsupported font file format"
    );
  }

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

  const shared_ptr<Font> &TextServer::getFont(const string &sName) const {
    FontMap::const_iterator FontIt = m_Fonts.find(sName);
    if(FontIt == m_Fonts.end()) {
      throw ItemNotFoundException(
        "Nuclex::Text::TextServer::getFont()",
        string("Font not found: '") + sName + "'"
      );
    }
    
    return FontIt->second;
  }

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

  void TextServer::addFont(const string &sName, const shared_ptr<Font> &spFont) {
    FontMap::iterator FontIt = m_Fonts.find(sName);
    if(FontIt != m_Fonts.end())
      FontIt->second = spFont;
    else
      m_Fonts.insert(FontMap::value_type(sName, spFont));
  }

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

  void TextServer::removeFont(const string &sName) {
    FontMap::iterator FontIt = m_Fonts.find(sName);
    if(FontIt == m_Fonts.end()) {
      throw ItemNotFoundException(
        "Nuclex::Text::TextServer::removeFont()",
        string("Font not found: '") + sName + "'"
      );
    }

    m_Fonts.erase(FontIt);
  }

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

  void TextServer::clearFonts() {
    m_Fonts.clear();
  }

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

  shared_ptr<TextServer::FontEnumerator> TextServer::enumFonts() const {
    return shared_ptr<TextServer::FontEnumerator>(
      new InternalFontEnumerator(m_Fonts)
    );
  }

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

}} // namespace Nuclex::Text