#include "tscanner.h"
#include "tscannertwain.h"
#include "texception.h"
#include "tscannerepson.h"
#include "tstream.h"
#include "tconvert.h"
#include "tfilepath.h"
#include "tfilepath_io.h"
#include "tenv.h"
#include "tsystem.h"

extern "C" {
#include "../common/twain/ttwain_util.h"
}

//===================================================================
//
// TScanParam
//
//-------------------------------------------------------------------

void TScanParam::update(const TScanParam &model)
{
	m_supported = model.m_supported;
	m_min = model.m_min;
	m_max = model.m_max;
	m_def = model.m_def;
	m_step = model.m_step;
	m_value = tcrop(m_value, m_min, m_max);
}

//===================================================================
//
// TScannerParameters
//
//-------------------------------------------------------------------

const std::string BlackAndWhite = "Black & White";
const std::string Graytones = "Graytones";
const std::string Rgbcolors = "RGB Color";

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

TScannerParameters::TScannerParameters()
	: m_bw(false), m_gray(false), m_rgb(false), m_scanType(None), m_scanArea(TRectD()), m_cropBox(TRectD()), m_isPreview(false), m_maxPaperSize(TDimensionD(0, 0)), m_paperOverflow(false), m_brightness(), m_contrast(), m_threshold(), m_dpi(), m_paperFeeder(), m_twainVersion(), m_manufacturer(), m_prodFamily(), m_productName(), m_version(), m_reverseOrder(false), m_validatedByCurrentScanner(false)
{
	m_threshold.m_value = 127;
	m_brightness.m_value = 127;
}

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

TScannerParameters::~TScannerParameters()
{
}

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

void TScannerParameters::assign(const TScannerParameters *src)
{
	*this = *src;
}

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

void TScannerParameters::setSupportedTypes(bool bw, bool gray, bool rgb)
{
	m_bw = bw;
	m_gray = gray;
	m_rgb = rgb;
	if (!m_bw && !m_gray && !m_rgb) {
		m_scanType = None;
	} else {
		switch (m_scanType) {
		case BW:
			if (!m_bw)
				m_scanType = m_gray ? GR8 : RGB24;
			break;
		case GR8:
			if (!m_gray)
				m_scanType = m_rgb ? RGB24 : BW;
			break;
		case RGB24:
			if (!m_rgb)
				m_scanType = m_gray ? GR8 : BW;
			break;
		case None:
			if (gray)
				m_scanType = GR8;
			else {
				if (rgb)
					m_scanType = RGB24;
				else if (bw)
					m_scanType = BW;
			}
			break;
		}
	}
}

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

bool TScannerParameters::isSupported(ScanType scanType) const
{
	switch (scanType) {
	case BW:
		return m_bw;
	case GR8:
		return m_gray;
	case RGB24:
		return m_rgb;
	default:
		assert(0);
		return false;
	}
}

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

void TScannerParameters::cropScanArea()
{
	m_paperOverflow = false;
	if (m_maxPaperSize.lx == 0 || m_maxPaperSize.ly == 0) {
		// probabilmente non e' ancora stato selezionato uno scanner e quindi non e'
		// definita una maxPaperSize
		return;
	}
	assert(m_maxPaperSize.lx > 0 && m_maxPaperSize.ly > 0);
	if (m_scanArea.x1 > m_maxPaperSize.lx) {
		m_paperOverflow = true;
		m_scanArea.x1 = m_maxPaperSize.lx;
	}
	if (m_scanArea.y1 > m_maxPaperSize.ly) {
		m_paperOverflow = true;
		m_scanArea.y1 = m_maxPaperSize.ly;
	}
}

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

void TScannerParameters::setMaxPaperSize(double maxWidth, double maxHeight)
{
	// assert(maxWidth>0 && maxHeight>0);
	m_maxPaperSize = TDimensionD(maxWidth, maxHeight);
	cropScanArea();
}

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

