/*
 * messageproc.c
 *
 *  Created on: 2021年11月1日
 *      Author: graydon
 */
#include <string.h>
#include <stdlib.h>
#include <SRU.h>
#include "messageproc.h"
#include "../drv/spi.h"
#include "../drv/gpio.h"

#include "F2F.h"
#include "ModuleProAPI.h"
#include "tg/tg_adapter.h"
#include "tg/tg_scene.h"
#include "var_state.h"
#include "tob.h"

s32 Message::Send(MsgType msg_type, uvoidptr buffer, u32 len)
{
	MSG msg;

	msg.Enc(msg_type, buffer, len);
	return txQueue->Push(msg);
}

s32 Message::Send(MSG* pmsg )
{
	u32 ret=  txQueue->Push(*pmsg);
	return ret;
}

uvoid Message::ReportDspStatus(MSG* pmsg)
{
	s32 size = dsp_status_q.get_device_status_ptr(pmsg->data,MSG_DATA_LEN);
	if(size > 0) {
		pmsg->Enc(MsgType::MSG_DSP_STATUS_REPORT, 0, size);
		txQueue->Push(*pmsg);
	}
}

uvoid Message::ReportLevel(MSG* pmsg)
{
	int i;
	int data_len;

	ToB* tob = ToB::GetInstance();
	u16 LevelCnt = tob->GetLevels(Levels);	//864 levels
	u32 msgLen = LevelCnt * sizeof(*Levels);
	int Packegs = (msgLen+MSG_DATA_LEN-1)/MSG_DATA_LEN;

	pmsg->magic = 0x5aa5;
//	pmsg->dataLen = LevelCnt;
	pmsg->totalPkts = Packegs;
//	pmsg->pktNo = 1;
	pmsg->msgType = MSG_GET_LEVEL;
	pmsg->msgID = LevelCnt;

	// Split packeg
	for(i=0; i<Packegs; i++){
		if(i == Packegs-1){
			data_len = msgLen - i * MSG_DATA_LEN;
		}
		else{
			data_len = MSG_DATA_LEN;
		}

		memcpy(pmsg->data, Levels + i * MSG_DATA_LEN / sizeof(*Levels), data_len);
		pmsg->dataLen = data_len;
		pmsg->pktNo = i;

		pmsg->Enc(MsgType::MSG_GET_LEVEL, 0, data_len);
		txQueue->Push(*pmsg);
	}
}

s32 Message::ParamCtrl(MSG* pmsg)
{
#define PCTL_MAX_PKT 5
#pragma section("seg_ext_pmda")
	static s8 buffer[MSG_DATA_LEN*PCTL_MAX_PKT];
	struct ParamCtrl * ptr = (struct ParamCtrl *)buffer;
	ToB* tob = ToB::GetInstance();

	if(pmsg->totalPkts > PCTL_MAX_PKT || pmsg->pktNo >= pmsg->totalPkts) {
		return -1 ;
	}
	memcpy(buffer + pmsg->pktNo*MSG_DATA_LEN , pmsg->data, pmsg->dataLen);

	if(tob != NULL && pmsg->pktNo == pmsg->totalPkts - 1) {
		VarState& var = VarState::GetInstance();
		u32 type = tob->GetModuleType(ptr->mid);
		s32 data_num = (pmsg->totalPkts-1)*MSG_DATA_LEN+pmsg->dataLen;

		s16* data = (s16*)(ptr + 1);

		data_num = (data_num - sizeof(struct ParamCtrl))/sizeof(s16);
//		ptr->mid = var.pscene->get_module_id(ptr->mid, type, ptr->cmd) ;

		tob->toCtrl(ptr->mid, ptr->cmd, data, data_num);
	}

	return 0;
}


s32 Message::PresetProcess(MSG* pmsg)
{
	VarState& var = VarState::GetInstance();
	static u8* bin = NULL;

	if(pmsg->pktNo == 0 && bin != NULL ) {
		sram_free(SRAM_DDR, bin);
		bin = NULL;
	}

	if(pmsg->pktNo == 0 && bin == NULL) {
		bin = (u8*)sram_malloc(SRAM_DDR, mem_any, pmsg->totalPkts*MSG_DATA_LEN);
	}
	if(bin == NULL) return -1;
//	printf("No:%d len %d\n", pmsg->pktNo,pmsg->dataLen);
	var.TopoLoading = utrue;
	memcpy(bin+pmsg->pktNo*MSG_DATA_LEN, pmsg->data , pmsg->dataLen);

	if(pmsg->pktNo == pmsg->totalPkts -1) {
		u32 size = (pmsg->totalPkts -1)*MSG_DATA_LEN+pmsg->dataLen;

		if(var.pscene) {
			ToB* tob = ToB::GetInstance();

			SetTxRxNullBufferPtr();
			for(s32 i =0 ;i < IntDataType::COUNT;i++){
				SetNumOfChannels(static_cast<IntDataType>(i) , 0, 0);
			}
			if(var.pscene->set_parameters_content(bin, size) != 0){
				//fail
				var.TopoStatus = PRESET_STA::PRESET_ERR;
			}
			else if(tob){
				u8* content = (u8*)sram_malloc(SRAM_DDR, mem_any, 45128);//45*1024);
				s32 size ;

				var.pscene->update_module();
				size = var.pscene->convert_to_bin(content);

				tob->toClear();
				tob->toAnalysis(content, size);

				sram_free(SRAM_DDR, content);
				var.TopoStatus = PRESET_STA::PRESET_DONE;
			}
		}
		sram_free(SRAM_DDR, bin); bin = NULL;
		var.TopoLoading = ufalse ;
	}

	return 0;
}

