#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <getopt.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/mount.h>
#include <sys/wait.h>
#include "sample_comm.h"
#include "sample_comm_aov.h"
#include "rk_mpi_adec.h"
#include "rk_mpi_aenc.h"
#include "rk_mpi_ai.h"
#include "rk_mpi_ao.h"
#include "rk_mpi_amix.h"

#define MOUNT_PATH "/mnt/sdcard"
#define TEST_FILE_PATH "/mnt/sdcard/aov_test.txt"
#define TEST_FILE_SIZE (1024 * 128)

static RK_CHAR optstr[] = "?:l:s:e:a:o:";

static char *output_path = NULL;

static const struct option long_options[] = {
    {"loop_count", required_argument, NULL, 'l'},
    {"help", optional_argument, NULL, '?'},
    {"enable_ethernet", optional_argument, NULL, 'e'},
    {"enable_sdcard", optional_argument, NULL, 's'},
    {"enable_audio", optional_argument, NULL, 'a'},
    {"output_path", optional_argument, NULL, 'o'},
    {NULL, 0, NULL, 0},
};

static void print_usage(const RK_CHAR *name) {
	printf("usage example:\n");
	printf("\t-l | --loop_count: total test loop, Default 1\n");
	printf("\t-e | --enable_ethernet: enable ethernet, Default 0\n");
	printf("\t-s | --enable_sdcard: enable sdcard, Default 0\n");
	printf("\t-a | --enable_audio: enable sdcard, Default 0\n");
	printf("\t-o | --output_path: set audio output file path, Default NULL\n");
}

static int mount_sdcard() {
	// mount sd
	int ret = RK_SUCCESS;
	if (access("/dev/mmcblk1p1", F_OK) == 0) {
		ret = mount("/dev/mmcblk1p1", MOUNT_PATH, "vfat", 0, NULL);
		if (ret != 0)
			printf("[%s()] mount failed because %s\n", __func__, strerror(errno));
		else
			printf("[%s()] mount success\n", __func__);
	} else if (access("/dev/mmcblk1", F_OK) == 0) {
		ret = mount("/dev/mmcblk1", MOUNT_PATH, "vfat", 0, NULL);
		if (ret != 0)
			printf("[%s()] mount failed because %s\n", __func__, strerror(errno));
		else
			printf("[%s()] mount success\n", __func__);
	} else {
		printf("[%s()] no appropriate parttion!\n", __func__);
		ret = RK_FAILURE;
	}
	return ret;
}

static int unmount_sdcard() {
	int ret = 0;
	ret = umount2(MOUNT_PATH, MNT_DETACH);
	if (ret == 0)
		printf("[%s()] unmount success\n", __func__);
	else
		printf("[%s()] unmount failed because %s\n", __func__, strerror(errno));

	return ret;
}

static int create_test_file() {
	int fd;
	int random = rand();
	int write_arr[TEST_FILE_SIZE];
	int i = 0;
	fd = open(TEST_FILE_PATH, O_RDWR | O_TRUNC | O_CREAT, 777);
	if (fd < 0) {
		printf("[%s()] open failed: %s\n", __func__, strerror(errno));
		return RK_FAILURE;
	}
	for (i = 0; i != TEST_FILE_SIZE; ++i)
		write_arr[i] = (random * i);
	write(fd, write_arr, sizeof(write_arr));
	fsync(fd);
	close(fd);
	return RK_SUCCESS;
}

static int calculate_md5(char *dst_buf, int size) {
	char src_buf[512] = {'\0'};
	char *ptr;
	FILE *fp = NULL;
	int i = 0;
	int status;

	fp = popen("md5sum " TEST_FILE_PATH, "r");
	if (fp == NULL) {
		printf("[%s()] popen failed because %s\n", __func__, strerror(errno));
		return RK_FAILURE;
	}

	while (fgets(src_buf, sizeof(src_buf), fp) != NULL) {
		// printf("[%s()] %s\n", __func__, src_buf);
		continue;
	}

	src_buf[sizeof(src_buf) - 1] = '\0';
	i = 0;
	while (i < sizeof(src_buf) && src_buf[i] != '\0' && src_buf[i] != ' ') {
		i++;
	}

	memset(dst_buf, 0, size);
	strncpy(dst_buf, src_buf, i);

	status = pclose(fp);
	if (!WIFEXITED(status))
		printf("[%s()] child process exit error! %s\n", __func__, strerror(errno));
	return RK_SUCCESS;
}

