#include <stdio.h>
#include "JZsdkLib.h"

#include "OpusFile.h"

#define OPUS_TEMP_SAVE_DIR "/root/test_audio.opus"


static T_OpusSaveParam g_TempOpus = {0};
static int g_OpusFile_SaveFlag = JZ_FLAGCODE_OFF; //判断是否开启保存中的标志位
static int g_OpusFile_SaveLen = 0; //当前文件已存储的长度
static T_JZTaskHandle s_OpusSaveThread = NULL;
static FILE* g_OpusFile_SaveFp = NULL; //opus文件的临时保存指针

static void* OpusFile_SaveOpusPrint(void* arg);

int OpusFile_GetSaveFlag()
{
	return g_OpusFile_SaveFlag;
}

/******************
 *
 *
 *  opus流存储开始
 *  采样率如果填0 则默认16000
 *  birrate如果填0 则默认16000
 *  channels 默认0 1都是1 暂不支持2频道
 *
 * **********************/
T_JZsdkReturnCode OpusFile_SaveOpusFileStart(T_OpusSaveParam TempOpus)
{
	T_JZsdkOsalHandler* OsalHandler = JZsdk_Platform_GetOsalHandler();

	if (g_OpusFile_SaveFlag == JZ_FLAGCODE_ON)
	{
		JZSDK_LOG_ERROR("opus文件保存功能已经开启");
		return JZ_ERROR_SYSTEM_MODULE_CODE_IS_BUSY;
	}

	//查询是否在解码数据中，如果在解码中也不能传入新的数据
	if(OpusFile_GetDecodeFinshFlag() == JZ_FLAGCODE_ON)
	{ 
		JZSDK_LOG_ERROR("正在进行解码opus，无法传入新的opus内容");
		return JZ_ERROR_SYSTEM_MODULE_CODE_IS_BUSY;
	}

	memset(&g_TempOpus, 0, sizeof(T_OpusSaveParam));
	memcpy(&g_TempOpus, &TempOpus, sizeof(T_OpusSaveParam));

	if (TempOpus.saveflag = JZ_FLAGCODE_ON)
	{
		JZSDK_LOG_INFO("上传的opus文件存储路径为:%s SampleRate:%d Bitrate:%d  Channels:%d", 
			OPUS_TEMP_SAVE_DIR, TempOpus.SampleRate, TempOpus.BitRate, TempOpus.Channels);
	}
	else
	{
		JZSDK_LOG_INFO("上传的opus文件存储路径为:/root/sdcard/opus/%s SampleRate:%d Bitrate:%d  Channels:%d",
			TempOpus.FileName, TempOpus.SampleRate, TempOpus.BitRate, TempOpus.Channels);
	}

	if (g_OpusFile_SaveFp != NULL)
	{
		JZSDK_LOG_ERROR("要保存的opus文件已经打开,请先关闭保存功能");
		return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
	}

	g_OpusFile_SaveFp = fopen(OPUS_TEMP_SAVE_DIR, "wb");
	if (g_OpusFile_SaveFp == NULL)
	{
		JZSDK_LOG_ERROR("打开opus文件失败");
		return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
	}

	g_OpusFile_SaveFlag = JZ_FLAGCODE_ON;

	//创建存储显示线程
	OsalHandler->TaskCreate("OpusSavePrint", OpusFile_SaveOpusPrint, 8192, NULL, &s_OpusSaveThread);

	return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}


/******************
* 
*
*  存储opus流中
*
*
* **********************/
T_JZsdkReturnCode OpusFile_SaveOpusFileStream(unsigned char* Stream, int StreamLen)
{
	if (g_OpusFile_SaveFlag == JZ_FLAGCODE_OFF)
	{
		JZSDK_LOG_ERROR("没有打开opus文件保存功能");
		return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
	}

	if (g_OpusFile_SaveFp == NULL)
	{
		JZSDK_LOG_ERROR("要保存的opus文件未打开");
		return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
	}

	fseek(g_OpusFile_SaveFp, g_OpusFile_SaveLen, SEEK_SET);
	int writeLen = fwrite(Stream, 1, StreamLen, g_OpusFile_SaveFp);
	if (writeLen != StreamLen)
	{
		JZSDK_LOG_ERROR("opus文件写入失败");
		return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
	}

	fflush(g_OpusFile_SaveFp);
	g_OpusFile_SaveLen += StreamLen;

	return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}


/******************
 *
 *
 *  结束存储opus文件
 *
 *  checkflag是否需要校正 或校正类型
 *  checkcode 校正码
 *
 *
 * **********************/