void TScannerParameters::setPaperFormat(std::string paperFormat)
{
	TPaperFormatManager *formatManager = TPaperFormatManager::instance();
	assert(formatManager->isValidFormat(paperFormat));
	if (!formatManager->isValidFormat(paperFormat))
		paperFormat = formatManager->getDefaultFormat();
	m_paperFormat = paperFormat;
	TDimensionD d = TPaperFormatManager::instance()->getSize(paperFormat);
	m_scanArea = TRectD(TPointD(0, 0), d);
	cropScanArea();
	if (m_cropBox == TRectD())
		m_cropBox = m_scanArea;
}

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

void TScannerParameters::updatePaperFormat()
{
	if (m_paperFormat == "")
		m_paperFormat = TPaperFormatManager::instance()->getDefaultFormat();
	setPaperFormat(m_paperFormat);
}

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

void TScannerParameters::setScanType(ScanType scanType)
{
	assert(scanType == None || scanType == BW || scanType == GR8 || scanType == RGB24);
	m_scanType = scanType;
}

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

void TScannerParameters::adaptToCurrentScanner()
{
	try {
		if (TScanner::instance()->isDeviceSelected()) {
			TScanner::instance()->updateParameters(*this);
			m_validatedByCurrentScanner = true;
		}
	} catch (TException &) {
		//TMessage::error("%1", e.getMessage());
	}
}

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

void TScannerParameters::saveData(TOStream &os) const
{
	std::map<std::string, std::string> attr;
	attr["fmt"] = m_paperFormat;
	os.openCloseChild("paper", attr);

	if (m_paperFeeder.m_value == 1.0) {
		attr.clear();
		os.openCloseChild("autoFeeder", attr);
	}

	if (m_reverseOrder) {
		attr.clear();
		os.openCloseChild("reverseOrder", attr);
	}

	if (m_scanType != None) {
		std::string scanTypeString = Rgbcolors;
		switch (m_scanType) {
		case BW:
			scanTypeString = BlackAndWhite;
			break;
		case GR8:
			scanTypeString = Graytones;
			break;
		case RGB24:
			scanTypeString = Rgbcolors;
			break;
		}
		attr.clear();
		attr["value"] = scanTypeString;
		os.openCloseChild("mode", attr);
	}

	if (m_dpi.m_supported) {
		attr.clear();
		attr["value"] = toString(m_dpi.m_value);
		os.openCloseChild("dpi", attr);
	}

	if (m_brightness.m_supported) {
		attr.clear();
		attr["value"] = toString(m_brightness.m_value);
		os.openCloseChild("brightness", attr);
	}

	if (m_contrast.m_supported) {
		attr.clear();
		attr["value"] = toString(m_contrast.m_value);
		os.openCloseChild("contrast", attr);
	}

	if (m_threshold.m_supported) {
		attr.clear();
		attr["value"] = toString(m_threshold.m_value);
		os.openCloseChild("threshold", attr);
	}
}

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

void TScannerParameters::loadData(TIStream &is)
{
	std::string tagName;
	while (is.matchTag(tagName)) {
		if (tagName == "dpi") {
			std::string s = is.getTagAttribute("value");
			if (isDouble(s))
				m_dpi.m_value = (float)toDouble(s);
		} else if (tagName == "brightness") {
			std::string s = is.getTagAttribute("value");
			if (isDouble(s))
				m_brightness.m_value = (float)toDouble(s);
		} else if (tagName == "threshold") {
			std::string s = is.getTagAttribute("value");
			if (isDouble(s))
				m_threshold.m_value = (float)toDouble(s);
		} else if (tagName == "contrast") {
			std::string s = is.getTagAttribute("value");
			if (isDouble(s))
				m_contrast.m_value = (float)toDouble(s);
		} else if (tagName == "autoFeeder") {
			m_paperFeeder.m_value = 1.0;
		} else if (tagName == "reverseOrder") {
			m_reverseOrder = true;
		} else if (tagName == "mode") {
			std::string scanTypeString = is.getTagAttribute("value");
			m_scanType = None;
			if (scanTypeString == BlackAndWhite)
				m_scanType = BW;
			else if (scanTypeString == Graytones)
				m_scanType = GR8;
			else if (scanTypeString == Rgbcolors)
				m_scanType = RGB24;
		} else if (tagName == "paper") {
			std::string paperFormat = is.getTagAttribute("fmt");
			if (paperFormat != "")
				setPaperFormat(paperFormat);
		}
	}
	m_validatedByCurrentScanner = false;
}