static int ai_vqe_init(RK_S32 s32SampleRate) {
	AI_VQE_CONFIG_S stAiVqeConfig, stAiVqeConfig2;
	RK_S32 ret;
	RK_S32 s32VqeGapMs = 16;
	int s32DevId = 0;
	int s32ChnId = 0;
	const char *pVqeCfgPath = "/oem/usr/share/vqefiles/config_aivqe.json";

	// Need to config enCfgMode to VQE attr even the VQE is not enabled
	memset(&stAiVqeConfig, 0, sizeof(AI_VQE_CONFIG_S));
	if (pVqeCfgPath != RK_NULL) {
		stAiVqeConfig.enCfgMode = AIO_VQE_CONFIG_LOAD_FILE;
		memcpy(stAiVqeConfig.aCfgFile, pVqeCfgPath, strlen(pVqeCfgPath));
	}

	if (s32VqeGapMs != 16 && s32VqeGapMs != 10) {
		RK_LOGE("Invalid gap: %d, just supports 16ms or 10ms for AI VQE", s32VqeGapMs);
		return RK_FAILURE;
	}

	stAiVqeConfig.s32WorkSampleRate = s32SampleRate;
	stAiVqeConfig.s32FrameSample = s32SampleRate * s32VqeGapMs / 1000;
	ret = RK_MPI_AI_SetVqeAttr(s32DevId, s32ChnId, 0, 0, &stAiVqeConfig);
	if (ret != RK_SUCCESS) {
		RK_LOGE("%s: SetVqeAttr(%d,%d) failed with %#x", __FUNCTION__, s32DevId, s32ChnId,
		        ret);
		return ret;
	}

	ret = RK_MPI_AI_GetVqeAttr(s32DevId, s32ChnId, &stAiVqeConfig2);
	if (ret != RK_SUCCESS) {
		RK_LOGE("%s: SetVqeAttr(%d,%d) failed with %#x", __FUNCTION__, s32DevId, s32ChnId,
		        ret);
		return ret;
	}

	ret = memcmp(&stAiVqeConfig, &stAiVqeConfig2, sizeof(AI_VQE_CONFIG_S));
	if (ret != RK_SUCCESS) {
		RK_LOGE("%s: set/get vqe config is different: %d", __FUNCTION__, ret);
		return ret;
	}

	ret = RK_MPI_AI_EnableVqe(s32DevId, s32ChnId);
	if (ret != RK_SUCCESS) {
		RK_LOGE("%s: EnableVqe(%d,%d) failed with %#x", __FUNCTION__, s32DevId, s32ChnId,
		        ret);
		return ret;
	}

	return RK_SUCCESS;
}