T_JZsdkReturnCode OpusFile_SaveOpusFileEnd(int CheckFlag, unsigned char* CheckCode)
{
	T_JZsdkReturnCode ret = JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;

	//标志位判定
	if (g_OpusFile_SaveFlag == JZ_FLAGCODE_OFF)
	{
		JZSDK_LOG_ERROR("没有打开opus文件保存功能");
		return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
	}

	//文件指针判定
	if (g_OpusFile_SaveFp == NULL)
	{
		JZSDK_LOG_ERROR("要保存的opus文件未打开");
		g_OpusFile_SaveFlag = JZ_FLAGCODE_OFF;
		return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
	}

	//关闭存储的文件
	fflush(g_OpusFile_SaveFp);
	fclose(g_OpusFile_SaveFp);
	g_OpusFile_SaveFp = NULL;

	JZSDK_LOG_INFO("已存储opus文件, 其长度为:%d", g_OpusFile_SaveLen);

/***********************************************************
 *
 *    校验部分
 *
 *
 * *********************************************************/
	if (CheckFlag != JZ_FLAGCODE_OFF)
	{
		switch (CheckFlag)
		{
		case JZSDK_CHECK_SUM_TYPE_MD5:
		{
			JZSDK_LOG_INFO("opus保存使用md5校验码");
			//1、获取文件的md5校验码
			ret = JZsdk_CheckSum(JZSDK_CHECK_SUM_TYPE_MD5, OPUS_TEMP_SAVE_DIR, CheckCode, 32);
		}
		break;

		case JZSDK_CHECK_SUM_TYPE_SRC32:
		{
			JZSDK_LOG_INFO("opus保存使用src32校验码");
			//1、获取文件的src32校验码
			ret = JZsdk_CheckSum(JZSDK_CHECK_SUM_TYPE_SRC32, OPUS_TEMP_SAVE_DIR, CheckCode, 4);
		}
		break;

		default:
		{
			JZSDK_LOG_ERROR("opus保存校验码类型错误");
			g_OpusFile_SaveFlag = JZ_FLAGCODE_OFF;
			ret = JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
		}
		break;
		}

		if (ret != JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS)
		{
			JZSDK_LOG_ERROR("opus保存校验失败");
			JZsdk_Osal_delete(OPUS_TEMP_SAVE_DIR);
			g_OpusFile_SaveFlag = JZ_FLAGCODE_OFF;

			return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
		}
	}
	else
	{
		JZSDK_LOG_INFO("opus保存无需校验码");
	}

/***********************************************************
 *
 *    额外存储部分
 *
 *
 * *********************************************************/

	if (g_TempOpus.saveflag != JZ_FLAGCODE_OFF && g_TempOpus.FileName != NULL)
	{
		//将opus文件复制一份到存储的目录
		char dir[128] = {0};
		snprintf(dir, 128, "/root/sdcard/opus/%s", g_TempOpus.FileName);
		JZsdk_copy_file_byC(OPUS_TEMP_SAVE_DIR, dir);
	}

/***********************************************************
*
*    解码部分
*
*
* *********************************************************/

	//先给解码模块设置参数
	if(g_TempOpus.BitRate != 0)
	{
		OpusFile_SetDecodeBitrate(g_TempOpus.BitRate);
	}
	else
	{
		OpusFile_SetDecodeBitrate(16000);
	}

	if (g_TempOpus.Channels != 0)
	{
		OpusFile_SetDecodeChannels(g_TempOpus.Channels);
	}
	else
	{
		OpusFile_SetDecodeChannels(1);
	}
	
	if (g_TempOpus.SampleRate != 0)
	{
		OpusFile_SetDecodeSampleRate(g_TempOpus.SampleRate);
	}
	else
	{
		OpusFile_SetDecodeSampleRate(16000);
	}

	ret = OpusFile_DecodeOpus(OPUS_TEMP_SAVE_DIR);

	g_OpusFile_SaveFlag = JZ_FLAGCODE_OFF;

	return ret;
}


/******************
 *
 *
 *  opus文件 存储显示线程
 *
 *
 * **********************/
static void* OpusFile_SaveOpusPrint(void* arg)
{
	while (g_OpusFile_SaveFlag == JZ_FLAGCODE_ON)
	{
		int num = 0;

		JZSDK_LOG_INFO("opus存储功能开启中,当前已存入 %d 字节", g_OpusFile_SaveLen);

		//适时延迟
		while (num < 100 && g_OpusFile_SaveFlag == JZ_FLAGCODE_ON)
		{
			delayMs(10);
			num++;
		}
	}
}