/*
 * audioproc.c
 *
 *  Created on: 2021Äê11ÔÂ2ÈÕ
 *      Author: graydon
 */
#include <stdlib.h>
#include <stdio.h>
//#include <sys/platform.h>
//#include <sys/adi_core.h>
//#include <fstream>
#include "tob.h"
#include "crc.h"
#include "config.h"
#include "protocol.h"
#include "IModule.h"
#include "f2f.h"
#include "../drv/memory.h"


static ToB* tob = NULL;

ToB* ToB::GetInstance()
{
	return tob;
}

ToB::ToB(ubool dualDsp, u32 dspIndex )
	: dual_dsp(dualDsp), dsp_index(dspIndex),mList(32)
{
	if(tob != NULL) {
		delete tob;
	}
	tob = this;
	frames = NULL;
	processed = ufalse;
	mModuleNum =0;
	mLevelPacketNum =0;
	mModuleIndex.resize(0);
}

ToB::~ToB()
{
	toClear();
	tob = NULL;
}

uvoid ToB::SetMute(ubool mute)
{
	processed = (mute==0);
}
ErrStatus ToB::toClear()
{
	processed = ufalse;

	for (std::vector<IModule*>::iterator iter = mList.begin();
		iter != mList.end() ;iter++) {
		delete *iter;
	}
	mList.clear();
	mModuleIndex.clear();

	if(frames != NULL) {
		delete frames;
	}
	mModuleNum = 0;

	return ErrStatus::SUCCESS;
}

IModule* ToB::CreateBaseModule(u32 moduleType, u16 tag ,u16 rxNum, u16 txNum)
{
	ExportModules& em = ExportModules::Instance();
	ModuleEntry* entry = em.GetModuleEntry(moduleType);
	if (entry) {
		Create create = entry->GetEntry();
		if (create) {
			return create(tag, entry->link_enable , SAMPLE_RATE, SAMPLE_NUM, rxNum, txNum);
		}
	}
	return 	0;//new IModule(SAMPLE_RATE, SAMPLE_NUM, rxNum, txNum);
}