static int ai_chn_init(RK_S32 InputSampleRate, RK_S32 OutputSampleRate,
                       RK_S32 u32FrameCnt, RK_S32 vqeEnable) {
	AIO_ATTR_S aiAttr;
	AI_CHN_PARAM_S pstParams;
	RK_S32 ret;
	int s32DevId = 0;
	int s32ChnId = 0;
	memset(&aiAttr, 0, sizeof(AIO_ATTR_S));

	RK_BOOL needResample = (InputSampleRate != OutputSampleRate) ? RK_TRUE : RK_FALSE;

	RK_MPI_SYS_Init();
#ifdef RV1126_RV1109
	// 这是RV1126 声卡打开设置，RV1106设置无效，可以不设置
	ret = RK_MPI_AMIX_SetControl(s32DevId, "Capture MIC Path", (char *)"Main Mic");
	if (ret != RK_SUCCESS) {
		RK_LOGE("ai set Capture MIC Path fail, reason = %x", ret);
		goto __FAILED;
	}
#endif

	sprintf((char *)aiAttr.u8CardName, "%s", "hw:0,0");

	// s32DeviceSampleRate和s32SampleRate,s32SampleRate可以使用其他采样率，需要调用重采样函数。默认一样采样率。
	aiAttr.soundCard.channels = 2;
	aiAttr.soundCard.sampleRate = InputSampleRate;
	aiAttr.soundCard.bitWidth = AUDIO_BIT_WIDTH_16;
	aiAttr.enBitwidth = AUDIO_BIT_WIDTH_16;
	aiAttr.enSamplerate = (AUDIO_SAMPLE_RATE_E)OutputSampleRate;
	aiAttr.enSoundmode = AUDIO_SOUND_MODE_MONO;
	aiAttr.u32PtNumPerFrm = u32FrameCnt;
	// 以下参数无特殊需求，无需变动，保持默认值即可
	aiAttr.u32FrmNum = 4;
	aiAttr.u32EXFlag = 0;
	aiAttr.u32ChnCnt = 2;

	ret = RK_MPI_AI_SetPubAttr(s32DevId, &aiAttr);
	if (ret != RK_SUCCESS) {
		RK_LOGE("ai set attr fail, reason = %x", ret);
		goto __FAILED;
	}

	// 这是RV1106 回采设置，适用于左mic，右回采
	//  RV1126设置无效，可以不设置，RV1126需要配置asound.conf文件或者内核驱动配置软件回采
	ret =
	    RK_MPI_AMIX_SetControl(s32DevId, "I2STDM Digital Loopback Mode", (char *)"Mode2");
	if (ret != RK_SUCCESS) {
		RK_LOGE("ai set I2STDM Digital Loopback Mode fail, reason = %x", ret);
		goto __FAILED;
	}

	// 这是RV1106 ALC设置，而RV1126设置无效，可以不设置
	ret = RK_MPI_AMIX_SetControl(s32DevId, "ADC ALC Left Volume", (char *)"22");
	if (ret != RK_SUCCESS) {
		RK_LOGE("ai set alc left voulme fail, reason = %x", ret);
		goto __FAILED;
	}

	ret = RK_MPI_AMIX_SetControl(s32DevId, "ADC ALC Right Volume", (char *)"22");
	if (ret != RK_SUCCESS) {
		RK_LOGE("ai set alc right voulme fail, reason = %x", ret);
		goto __FAILED;
	}

	ret = RK_MPI_AI_Enable(s32DevId);
	if (ret != RK_SUCCESS) {
		RK_LOGE("ai enable fail, reason = %x", ret);
		goto __FAILED;
	}

	memset(&pstParams, 0, sizeof(AI_CHN_PARAM_S));
	pstParams.s32UsrFrmDepth = 4; // 0, get fail, 1 - u32ChnCnt, can get, if bind to other
	                              // device, must be < u32ChnCnt
	ret = RK_MPI_AI_SetChnParam(s32DevId, s32ChnId, &pstParams);
	if (ret != RK_SUCCESS) {
		RK_LOGE("ai set channel params, s32ChnId = %d", s32ChnId);
		return RK_FAILURE;
	}

	// 使用声音增强功能，默认开启
	if (vqeEnable) {
		ai_vqe_init(InputSampleRate);
	}

	ret = RK_MPI_AI_EnableChn(s32DevId, s32ChnId);
	if (ret != 0) {
		RK_LOGE("ai enable channel fail, s32ChnId = %d, reason = %x", s32ChnId, ret);
		return RK_FAILURE;
	}

	// 重采样功能
	if (needResample == RK_TRUE) {
		RK_LOGI("need to resample %d -> %d", InputSampleRate, OutputSampleRate);
		ret = RK_MPI_AI_EnableReSmp(s32DevId, s32ChnId,
		                            (AUDIO_SAMPLE_RATE_E)OutputSampleRate);
		if (ret != 0) {
			RK_LOGE("ai enable channel fail, reason = %x, s32ChnId = %d", ret, s32ChnId);
			return RK_FAILURE;
		}
	}

	RK_MPI_AI_SetVolume(s32DevId, 100);

	// 双声道，左声道为MIC拾⾳数据，右声道为播放的右声道的回采数据
	RK_MPI_AI_SetTrackMode(s32DevId, AUDIO_TRACK_NORMAL);

	return RK_SUCCESS;
__FAILED:
	return RK_FAILURE;
}