//===================================================================
//
// TScanner
//
//-------------------------------------------------------------------

namespace
{
TScanner *instanceTwain = 0;
TScanner *instanceEpson = 0;
}

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

bool TScanner::m_isTwain = true;

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

namespace
{
class Cleaner
{
public:
	bool m_activated;
	Cleaner() : m_activated(false) {}
	~Cleaner()
	{
		TScanner *scannerToDestroy = 0;
		if (m_activated)
			scannerToDestroy = TScanner::instance();
		delete scannerToDestroy;
	}
};
Cleaner MyCleaner;
};

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

// #define DUMMYSCAN
#ifdef DUMMYSCAN
class TScannerDummy : public TScanner
{
public:
	TScannerDummy() {}
	~TScannerDummy() {}
	void selectDevice() {}
	bool isDeviceAvailable() { return true; }
	void updateParameters(TScannerParameters &parameters)
	{
		parameters.setSupportedTypes(false, true, true);
		parameters.setMaxPaperSize(1000., 1000.);
		parameters.enablePaperFeeder(true);
		parameters.m_brightness.update(TScanParam(0, 255, 128, 1));
		parameters.m_contrast.update(TScanParam(0, 255, 128, 1));
		parameters.m_threshold.update(TScanParam(0, 255, 128, 1));
		parameters.m_dpi.update(TScanParam(60, 1200, 100, 1));

		setName("DummyScanner");
	}
	bool isTwain() const { return true; }
	void acquire(const TScannerParameters &param, int paperCount) { return; }
	bool isAreaSupported() { return true; }
};
#endif

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

TScanner *TScanner::instance()
{
	MyCleaner.m_activated = true;
#ifdef DUMMYSCAN
	static TScannerDummy dummy = TScannerDummy();
	return &dummy;
#else
	if (m_isTwain) {
		if (instanceEpson) {
			TScannerEpson *se = (TScannerEpson *)instanceEpson;
			se->closeIO();
			//delete m_instanceEpson; //e' singletone, perche' buttarlo? (vinz)
			//m_instanceEpson=0;
		}
		if (!instanceTwain)
			instanceTwain = new TScannerTwain();
	} else if (!m_isTwain) {
		if (instanceTwain) {
			//delete m_instanceTwain;  //e' singletone, perche' buttarlo? (vinz)
			//m_instanceTwain=0;
			TTWAIN_CloseAll(0);
		}
		if (!instanceEpson)
			instanceEpson = new TScannerEpson();
	}

	return (m_isTwain) ? instanceTwain : instanceEpson;
#endif
}

//-----------------------------------------------------------------------------
TScanner::TScanner()
	: m_paperLeft(0)
{
}

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

TScanner::~TScanner()
{
	if (instanceEpson) {
		TScannerEpson *se = (TScannerEpson *)instanceEpson;
		se->closeIO();
	}
}

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

void TScanner::addListener(TScannerListener *lst)
{
	m_listeners.insert(lst);
}

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

void TScanner::removeListener(TScannerListener *lst)
{
	m_listeners.erase(lst);
}

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

void TScanner::notifyImageDone(const TRasterImageP &img)
{
	std::set<TScannerListener *>::iterator it = m_listeners.begin();
	for (; it != m_listeners.end(); ++it) {
		(*it)->onImage(img);
	}
}

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

void TScanner::notifyNextPaper()
{
	std::set<TScannerListener *>::iterator it = m_listeners.begin();
	for (; it != m_listeners.end(); ++it) {
		(*it)->onNextPaper();
	}
}

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

void TScanner::notifyAutomaticallyNextPaper()
{
	std::set<TScannerListener *>::iterator it = m_listeners.begin();
	for (; it != m_listeners.end(); ++it) {
		(*it)->onAutomaticallyNextPaper();
	}
}

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