ErrStatus ToB::CreateModule(const u8* bin, u32 nbytes)
{
	FlowChartHead* head = (FlowChartHead*)bin;

	//check crc
	u32 tmp_crc ,crc = head->crc;
	head->crc = 0;
	tmp_crc = CRC::crc32(bin, nbytes);
	if (tmp_crc != crc) {
		//dbg_printf("flowchar crc check fail.\n");
		return ErrStatus::ERR_PARAM;
	}
	//dbg_printf("modules num %d, DSP1 Buffer %d,DSP2 Buffer %d.\n"
	//		,head->module_num,head->dsp1_buffer_num,head->dsp2_buffer_num);

	u32 size = sizeof(FlowChartHead);
	u32 nPhyInput =0 ,nPhyOutput=0;

	processed = ufalse;

	frames = new Frames(head->dsp_buffer_num[dsp_index]);

	do {
		Module* pmod = (Module*)(bin+ size);
		size += sizeof(Module);
		u16* mRxbufID = (u16*)(bin + size);	size += pmod->mRxNum * sizeof(u16);
		u16* mTxbufID = (u16*)(bin + size);	size += pmod->mTxNum * sizeof(u16);
		u16* mPhyID ;
		ubool bInput=ufalse,bOutput=ufalse;
		u16 input_num =0 ,output_num =0;

		if(pmod->mPhyModule == ModuleInterfaceType::PHY_INPUT){
			pmod->mRxNum = pmod->mTxNum;
			mPhyID = (u16*)(bin + size);	size += pmod->mTxNum * sizeof(u16);
			bInput = utrue;
		}
		else if(pmod->mPhyModule == ModuleInterfaceType::PHY_OUTPUT){
			pmod->mTxNum = pmod->mRxNum ;
			mPhyID = (u16*)(bin + size);	size += pmod->mRxNum * sizeof(u16);
			bOutput = utrue;
		}
		else {
			mPhyID = NULL;
		}

		if (pmod->mDsp != dsp_index)  continue;

#ifdef DEBUG
		dbg_printf("Module ID %d type %d rxnum %d txnum %d. \n",pmod->mID ,pmod->mType, pmod->mRxNum,pmod->mTxNum);
#endif
//		if(pmod->mID == 394) {
//			int ddr = sram_free_space(SRAM_DDR);
//			int ccm = sram_free_space(SRAM_CCM);
//			int l1 = sram_free_space(SRAM_L1);
//			printf("ddr %d ccm %d l1 %d.\n",ddr, ccm ,l1);
//		}
		IModule* m = CreateBaseModule(pmod->mType,pmod->mTag, pmod->mRxNum,pmod->mTxNum);
		if(!m) {
			dbg_printf("Module ID Create fail.\n", pmod->mID);
			continue;
		}

		m->SetModuleInfo(pmod->mID ,pmod->mType,pmod->mTag);
		mList.push_back(m);

		if(pmod->mID >= mModuleIndex.size()) {
			mModuleIndex.resize(pmod->mID + 1,0);
		}
		mModuleIndex[pmod->mID] = ++mModuleNum  ;

		for (size_t i = 0; i < pmod->mTxNum && !bOutput; i++){
			if (mTxbufID[i] > 0) {
				Frame* pcm = frames->GetFrame(mTxbufID[i]-1 );
				m->SetOutputChannelDataPtr(i, pcm);

				if (bInput) {
					if(nPhyInput < mPhyID[i]) nPhyInput = mPhyID[i];
					m->SetInputChannelDataPtr(i, pcm);
					SetRxChannelPtr(mPhyID[i]-1, pcm->Data());
				}
				output_num ++;
			}
			else {
				m->SetOutputChannelDataPtr(i, 0);
			}
		}
		for (size_t i = 0; i < pmod->mRxNum && !bInput; i++) {
			if (mRxbufID[i] > 0) {
				Frame* pcm = frames->GetFrame(mRxbufID[i]-1 );
				m->SetInputChannelDataPtr(i, pcm);

				if (bOutput) {
					if(nPhyOutput < mPhyID[i]) nPhyOutput = mPhyID[i];

					pcm = frames->AllocFrame();
					m->SetOutputChannelDataPtr(i, pcm);
					SetTxChannelPtr(mPhyID[i]-1, pcm->Data());
				}
				input_num ++;
			}
			else {
				m->SetInputChannelDataPtr(i, 0);
			}
		}

		m->Init();
	} while (size < nbytes);

	if (size != nbytes) {
		dbg_printf("check flowchart some error!\n");
	}
	dbg_printf("Phy InputNum %d, Output Num %d\n",nPhyInput,nPhyOutput);
	SetNumOfChannels(nPhyInput, nPhyOutput);
	//processed = utrue;

	return 	ErrStatus::SUCCESS;
}

ErrStatus ToB::toProc()
{
	if(processed) {
		for (auto iter = mList.begin();
			iter != mList.end() ;iter++) {
			(*iter)->Proc();
		}
	}
	else {
		MuteOutput();
	}
	return ErrStatus::SUCCESS;
}

ErrStatus ToB::toCtrl(u32 mID, u32 pID, const s16* val, u32 num)
{
	if(mID >= mModuleIndex.size() || mModuleIndex[mID] == 0) {
		return ErrStatus::ERR_PARAM;
	}

	IModule* m = mList[mModuleIndex[mID]-1];
	if( m != NULL) {
		m->Ctrl(pID, val, num);
	}

	return ErrStatus::SUCCESS;
}

ErrStatus ToB::toCtrl(const u8* bin , u32 nbytes)
{
	FlowChartHead* head = (FlowChartHead*)bin;

	//check crc
	u32 tmp_crc ,crc = head->crc;
	head->crc = 0;
	tmp_crc = CRC::crc32(bin, nbytes);
	if (tmp_crc != crc) {
		//dbg_printf("flowchar crc check fail.\n");
		return ErrStatus::ERR_PARAM;
	}

	u32 size = sizeof(FlowChartHead);

	while(size < nbytes) {
		Param* h = (Param*)(bin+size);
		size += sizeof(Param);
		const s16* val = (const s16*)(bin+size);

		toCtrl(h->mID, h->pID, val, h->num);
		size += h->num*sizeof(s16);
	}

	if(size != nbytes) {
		//dbg_printf("check preset has some error!\n");
	}

	processed = utrue;
	return ErrStatus::SUCCESS;
}