static int ao_chn_init(RK_S32 s32ReSmpSampleRate, RK_S32 s32SampleRate,
                       RK_S32 u32FrameCnt) {
	RK_S32 ret = 0;
	AUDIO_DEV s32DevId = 0;
	AO_CHN s32ChnId = 0;
	AIO_ATTR_S aoAttr;
	AO_CHN_PARAM_S pstParams;
	RK_S32 s32SetVolume = 100;

	memset(&pstParams, 0, sizeof(AO_CHN_PARAM_S));
	memset(&aoAttr, 0, sizeof(AIO_ATTR_S));
#ifdef RV1126_RV1109
	/*==============================================================================*/
	// 这是RV1126 声卡打开设置，RV1106设置无效，可以不设置
	ret = RK_MPI_AMIX_SetControl(s32DevId, "Playback Path", (char *)"SPK");
	if (ret != RK_SUCCESS) {
		RK_LOGE("ao set Playback Path fail, reason = %x", ret);
		return RK_FAILURE;
	}
#endif
	sprintf((char *)aoAttr.u8CardName, "%s", "hw:0,0");

	aoAttr.soundCard.channels = 2;               // 2
	aoAttr.soundCard.sampleRate = s32SampleRate; // s32SampleRate;       16000
	aoAttr.soundCard.bitWidth = AUDIO_BIT_WIDTH_16;

	aoAttr.enBitwidth = AUDIO_BIT_WIDTH_16;                   // AUDIO_BIT_WIDTH_16
	aoAttr.enSamplerate = (AUDIO_SAMPLE_RATE_E)s32SampleRate; // 16000

	aoAttr.enSoundmode = AUDIO_SOUND_MODE_MONO;
	aoAttr.u32PtNumPerFrm = u32FrameCnt; // 1024
	// 以下参数没有特殊需要，无需修改
	aoAttr.u32FrmNum = 4;
	aoAttr.u32EXFlag = 0;
	aoAttr.u32ChnCnt = 2;

	RK_MPI_AO_SetPubAttr(s32DevId, &aoAttr);
	RK_MPI_AO_Enable(s32DevId);
	/*==============================================================================*/
	pstParams.enLoopbackMode = AUDIO_LOOPBACK_NONE;
	ret = RK_MPI_AO_SetChnParams(s32DevId, s32ChnId, &pstParams);
	if (ret != RK_SUCCESS) {
		RK_LOGE("ao set channel params, s32ChnId = %d", s32ChnId);
		return RK_FAILURE;
	}
	/*==============================================================================*/
	ret = RK_MPI_AO_EnableChn(s32DevId, s32ChnId);
	if (ret != 0) {
		RK_LOGE("ao enable channel fail, s32ChnId = %d, reason = %x", s32ChnId, ret);
		return RK_FAILURE;
	}
	/*==============================================================================*/
	// set sample rate of input data
	printf("********RK_MPI_AO_EnableReSmp*********\n");
	ret = RK_MPI_AO_EnableReSmp(s32DevId, s32ChnId,
	                            (AUDIO_SAMPLE_RATE_E)s32ReSmpSampleRate);
	if (ret != 0) {
		RK_LOGE("ao enable channel fail, reason = %x, s32ChnId = %d", ret, s32ChnId);
		return RK_FAILURE;
	}

	RK_MPI_AO_SetVolume(s32DevId, s32SetVolume);

	RK_MPI_AO_SetTrackMode(s32DevId, AUDIO_TRACK_OUT_STEREO);

	return RK_SUCCESS;
}

static int ao_chn_deinit() {
	RK_S32 ret = 0;
	AUDIO_DEV s32DevId = 0;
	AO_CHN s32ChnId = 0;

	RK_MPI_AO_DisableReSmp(s32DevId, s32ChnId);
	RK_MPI_AO_DisableChn(s32DevId, s32ChnId);
	RK_MPI_AO_Disable(s32DevId);

	return RK_SUCCESS;
}

