#ifndef TNZCAMERA_H
#define TNZCAMERA_H

#include "tcommon.h"
#include "timage.h"
#include "tiio.h"
#include "tthread.h"
#include "toonz/toonzscene.h"

//#define WRITE_LOG_FILE
//#define CHECK_VIDEO_FRAME_INTERVALL
//#define USE_OPENGL_SHARED

#undef DVAPI
#undef DVVAR
#ifdef TCAMERA_EXPORTS
#define DVAPI DV_EXPORT_API
#define DVVAR DV_EXPORT_VAR
#else
#define DVAPI DV_IMPORT_API
#define DVVAR DV_IMPORT_VAR
#endif

// forward declaration
class CameraLevelManager;
class CameraConnect;
class QImage;
class CaptureParameters;
class TXshSimpleLevel;

//===================================================================
// CameraImageViewer

class DVAPI CameraImageViewer
{
public:
	CameraImageViewer() {}

	virtual void setImage(TRasterP ras) = 0;
};

//void processImage(unsigned char* m_ptr, int camWidth, int camHeight);

#ifndef USE_OPENGL_SHARED
//=============================================================================
// ImageProcessing

class ImageProcessing : public TThread::Runnable
{
	Q_OBJECT
	unsigned char *m_ptr;
	int m_camWidth;
	int m_camHeight;

	enum AcquireType {
		ACQUIRE_FRAME,
		ACQUIRE_WHITE_IMAGE,
		NONE
	} m_acquireType;

public:
	ImageProcessing();
	~ImageProcessing();

	void setData(unsigned char *dataPtr);
	void setImageSize(int camWidth, int camHeight)
	{
		m_camWidth = camWidth;
		m_camHeight = camHeight;
	}

	void run();

	void onFinished(TThread::RunnableP task);
};
#endif

//===================================================================
// CameraTest

class DVAPI TnzCamera : public QObject
{
	Q_OBJECT

	CameraImageViewer *m_viewer;
	CameraLevelManager *m_cameraLevelManager;
	CameraConnect *m_cameraConnection;

	QList<QString> m_devices;

	bool m_isCameraConnected;
	bool m_acquireFrame;
	bool m_acquireWhiteImage;

	ToonzScene *m_scene;

	TDimension m_deviceResolution;

	TPixel32 m_linesColor;

	bool m_startedImageProcessing;
#ifndef USE_OPENGL_SHARED
	TThread::Executor *m_imageProcessingExecutor;
#else
#endif

	bool m_freeze;

#ifdef CHECK_VIDEO_FRAME_INTERVALL
	double m_videoFrameIntervall;
#endif

	TnzCamera();

public:
	static TnzCamera *instance();
	bool initTnzCamera();
	~TnzCamera();

#ifdef USE_OPENGL_SHARED
	void notifyImageChanged(int camWidth, int camHeight, unsigned char *ptr)
	{
		Q_EMIT imageChanged(camWidth, camHeight, ptr);
	}
#else
	TThread::Executor *getImageProcessingExecutor() const
	{
		return m_imageProcessingExecutor;
	}
#endif
	bool &startedImageProcessing()
	{
		return m_startedImageProcessing;
	}

	bool isFreezed() const { return m_freeze; }
	void freeze(bool freeze) { m_freeze = freeze; }

	void setScene(ToonzScene *scene);
	TDimension getDeviceResolution() const { return m_deviceResolution; }
	CaptureParameters *getCaptureParameters() const;

	TXshSimpleLevel *getCurrentLevel() const;
	TFrameId getCurrentFid() const;

#ifdef CHECK_VIDEO_FRAME_INTERVALL
	double getVideoFrameIntervall() const
	{
		return m_videoFrameIntervall;
	}
	void setVideoFrameIntervall(double intervall);
#endif

	bool isAcquireFrame() const
	{
		return m_acquireFrame;
	}
	bool isAcquireWhiteImage() const { return m_acquireWhiteImage; }
	void setViewImage(TRaster32P img);
	void setAcquiredImage(TRaster32P img);
	void setAcquiredWhiteImage(TRasterGR8P img);

	TRasterGR8P getWhiteImage();

	bool isCameraConnected() const { return m_isCameraConnected; }

	void updateDeviceResolution(int width, int height);
	bool setCurrentImageSize(int width, int height);
	int getImageWidth() const;
	int getImageHeight() const;

	int getContrast() const;
	int getBrightness() const;

	bool isSubtractWhiteImage() const;
	void removeWhiteImage();

	bool getUpsideDown() const;

	bool saveWithoutAlpha() const;

	TPixel32 getLinesColor() const { return m_linesColor; }
	void setLinesColor(TPixel32 color) { m_linesColor = color; }

	bool findConnectedCameras(QList<QString> &cameras);
	bool cameraConnect(wstring deviceName);
	void cameraDisconnect();
	bool onViewfinder(CameraImageViewer *viewer);
	bool onRelease(TFrameId frameId, wstring fileName, int row = 0, int col = 0, bool keepWhiteImage = false);
	int saveType() const;
	void setSaveType(int value);

	//Utility function
	void keepWhiteImage();

	void notifyCameraShutDown() { Q_EMIT cameraShutDown(); }
	void notifyAbort() { Q_EMIT abort(); }

#ifdef USE_OPENGL_SHARED
protected Q_SLOTS:
	void processImage(int camWidth, int camHeight, unsigned char *ptr);
#endif

	Q_SIGNALS : void cameraShutDown();
	void abort();
	void devicePropChanged();
	void captureFinished();
	void imageViewChanged(TRaster *ras);
	void imageSizeUpdated();
#ifdef USE_OPENGL_SHARED
	void imageChanged(int camWidth, int camHeight, unsigned char *ptr);
#endif
};

#ifdef WRITE_LOG_FILE

//===================================================================
// LogWriter

#include "tfilepath_io.h"

class LogWriter //Singleton
{
	Tofstream m_os;

public:
	LogWriter(TFilePath fp);

	void write(QString str);

public:
	static LogWriter *instance();
	~LogWriter();
};

#endif

#endif // TNZCAMERA_H