void TScanner::notifyError()
{
	std::set<TScannerListener *>::iterator it = m_listeners.begin();
	for (; it != m_listeners.end(); ++it) {
		(*it)->onError();
	}
}

//-----------------------------------------------------------------------------
/*! If one listener is set to cancel return true. */
bool TScanner::isScanningCanceled()
{
	std::set<TScannerListener *>::iterator it = m_listeners.begin();
	for (; it != m_listeners.end(); ++it) {
		if ((*it)->isCanceled())
			return true;
	}
	return false;
}

//===================================================================
//
// TPaperFormatManager
//
//-------------------------------------------------------------------

namespace
{
const std::pair<std::string, TDimensionD> defaultPaperFormat("A4 paper", TDimensionD(210.00, 297.00));
}

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

TPaperFormatManager::TPaperFormatManager()
{
	readPaperFormats();
	// se non c'e' aggiungo il formato di default. In questo modo e' sempre definito
	if (!isValidFormat(defaultPaperFormat.first))
		m_formats[defaultPaperFormat.first] = Format(defaultPaperFormat.second);
}

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

TPaperFormatManager *TPaperFormatManager::instance()
{
	static TPaperFormatManager _instance;
	return &_instance;
}

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

void TPaperFormatManager::getFormats(std::vector<std::string> &names) const
{
	for (FormatTable::const_iterator it = m_formats.begin();
		 it != m_formats.end(); ++it)
		names.push_back(it->first);
}

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

TDimensionD TPaperFormatManager::getSize(std::string name) const
{
	FormatTable::const_iterator it = m_formats.find(name);
	if (it == m_formats.end())
		return TDimensionD(0., 0.);
	else
		return it->second.m_size;
}

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

bool TPaperFormatManager::isValidFormat(std::string name) const
{
	FormatTable::const_iterator it = m_formats.find(name);
	return it != m_formats.end();
}

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

std::string TPaperFormatManager::getDefaultFormat() const
{
	return defaultPaperFormat.first;
}

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

void TPaperFormatManager::readPaperFormat(const TFilePath &path)
{
	if (path.getType() != "pap")
		return;
	Tifstream is(path);
	std::string name;
	TDimensionD size(0, 0);
	while (is) {
		char buffer[1024];
		is.getline(buffer, sizeof buffer);

		// i e' il carattere successivo alla fine della linea
		unsigned int i = 0;
		for (i = 0; i < sizeof buffer && buffer[i]; i++) {
		}
		if (i > 0 && buffer[i - 1] == '\n')
			i--;
		while (i > 0 && buffer[i - 1] == ' ')
			i--;
		unsigned int j = 0;
		unsigned int k = 0;
		// j e' il carattere successivo alla fine del primo token
		for (j = 0; j < i && buffer[j] != ' '; j++) {
		}

		// k e' l'inizio del secondo token (se c'e', altrimenti == i)
		for (k = j; k < i && buffer[k] == ' '; k++) {
		}

		std::string value;
		if (k < i)
			value = std::string(buffer + k, i - k);

		if (buffer[0] == '#') {
			if (k < i && name == "")
				name = value;
		} else if (std::string(buffer).find("WIDTH") == 0) {
			if (isDouble(value))
				size.lx = toDouble(value);
		} else if (std::string(buffer).find("LENGTH") == 0) {
			if (isDouble(value))
				size.ly = toDouble(value);
		}
	}
	if (name == "" || size.lx == 0 || size.ly == 0) {
		// TMessage::error("Error reading paper format file : %1",path);
	} else
		m_formats[name] = Format(size);
}

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

void TPaperFormatManager::readPaperFormats()
{
	TFilePathSet fps;
	TFilePath papDir = TEnv::getConfigDir() + "pap";
	if (!TFileStatus(papDir).isDirectory()) {
		// TMessage::error("E_CanNotReadDirectory_%1", papDir);
		return;
	}

	try {
		fps = TSystem::readDirectory(papDir);
	} catch (TException &) {
		// TMessage::error("E_CanNotReadDirectory_%1", papDir);
		return;
	}

	TFilePathSet::const_iterator it = fps.begin();
	for (; it != fps.end(); ++it)
		readPaperFormat(*it);
}