static int ai_chn_deinit(RK_S32 vqeEnable) {
	RK_S32 ret;
	int s32DevId = 0;
	int s32ChnId = 0;

	if (vqeEnable) {
		RK_MPI_AI_DisableVqe(s32DevId, s32ChnId);

		// 这是RV1106 回采设置关闭，而RV1126设置无效，可以不配置
		ret =
		    RK_MPI_AMIX_SetControl(0, "I2STDM Digital Loopback Mode", (char *)"Disabled");
		if (ret != RK_SUCCESS)
			RK_LOGE("ai set I2STDM Digital Loopback Mode fail, reason = %x", ret);
	}

	RK_MPI_AI_DisableChn(s32DevId, s32ChnId);
	RK_MPI_AI_Disable(s32DevId);
	RK_MPI_SYS_Exit();
}

static int test_ai_ao_pipe() {
	int i = 0;
	RK_S32 s32MilliSec = 1000;
	AUDIO_FRAME_S frame;
	RK_S32 ret = RK_SUCCESS;
	FILE *save_file = NULL;
	char save_path[256] = {'\0'};
	if (output_path) {
		snprintf(save_path, 256, "%s/ai.pcm", output_path);
		save_file = fopen(save_path, "w");
		if (!save_file) {
			RK_LOGE("open ret file failed: %s", strerror(errno));
			return RK_FAILURE;
		}
	}
	for (int i = 0; i < 100; ++i) {
		ret = RK_MPI_AI_GetFrame(0, 0, &frame, RK_NULL, s32MilliSec);
		if (ret == RK_SUCCESS) {
			RK_LOGD("RK_MPI_AI_GetFrame %d success", i);
			if (save_file) {
				void *data = RK_MPI_MB_Handle2VirAddr(frame.pMbBlk);
				RK_U32 len = frame.u32Len;
				RK_LOGD("data = %p, len = %d", data, len);
				fwrite(data, len, 1, save_file);
				fflush(save_file);
			}
			ret = RK_MPI_AO_SendFrame(0, 0, &frame, s32MilliSec);
			if (ret != RK_SUCCESS) {
				RK_LOGE("RK_MPI_AO_SendFrame failed %#X", ret);
				RK_MPI_AI_ReleaseFrame(0, 0, &frame, RK_NULL);
				break;
			} else {
				RK_LOGD("RK_MPI_AO_SendFrame %d success", i);
			}

			RK_MPI_AI_ReleaseFrame(0, 0, &frame, RK_NULL);
		} else {
			RK_LOGE("RK_MPI_AI_GetFrame failed %#X", ret);
			break;
		}
	}
	if (save_file) {
		fflush(save_file);
		fclose(save_file);
	}
	return ret;
}

