#include "SpBase.h"
#include "SpIni.h"

#ifdef RVC_OS_WIN
#include <Shlwapi.h>
#include "../../Other/libwmpplayer/libwmpplayer.h"
#include "../../Other/libimgplayer/libimgplayer.h"
#else
#include <pthread.h>
#include <signal.h>
#include <unistd.h>
#include "../../Other/libmediaplayer/libmediaplayer.h"
#include "../../Other/libpictureplayer/libpictureplayer.h"
#include <semaphore.h>
#endif // RVC_OS_WIN


#include "LocalMediaPlay_server_g.h"
#include "AdvertBase/AdvertSync.h"
#include "AdvertManage/mediaManage.h"
#include <iostream>


//#include "SpTest.h"
#include "modVer.h"


using namespace LocalMediaPlay;

#define LOG_EVT_SELFCHECK_IEBROWSER_IDLE	0x50500007				//IEBrowser重启
#define MAX_PLAY_CHANNELS					3						//最大播放通道数

typedef struct {
	int nCfgInx;
	int nWndX;
	int nWndY;
	int nWndWidth;
	int nWndHeight;
}MediaPlayParam;

//DWORD WINAPI qryMedia(LPVOID lpv);
//DWORD WINAPI MediaPlayThread(LPVOID param);
//DWORD WINAPI clearOutdata(LPVOID lpv);
//DWORD WINAPI CheckAudioThread(LPVOID param);

#ifdef RVC_OS_WIN
class CLocalMediaPlayEntity : public CWmpHostApi, public CImgHostApi, public CEntityBase, public ILogListener
#else
class CLocalMediaPlayEntity : public CMediaHostApi, public CPicHostApi, public CEntityBase, public ILogListener
#endif // RVC_OS_WIN
{

public:
	CLocalMediaPlayEntity();
	virtual ~CLocalMediaPlayEntity();

	virtual const char *GetEntityName() const { return "LocalMediaPlay"; }

	virtual bool IsService() const { return true; }

	const char* GetEntityVersion() const override
	{
		return MODULE_VERSION_FULL;
	}

	virtual CServerSessionBase *OnNewSession(const char* pszRemoteEntityName, const char * pszClass);

#ifdef RVC_OS_WIN
	virtual BOOL LoadPlayConfig(CWmpPlayConfig& config, int CfgInx);
	virtual BOOL LoadPlayConfig(CImgPlayConfig& config, int CfgInx);
	virtual void WmpDebug(const char* fmt, ...);
	virtual void ImgDebug(const char* fmt, ...);
#else
	virtual int LoadPlayConfig(CMediaPlayConfig& config, int CfgInx);
	virtual int LoadPlayConfig(CPicPlayConfig& config, int CfgInx);
	virtual void Debug(const char* fmt, ...);
	virtual void PicDebug(const char* fmt, ...);
	virtual void AudioPlayFinished();
	virtual int GetMediaPlayerIcoPath(char* strPath, size_t uLen);
	virtual int GetPicPlayerIcoPath(char* strPath, size_t uLen);
	bool GetPlayFlag();
	
#endif // _WIN32

	virtual void OnLog(const CAutoArray<CUUID> &SubIDs, const CUUID nLogID, const LogTypeEnum eLogType, const SeverityLevelEnum eLevel,
		const DWORD dwSysError, const DWORD dwUserCode, const DWORD dwEntityInstanceID, const WORD wEntityDevelID,
		const CAutoArray<DWORD> &Param, const char *pszEntityName, const char *pszModuleName, const char *pszMessage);

	virtual void OnPreStart(CAutoArray<CSimpleStringA> strArgs, CSmartPointer<ITransactionContext> pTransactionContext);

	ErrorCodeEnum __OnStart(ErrorCodeEnum preOperationError);

	virtual void OnPreClose(EntityCloseCauseEnum eCloseCause, CSmartPointer<ITransactionContext> pTransactionContext);

	ErrorCodeEnum __OnClose(ErrorCodeEnum preOperationError);

	void StartVideo(int nCfgInx, int nWndX, int nWndY, int nWndWidth, int nWndHeight);

	void StartAudio(const char *pAudioNames);

	void StartImage(int nCfgInx, int nWndX, int nWndY, int nWndWidth, int nWndHeight);

	void StopVideo(int nCfgInx);

	void StopAudio();

	void StopImage(int nCfgInx);

	void StopAll();

	bool GetLocalVideoVolume(int nCfgInx, int &nVolume);
	bool SetLocalVideoVolume(int nCfgInx, int nVolume);
	std::pair<bool, int> GetLocalAudioVolume();
	bool SetLocalAudioVolume(int nVolume);
	bool IsRunConfigExist();

protected:
	// 音频播放对象指针
#ifdef RVC_OS_WIN
	Clibwmpplayer* m_pAudioPlayer;
#else
	Clibmediaplayer* m_pMediaAudioPlayer;
#endif // RVC_OS_WIN

private:

	virtual void OnSelfTest(EntityTestEnum eTestType, CSmartPointer<ITransactionContext> pTransactionContext);

	// 按分隔符分隔字符串
	void CStringSplit(char *str, char **result, const char *del);


	//friend DWORD WINAPI clearOutdata(LPVOID lpv);
	
#ifdef RVC_OS_WIN
	friend DWORD WINAPI MediaPlayThread(LPVOID param);
	friend DWORD WINAPI qryMedia(LPVOID lpv);
	friend DWORD WINAPI CheckAudioThread(LPVOID param);
#else
	friend void* queryMedia(void* param);
	friend void* StartAudioPlayingThreadFunc(void* param);
	friend void* StartMediaPlayFunc(void* param);
#endif // RVC_OS_WIN

	void setMediaPath();
	void SecureClientRelease();
	bool SecureClientConnect();

	void loadDefaultMedia();

	int GetPlayerIcoPath(char* strPath, size_t uLen);
private:
	int m_id_seq;
	CUUID m_SubIDIEIdle;

#ifdef RVC_OS_WIN
	// 视频播放对象指针数组
	Clibwmpplayer* m_pVideoPlayer[MAX_PLAY_CHANNELS];
	// 图片播放对象指针数组
	Clibimgplayer* m_pImagePlayer[MAX_PLAY_CHANNELS];
#else
	// 媒体播放对象指针数组
	Clibmediaplayer* m_pMediaPlayer[MAX_PLAY_CHANNELS];
	// 图片播放对象指针数组    add by clp   20201103
	Clibpictureplayer* m_pPicturePlayer[MAX_PLAY_CHANNELS];
#endif // RVC_OS_WIN

	//连接获取最新广告资源
	CAdvertSyncConnection *m_connection;
	mediaManage m_mediaManage;
	MediaPlayParam m_mediaParam;
	int m_defaultVolum;
	std::string m_lastPlayAudio;

#ifdef RVC_OS_WIN
	HANDLE m_scanThread, m_playThread;
	vector<CWmpPlayConfig> m_defaultVideo;
	vector<CWmpPlayConfig> m_defaultAudio;
	vector<CImgPlayConfig> m_defaultImg;
#else
	pthread_t m_scanThreadId;
	vector<CMediaPlayConfig> m_Videos;
	vector<CMediaPlayConfig> m_Audios;
	vector<CPicPlayConfig> m_defaultPic;
	pthread_t m_uMediaPlayThreadId;
	bool m_badplayflag;
	sem_t m_scanexit_sem;
#endif // RVC_OS_WIN
};


