#include "CSyncProc.h"
#include <iostream>
#include <process.h>

extern "C"
{
#include <libavcodec/avcodec.h>
#include "libavformat/avformat.h"
#include "libavutil/frame.h"
};

#include "CVideoDataManager.h"
#include <Windows.h>
 
template<typename T>
void ClearQueue(std::queue<T>& q)
{
	std::queue<T> empty;
	std::swap(empty, q);
}

CSyncProc::CSyncProc()
{
	
}

CSyncProc::~CSyncProc()
{
	for (auto it = m_vecPacketManager.begin(); it != m_vecPacketManager.end(); it++)
	{
		delete (*it);
	}
	m_vecPacketManager.clear();
}

CSyncProc::CSyncProc(const CSyncProc& proc)
{

}

CSyncProc& CSyncProc::getInstance()
{
	static CSyncProc instance;
	return instance;
}

void CSyncProc::AddFun(void * p, FunUpdate fun)
{
	m_mapFun.insert(std::pair<void*, FunUpdate>(p, fun));
}

bool CSyncProc::UpdateTimeQueue(CVideoDataManager * pMan, double dTime)
{
	return true;

	if (m_bSync)
	{
		return false;
	}
	m_lockTime.lock();

	while (m_qTimeParam.size() != 0)
	{
		TimeParam tParam = m_qTimeParam.front();
		if (abs(dTime - tParam.dTime) > m_maxInternal)
		{
			m_qTimeParam.pop();
			std::cout << "VideoPlayer   UpdateTimeQueue failed " << std::endl;

			pMan->Clear();
			m_bSync = false;
		}
		else
		{
			std::cout << "VideoPlayer   UpdateTimeQueue push " << std::endl;
			break;
		}
	}

	TimeParam tParam;
	tParam.pParam = pMan;
	tParam.dTime = dTime;
	m_qTimeParam.push(tParam);

	if (m_qTimeParam.size() == m_mapFun.size())
	{
		ClearQueue(m_qTimeParam);
		std::cout << "VideoPlayer   UpdateTimeQueue suc " << std::endl;

		m_lockTime.unlock();

		if (m_bSync == false)
		{
			_beginthreadex(nullptr, 0, &CSyncProc::SyncThread, this, 0, 0);
		}

		return true;
	}
	m_lockTime.unlock();
	return false;
}

unsigned __stdcall CSyncProc::SyncThread(void * param)
{
	CSyncProc* p = (CSyncProc*)param;
	p->SyncProcessor();

	return 0;
}

void CSyncProc::SyncProcessor()
{
	std::cout << "CFrameProc SyncThreadProcessor m_mapFun.size()" << m_mapFun.size() << std::endl;
	for (auto it = m_mapFun.begin(); it != m_mapFun.end(); it++)
	{
		while (true)
		{
			if (it->second())
			{
				std::cout << "CFrameProc it->second() ok " << std::endl;
				break;
			}
		}

	}

	m_bSync = true;

}


unsigned __stdcall CSyncProc::RecvDataToSyncDataThread(void * param)
{
	CSyncProc* p = (CSyncProc*)param;
	p->RecvDataToSyncDataProcessor();

	return 0;
}

void CSyncProc::RecvDataToSyncDataProcessor()
{
	/*while (true)
	{
		if (!m_bSync)
		{
			Sleep(1000);
			continue;
		}
		
		int64_t  pts = 0; 
		CPacketInfo *pPack = nullptr;
		double dPts = 0 ;
		if (m_vecPacketManager[0]->PopData(pts, dPts, pPack))
		{
			m_vecPacketManager[0]->AddSyncData(pPack);
		}
		else
		{
			continue;
		}
	
		for (int  iLoop = 1; iLoop != m_vecPacketManager.size(); )
		{
			CPacketInfo *pPackDetail = nullptr;
			if (m_vecPacketManager[iLoop]->GetRecvData(pts, dPts, pPackDetail))
			{
				m_vecPacketManager[iLoop]->AddSyncData(pPackDetail);
				iLoop++;
			}
			
		}
		Sleep(5);
	}*/
	
	while (true)
	{
		m_lockManager.lock();
		for (int iLoop = 0; iLoop != m_vecPacketManager.size(); iLoop++ )
		{
			int64_t  pts = 0;
			CPacketInfo* pPack = nullptr;
			double dPts = 0;
			if (m_vecPacketManager[iLoop]->PopData(pts, dPts, pPack))
			{
				m_vecPacketManager[iLoop]->AddSyncData(pPack);
			}
		}
		m_lockManager.unlock();
		Sleep(5);
	}
}

void CSyncProc::AddDataManager(CVideoDataManager * pMan)
{
	m_lockManager.lock();
	m_vecPacketManager.emplace_back(pMan);
	m_lockManager.unlock();
}

void CSyncProc::Start()
{
	_beginthreadex(nullptr, 0, &CSyncProc::RecvDataToSyncDataThread, this, 0, 0);
}