/*
Copyright (C) 2001-2006, William Joseph.
All Rights Reserved.

This file is part of GtkRadiant.

GtkRadiant is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.

GtkRadiant 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 General Public License for more details.

You should have received a copy of the GNU General Public License
along with GtkRadiant; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
*/

#include "filetypes.h"

#include "debugging/debugging.h"

#include "ifiletypes.h"

#include "string/string.h"
#include "os/path.h"
#include <vector>
#include <map>

class RadiantFileTypeRegistry : public IFileTypeRegistry
{
  struct filetype_copy_t
  {
    filetype_copy_t(const char* moduleName, const filetype_t other)
      : m_moduleName(moduleName), m_name(other.name), m_pattern(other.pattern), m_can_load(other.can_load), m_can_import(other.can_import), m_can_save(other.can_save)
    {
    }
    const char* getModuleName() const
    {
      return m_moduleName.c_str();
    }
    filetype_t getType() const
    {
      return filetype_t(m_name.c_str(), m_pattern.c_str(), m_can_load, m_can_save, m_can_import);
    }
    bool m_can_load;
    bool m_can_import;
    bool m_can_save;
  private:
    CopiedString m_moduleName;
    CopiedString m_name;
    CopiedString m_pattern;
  };
  typedef std::vector<filetype_copy_t> filetype_list_t;
  std::map<CopiedString, filetype_list_t> m_typelists;
public:
  RadiantFileTypeRegistry()
  {
    addType("*", "*", filetype_t("All Files", "*.*"));
  }
  void addType(const char* moduleType, const char* moduleName, filetype_t type)
  {
    m_typelists[moduleType].push_back(filetype_copy_t(moduleName, type));
  }
  void getTypeList(const char* moduleType, IFileTypeList* typelist, bool want_load, bool want_import, bool want_save)
  {
    filetype_list_t& list_ref = m_typelists[moduleType];
    for(filetype_list_t::iterator i = list_ref.begin(); i != list_ref.end(); ++i)
    {
      if(want_load && !(*i).m_can_load) return;
      if(want_import && !(*i).m_can_import) return;
      if(want_save && !(*i).m_can_save) return;
      typelist->addType((*i).getModuleName(), (*i).getType());
    }
  }
};

static RadiantFileTypeRegistry g_patterns;

IFileTypeRegistry* GetFileTypeRegistry()
{
  return &g_patterns;
}

const char* findModuleName(IFileTypeRegistry* registry, const char* moduleType, const char* extension)
{
  class SearchFileTypeList : public IFileTypeList
  {
    char m_pattern[128];
    const char* m_moduleName;
  public:
    SearchFileTypeList(const char* ext)
      : m_moduleName("")
    {
      m_pattern[0] = '*';
      m_pattern[1] = '.';
      strncpy(m_pattern + 2, ext, 125);
      m_pattern[127] = '\0';
    }
    void addType(const char* moduleName, filetype_t type)
    {
      if(extension_equal(m_pattern, type.pattern))
      {
        m_moduleName = moduleName;
      }
    }

    const char* getModuleName()
    {
      return m_moduleName;
    }
  } search(extension);
  registry->getTypeList(moduleType, &search);
  return search.getModuleName();
}


#include "modulesystem/singletonmodule.h"
#include "modulesystem/moduleregistry.h"

class FiletypesAPI
{
  IFileTypeRegistry* m_filetypes;
public:
  typedef IFileTypeRegistry Type;
  STRING_CONSTANT(Name, "*");

  FiletypesAPI()
  {
    m_filetypes = GetFileTypeRegistry();
  }
  IFileTypeRegistry* getTable()
  {
    return m_filetypes;
  }
};

typedef SingletonModule<FiletypesAPI> FiletypesModule;
typedef Static<FiletypesModule> StaticFiletypesModule;
StaticRegisterModule staticRegisterFiletypes(StaticFiletypesModule::instance());