class CLocalMediaPlaySession : public PlayService_ServerSessionBase
{
public:
	CLocalMediaPlaySession(CLocalMediaPlayEntity* pEntity, int id) : m_id(id), m_pEntity(pEntity)
	{
	}

	virtual void Handle_StartPlayVideo(SpReqAnsContext<PlayService_StartPlayVideo_Req, PlayService_StartPlayVideo_Ans>::Pointer ctx);

	virtual void Handle_StartPlayAudio(SpReqAnsContext<PlayService_StartPlayAudio_Req, PlayService_StartPlayAudio_Ans>::Pointer ctx);

	virtual void Handle_StartPlayImage(SpReqAnsContext<PlayService_StartPlayImage_Req, PlayService_StartPlayImage_Ans>::Pointer ctx);

	virtual void Handle_StopPlayVideo(SpReqAnsContext<PlayService_StopPlayVideo_Req, PlayService_StopPlayVideo_Ans>::Pointer ctx);

	virtual void Handle_StopPlayAudio(SpReqAnsContext<PlayService_StopPlayAudio_Req, PlayService_StopPlayAudio_Ans>::Pointer ctx);

	virtual void Handle_StopPlayImage(SpReqAnsContext<PlayService_StopPlayImage_Req, PlayService_StopPlayImage_Ans>::Pointer ctx);

	virtual void OnClose(ErrorCodeEnum eErrorCode);

	virtual void Handle_GetLocalVideoVolume(SpReqAnsContext<PlayService_GetLocalVideoVolume_Req, PlayService_GetLocalVideoVolume_Ans>::Pointer ctx);

	virtual void Handle_SetLocalVideoVolume(SpReqAnsContext<PlayService_SetLocalVideoVolume_Req, PlayService_SetLocalVideoVolume_Ans>::Pointer ctx);

	virtual void Handle_GetLocalAudioVolume(SpReqAnsContext<PlayService_GetLocalAudioVolume_Req, PlayService_GetLocalAudioVolume_Ans>::Pointer ctx);

	virtual void Handle_SetLocalAudioVolume(SpReqAnsContext<PlayService_SetLocalAudioVolume_Req, PlayService_SetLocalAudioVolume_Ans>::Pointer ctx);


private:
	int m_id;
	CLocalMediaPlayEntity* m_pEntity;
};