#include "tiio.h"

#include "tiio.h"

#include "tiio_jpg.h"

#include "tproperty.h"

#include <map></map>

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

#include <fcntl.h></fcntl.h>

#include <sys types.h=""></sys>

#include <sys stat.h=""></sys>

#ifdef WIN32

#pragma warning(disable : 4786)

#include <io.h></io.h>

#endif

#include <stdio.h></stdio.h>

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

namespace

{

class TiioTable

{ // singleton

public:

	typedef std::map<std::string, *="" tiio::readermaker=""></std::string,>

		ReaderTable;

	typedef std::map<std::string, *,="" bool="" std::pair<tiio::writermaker="">></std::string,>

		WriterTable;

	typedef std::map<std::string, *="" tiio::vectorreadermaker=""></std::string,>

		VectorReaderTable;

	typedef std::map<std::string, *,="" bool="" std::pair<tiio::vectorwritermaker="">></std::string,>

		VectorWriterTable;

	typedef std::map<std::string, *="" tpropertygroup=""></std::string,>

		PropertiesTable;

	ReaderTable m_readers;

	WriterTable m_writers;

	VectorReaderTable m_vectorReaders;

	VectorWriterTable m_vectorWriters;

	PropertiesTable m_writerProperties;

	TiioTable() { initialize(); }

	static TiioTable *instance()

	{

		static TiioTable theTable;

		return &theTable;

	}

	~TiioTable()

	{

		for (PropertiesTable::iterator it = m_writerProperties.begin();

			 it != m_writerProperties.end(); ++it)

			delete it->second;

	}

	void add(std::string ext, Tiio::ReaderMaker *fn)

	{

		m_readers[ext] = fn;

	}

	void add(std::string ext, Tiio::WriterMaker *fn, bool isRenderFormat)

	{

		m_writers[ext] = std::pair<tiio::writermaker *,="" bool="">(fn, isRenderFormat);</tiio::writermaker>

	}

	void add(std::string ext, Tiio::VectorReaderMaker *fn)

	{

		m_vectorReaders[ext] = fn;

	}

	void add(std::string ext, Tiio::VectorWriterMaker *fn, bool isRenderFormat)

	{

		m_vectorWriters[ext] = std::pair<tiio::vectorwritermaker *,="" bool="">(fn, isRenderFormat);</tiio::vectorwritermaker>

	}

	void addWriterProperties(std::string ext, TPropertyGroup *prop)

	{

		m_writerProperties[ext] = prop;

	}

	Tiio::ReaderMaker *findReader(std::string ext) const

	{

		ReaderTable::const_iterator it = m_readers.find(ext);

		if (it == m_readers.end())

			return 0;

		else

			return it->second;

	}

	Tiio::WriterMaker *findWriter(std::string ext) const

	{

		WriterTable::const_iterator it = m_writers.find(ext);

		if (it == m_writers.end())

			return 0;

		else

			return it->second.first;

	}

	Tiio::VectorReaderMaker *findVectorReader(std::string ext) const

	{

		VectorReaderTable::const_iterator it = m_vectorReaders.find(ext);

		if (it == m_vectorReaders.end())

			return 0;

		else

			return it->second;

	}

	Tiio::VectorWriterMaker *findVectorWriter(std::string ext) const

	{

		VectorWriterTable::const_iterator it = m_vectorWriters.find(ext);

		if (it == m_vectorWriters.end())

			return 0;

		else

			return it->second.first;

	}

	TPropertyGroup *findWriterProperties(std::string ext) const

	{

		PropertiesTable::const_iterator it = m_writerProperties.find(ext);

		if (it == m_writerProperties.end())

			return 0;

		else

			return it->second;

	}

	void initialize();

};

} // namespace

//=========================================================

void TiioTable::initialize()

{

}

Tiio::Reader *Tiio::makeReader(std::string ext)

{

	Tiio::ReaderMaker *reader = TiioTable::instance()->findReader(ext);

	if (!reader)

		return 0;

	else

		return reader();

}