int main(int argc, char *argv[]) {
	int ret = RK_SUCCESS;
	int fd = -1;
	int loop_count = 1;
	int c;
	int i = 0;
	bool enable_sdcard = false;
	bool enable_ethernet = false;
	bool enable_audio = false;
	char old_buf[256] = {'\0'}, new_buf[256] = {'\0'};
	if (argc < 2) {
		print_usage(argv[0]);
		return RK_FAILURE;
	}
	while ((c = getopt_long(argc, argv, optstr, long_options, NULL)) != -1) {
		switch (c) {
		case 'l':
			loop_count = atoi(optarg);
			break;
		case 'e':
			enable_ethernet = atoi(optarg);
			break;
		case 's':
			enable_sdcard = atoi(optarg);
			break;
		case 'a':
			enable_audio = atoi(optarg);
			break;
		case 'o':
			output_path = optarg;
			break;
		case '?':
			print_usage(argv[0]);
		default:
			return RK_FAILURE;
		}
	}
	if (enable_sdcard) {
		SAMPLE_COMM_AOV_BindSdcard();
		mount_sdcard();
	}
	if (enable_ethernet)
		SAMPLE_COMM_AOV_BindEthernet();
	if (enable_audio) {
		// FIXME:
		// Just for rv1106 test now.
		system("insmod /oem/usr/ko/snd-soc-rockchip-i2s-tdm.ko");
		system("insmod /oem/usr/ko/snd-soc-rv1106.ko");
		system("insmod /oem/usr/ko/snd-soc-simple-card-utils.ko");
		system("insmod /oem/usr/ko/snd-soc-simple-card.ko");
		SAMPLE_COMM_AOV_BindSoundcard();
	}

	SAMPLE_COMM_AOV_SetSuspendTime(100);

	printf("[%s()] -------------- Test Start! --------------\n", __func__);
	for (int i = 0; i < loop_count; ++i) {
		if (enable_sdcard) {
			ret = create_test_file();
			if (ret != RK_SUCCESS) {
				printf("[%s()] create test file failed!", __func__);
				break;
			}
			calculate_md5(old_buf, sizeof(old_buf));

			unmount_sdcard();
			ret = SAMPLE_COMM_AOV_UnbindSdcard();
			if (ret != RK_SUCCESS) {
				printf("[%s()] unbind sdcard failed! please check sdcard is exist\n",
				       __func__);
				break;
			}
		}
		if (enable_ethernet) {
			ret = SAMPLE_COMM_AOV_UnbindEthernet();
			if (ret != RK_SUCCESS) {
				printf("[%s()] unbind eternet failed! please check sdcard is exist\n",
				       __func__);
				break;
			}
		}
		if (enable_audio) {
			ret = SAMPLE_COMM_AOV_UnbindSoundcard();
			if (ret != RK_SUCCESS) {
				printf("[%s()] unbind sound card failed!\n", __func__);
				break;
			}
		}

		SAMPLE_COMM_AOV_EnterSleep();

		if (enable_audio) {
			ret = SAMPLE_COMM_AOV_BindSoundcard();
			if (ret != RK_SUCCESS) {
				printf("[%s()] bind sound card failed!\n", __func__);
				break;
			}
			ret = ai_chn_init(16000, 16000, 1024, 1);
			if (ret != RK_SUCCESS) {
				printf("[%s()] init ai failed %#X\n", __func__, ret);
				break;
			}
			ret = ao_chn_init(16000, 16000, 1024);
			if (ret != RK_SUCCESS) {
				printf("[%s()] init ao failed %#X\n", __func__, ret);
				break;
			}
			ret = test_ai_ao_pipe();
			if (ret != RK_SUCCESS) {
				printf("[%s()] test ai ao failed!\n", __func__);
				break;
			}
			ao_chn_deinit();
			ai_chn_deinit(1);
		}
		if (enable_ethernet) {
			ret = SAMPLE_COMM_AOV_BindEthernet();
			if (ret != RK_SUCCESS) {
				printf("[%s()] bind ethernet failed! please check sdcard is exist\n",
				       __func__);
				break;
			}
		}
		if (enable_sdcard) {
			ret = SAMPLE_COMM_AOV_BindSdcard();
			if (ret != RK_SUCCESS) {
				printf("[%s()] bind sdcard failed! please check sdcard is exist\n",
				       __func__);
				break;
			}
			ret = mount_sdcard();
			if (ret != RK_SUCCESS) {
				printf("[%s()] mount sdcard failed!", __func__);
				break;
			}
			calculate_md5(new_buf, sizeof(new_buf));
			printf("[%s()] pre md5 %s\n", __func__, old_buf);
			printf("[%s()] new md5 %s\n", __func__, new_buf);
			if (strncmp(new_buf, old_buf, sizeof(new_buf)) != 0) {
				printf("[%s()] test failed, test file is broken\n", __func__);
				ret = RK_FAILURE;
				break;
			}
		}
		printf("[%s()] -------------- Success count %d --------------\n", __func__, i);
	}
	if (ret == RK_SUCCESS)
		printf("[%s()] -------------- Test Success! --------------\n", __func__);
	else
		printf("[%s()] -------------- Test Failed! --------------\n", __func__);

	printf("[%s()] -------------- Test End! --------------\n", __func__);

	return ret;
}