/*void Message::param_init(ptag_device_config pDevCfg)
{
	pDevCfg->dual_dsp = 0;
	pDevCfg->dsp_index = 0;
	pDevCfg->local_rx_num = 16;
	pDevCfg->local_tx_num = 16;
	pDevCfg->dante_rx_num = 16;
	pDevCfg->dante_tx_num = 16;
	pDevCfg->external_clock = 1;
	pDevCfg->scene_size = 1000;
	pDevCfg->level_num = 10;
	pDevCfg->modulelist = 9;
	pDevCfg->hardware_type = 1;

}*/

s32 Message::HandshakeMessageProcess(MSG* pmsg)
{
	VarState& var = VarState::GetInstance();

	ptag_device_config device_config = (ptag_device_config)pmsg->data;
	struct DSPConfig dspconfig ;

	if(var.HandShakeSuccesful == ufalse) {
		//可以根据ptag_device_config.hardware_type动态适配型号.
		if(var.pscene){
			delete var.pscene;
			var.pscene = NULL;
		}

//		param_init(device_config);
		hw_adapter_t* _adapter = new tg_hw_adapter_t(device_config->dual_dsp,device_config->dsp_index
							,device_config->local_rx_num,device_config->local_tx_num
							,device_config->dante_rx_num,device_config->dante_tx_num);
		var.pscene = new(SRAM_DDR) tgScene(_adapter);

		_adapter->config_board(&dspconfig);
		new(SRAM_DDR) ToB(device_config->dual_dsp, device_config->dsp_index);

		SAMPLE_NUM = dspconfig.mSampleNum;
		var.master_intr = dspconfig.mIntrNo;
		var.g_level_report_interval = LEVEL_REPORT_TIME(dspconfig.mLevelReportInt);

		ModuleLeveldBUSetting(dspconfig.mConvertUnit);
		//Config(conf);
		RouteConfig(dspconfig.routes, dspconfig.mRouteNum);
		SRCsConfig(0 , &dspconfig.srcs[0]);
		SRCsConfig(1 , &dspconfig.srcs[4]);
		PCGsConfig(dspconfig.pcgs);
		SportsConfig(dspconfig.sports);
		//LinportConfig(dspconfig.linkport);

		var.HandShakeSuccesful = utrue;
	}

	Send(MsgType::MSG_ACK_REQ, 0 , 0);

	return 0;
}

s32 Message::RxMessageHandler(MSG* pmsg)
{
	extern ubool  systemMute;
	if(pmsg->magic != 0x5aa5) {
		//printf("magic error.\n");
		return -1;
	}

	switch(pmsg->msgType){
	case MsgType::MSG_PARAM_CTRL:
		ParamCtrl(pmsg);
		break;
	case MsgType::MSG_GET_LEVEL:
		ReportLevel(pmsg);
		break;
	case MsgType::MSG_PARAM_CONFIG:
	case MsgType::MSG_PARAM_COMPLETED:
		PresetProcess(pmsg);
		break;
	case MsgType::MSG_ACK_REQ:
		HandshakeMessageProcess(pmsg);
		break;
	default:
		break;
	}

	return 0;
}



uvoid Message::Proc()
{
	u32 status = 0;
//	static bool bSetOk = 0;

//	MSG* p = (MSG*)SPI_Rx_BUFFER;
//	if (0 == bSetOk) {
//		HandshakeMessageProcess(p);	//virtual communication
//		PresetProcess(p);
//		bSetOk = 1;
//	}

	if(SPIRxDone) {
		RxMessageHandler((MSG*)SPI_Rx_BUFFER);
		if(txQueue->Count() > 0) {
			txQueue->Pop(*(MSG*)SPI_Tx_BUFFER);
			GPIO_SetOutPut(GPIOA, GPIO_Pin12, GPIO_LOW);
		}
		else {
			SPI_Tx_BUFFER[0] = 0;
			GPIO_SetOutPut(GPIOA, GPIO_Pin12, GPIO_HIGH);
		}
		SPI2_SetTransMode(SPIStatus::SPI_TRX);
		GPIO_SetOutPut(GPIOB, GPIO_Pin5, GPIO_HIGH);
	}
}