u32 ToB::GetLevels(Message* handle , MSG* pmsg)
{
	u32 n =0,len =0;
	s8 buffer[MSG_DATA_LEN];
	u32 packetNo =0;

	if( !processed ) {
		return 0;
	}

	for (std::vector<IModule*>::iterator iter = mList.begin();
		iter != mList.end() ; iter++) {
		IModule* m = *iter;

		u32 ID = m->GetModuleID();

		struct Level* p = (struct Level*)buffer;

		n = sizeof(struct Level);
		p->mID = ID;

		/*graydon-230905: ¶àͨµÀÄ£¿é»á³öÏÖµçƽÊýÁ¿³¬³ö1024£¬±ÈÈç32ͨµÀ32µã·´À¡ÒÖÖÆ,
		 * ps: ÌÖÂÛ¾ö¶¨¶àͨµÀÄ£¿éÔÚ½çÃæ×öÊýÁ¿ÏÞÖÆÇÒ¹ý¶à¶àͨµÀ²»·ûºÏÓ¦ÓÃÐèÇó.
		 */
		p->num = m->GetLevel((s16*)(buffer + n));
		if(p->num == 0) continue;

		n += p->num*sizeof(s16);

		//¹ýÈ¥µÄµçƽÊýÁ¿+µ±Ç°µÄµçƽÊýÁ¿ÊÇ·ñ´óÓÚMSG_DATA_LEN
		if(len + n > MSG_DATA_LEN) {
			pmsg->pktNo = packetNo++;
			pmsg->totalPkts = mLevelPacketNum;
			pmsg->Enc(MsgType::MSG_LEVEL_GET_RES, 0, len);
			handle->Send(pmsg);//Èë¶ÓÁÐ
			len = 0;
		}
		memcpy(pmsg->data+len, p , n);
		len += n;
	}

	if(len > 0) {
		pmsg->pktNo = packetNo++;
		pmsg->totalPkts = mLevelPacketNum;
		pmsg->Enc(MsgType::MSG_LEVEL_GET_RES, 0, len);
		handle->Send(pmsg);
	}

	if(packetNo > 0){
		mLevelPacketNum = packetNo;
	}
	return n;
}


//cpu = ms*SAMPLE_RATE/SAMPLE_NUM
//cpu *100 -> u16
//cpu * 100 -> percent.
u32 ToB::GetModuleCPU(Message* handle , MSG* pmsg)
{
	u32 n =0;
	u32 cpu = (u32)(SAMPLE_RATE/SAMPLE_NUM*100000) ;
	u32* data = (u32*)pmsg->data;

	if( !processed ) {
		return 0;
	}

	for (std::vector<IModule*>::iterator iter = mList.begin();
		iter != mList.end() ; iter++) {
		IModule* m = *iter;
		ufloat time = m->GetRuntime();
		ModuleType type = (ModuleType)m->GetModuleType();
		u32 tag = m->GetModuleTag();
		u16 rxNum = m->GetModuleInputNum();
		u16 txNum = m->GetModuleOutputNum();
		u32 ID = m->GetModuleID();


		switch(type) {
		case ModuleType::Mixer:
			time = time / (rxNum * txNum ) ;
			break;
		case ModuleType::EQ:
		case ModuleType::NHS:
			time = time / (tag * rxNum) ;
			break;
		case ModuleType::SignalGenerator:
		case ModuleType::Ducker:
		case ModuleType::ContinuitySPL:
			time = time / txNum ;
			break;
		default:
			time = time / rxNum ;
			break;
		}
		data[n++] = ID;
		data[n++] = (u32)(time* cpu);

		if(n*sizeof(u32) >= MSG_DATA_LEN) {
			pmsg->Enc(MsgType::MSG_MODULE_CPU_RES, 0, MSG_DATA_LEN);
			handle->Send(pmsg);
			n = 0;
		}
	}

	if(n > 0) {
		pmsg->Enc(MsgType::MSG_MODULE_CPU_RES, 0, n*sizeof(u32));
		handle->Send(pmsg);
	}

	return 0;
}