Tiio::Writer *Tiio::makeWriter(std::string ext)

{

	Tiio::WriterMaker *writer = TiioTable::instance()->findWriter(ext);

	if (!writer)

		return 0;

	else

		return writer();

}

Tiio::VectorReader *Tiio::makeVectorReader(std::string ext)

{

	Tiio::VectorReaderMaker *reader = TiioTable::instance()->findVectorReader(ext);

	if (!reader)

		return 0;

	else

		return reader();

}

Tiio::VectorWriter *Tiio::makeVectorWriter(std::string ext)

{

	Tiio::VectorWriterMaker *writer = TiioTable::instance()->findVectorWriter(ext);

	if (!writer)

		return 0;

	else

		return writer();

}

TPropertyGroup *Tiio::makeWriterProperties(std::string ext)

{

	TPropertyGroup *prop = TiioTable::instance()->findWriterProperties(ext);

	if (!prop)

		return new TPropertyGroup();

	return prop->clone();

}

void Tiio::defineReaderMaker(const char *ext, Tiio::ReaderMaker *fn)

{

	TiioTable::instance()->add(ext, fn);

}

void Tiio::defineWriterMaker(const char *ext, Tiio::WriterMaker *fn, bool isRenderFormat)

{

	TiioTable::instance()->add(ext, fn, isRenderFormat);

}

void Tiio::defineVectorReaderMaker(const char *ext, Tiio::VectorReaderMaker *fn)

{

	TiioTable::instance()->add(ext, fn);

}

void Tiio::defineVectorWriterMaker(const char *ext, Tiio::VectorWriterMaker *fn, bool isRenderFormat)

{

	TiioTable::instance()->add(ext, fn, isRenderFormat);

}

void Tiio::defineWriterProperties(const char *ext, TPropertyGroup *prop)

{

	TiioTable::instance()->addWriterProperties(ext, prop);

}

/*

#ifdef WIN32

int Tiio::openForReading(char *fn)

{

  int fd = _open(fn, _O_BINARY|_O_RDONLY);

  if(fd == -1)

    {

     fprintf(stderr, "File not found\n");

     exit(1);

    }

  return fd;  

}

void* Tiio::openForReading2(char *fn)

{

  FILE *chan = fopen(fn, "rb");

  if(!chan)

    {

     fprintf(stderr, "File not found\n");

     exit(1);

    }

  return (void*)chan;

}

int Tiio::openForWriting(char *fn)

{

  int fd = _open(

      fn, 

      _O_BINARY | _O_WRONLY | _O_CREAT | _O_TRUNC,

      _S_IREAD | _S_IWRITE);

  if(fd == -1)

    {

     fprintf(stderr, "Can't open file\n");

     exit(1);

    }

  return fd;  

}

#endif

*/

Tiio::Reader::Reader()

{

}

Tiio::Reader::~Reader()

{

}

int Tiio::Writer::m_bwThreshold = 128;

Tiio::Writer::Writer()

	: m_properties(0)

{

}

Tiio::Writer::~Writer()

{

}

void Tiio::Writer::getSupportedFormats(QStringList &formats, bool onlyRenderFormats)

{

	TiioTable::VectorWriterTable::const_iterator vit = TiioTable::instance()->m_vectorWriters.begin();

	TiioTable::VectorWriterTable::const_iterator vit_e = TiioTable::instance()->m_vectorWriters.end();

	for (; vit != vit_e; ++vit)

		if (onlyRenderFormats && vit->second.second)

			formats.push_back(QString::fromStdString(vit->first));

	TiioTable::WriterTable::const_iterator it = TiioTable::instance()->m_writers.begin();

	TiioTable::WriterTable::const_iterator it_e = TiioTable::instance()->m_writers.end();

	for (; it != it_e; ++it)

		if (onlyRenderFormats && it->second.second)

			formats.push_back(QString::fromStdString(it->first));

}

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

void Tiio::Writer::setProperties(TPropertyGroup *properties)

{

	m_properties = properties ? properties->clone() : 0;

}