#include "precompile.h"
#include <time.h>
#include "sp_dir.h"
#include "sp_def.h"
#include "shm_mem.h"
#include "fileutil.h"

int sp_dir_create(sp_dir_t **p_dir)
{
	sp_dir_t *dir;
	int rc = Error_Unexpect;
	char tmp[MAX_PATH];
	char ver[SP_MAX_VER_LEN];
	dir = shm_malloc(sizeof(sp_dir_t));
	memset(dir, 0, sizeof(sp_dir_t));

	
	GetModuleFileNameA(NULL, tmp, MAX_PATH);
	*strrchr(tmp, SPLIT_SLASH) = 0;
	//C:/Run/version/1.2.3.4/bin
	dir->bin_path = shm_strdup(tmp);
	*strrchr(tmp, SPLIT_SLASH) = 0;
	//C:/Run/version/1.2.3.4
	dir->base_path = shm_strdup(tmp);
	*strrchr(tmp, SPLIT_SLASH) = 0;
	//C:/Run/version
	// 
	//TODO(Gifur): duplicate path value set, which would makd memory leak
	dir->root_ver_path = shm_strdup(tmp);
	*strrchr(tmp, SPLIT_SLASH) = 0;
	//C:/Run
	dir->root_path = shm_strdup(tmp);
	*strrchr(tmp, SPLIT_SLASH) = 0;
	//C:
	dir->rvc_path = shm_strdup_printf("%s" SPLIT_SLASH_STR "rvc", tmp);

	//TODO: duplicate
	dir->root_ver_path = shm_strdup_printf("%s" SPLIT_SLASH_STR "version", dir->root_path);
	dir->root_hardwarecfg_path = shm_strdup_printf("%s" SPLIT_SLASH_STR "hardwarecfg", dir->root_path);
	dir->root_runinfo_path = shm_strdup_printf("%s" SPLIT_SLASH_STR "runinfo", dir->root_path);

	dir->dep_path = shm_strdup_printf("%s" SPLIT_SLASH_STR "dep", dir->base_path);
	dir->cfg_path = shm_strdup_printf("%s" SPLIT_SLASH_STR "cfg", dir->base_path);
	dir->mod_path = shm_strdup_printf("%s" SPLIT_SLASH_STR "mod", dir->base_path);
	dir->obj_path = shm_strdup_printf("%s" SPLIT_SLASH_STR "obj", dir->base_path);

	dir->dbg_path = shm_strdup_printf("%s" SPLIT_SLASH_STR "dbg", dir->rvc_path);
	dir->slv_path = shm_strdup_printf("%s" SPLIT_SLASH_STR "slv", dir->rvc_path);
	dir->dmp_path = shm_strdup_printf("%s" SPLIT_SLASH_STR "dmp", dir->rvc_path);
	dir->ad0_path = shm_strdup_printf("%s" SPLIT_SLASH_STR "ad0", dir->rvc_path);


	if(!ExistsDirA(dir->root_hardwarecfg_path))
		CreateDirRecursiveA(dir->root_hardwarecfg_path);

	if (!ExistsDirA(dir->rvc_path)) {
		CreateDirRecursiveA(dir->rvc_path);
	}
	if (!ExistsDirA(dir->dmp_path)) {
		CreateDirRecursiveA(dir->dmp_path);
	}
	if (!ExistsDirA(dir->dbg_path)) {
		CreateDirRecursiveA(dir->dbg_path);
	}
	if (!ExistsDirA(dir->slv_path)) {
		CreateDirRecursiveA(dir->slv_path);
	}

	memset(tmp, 0, sizeof(tmp));
	sprintf(tmp, "%s" SPLIT_SLASH_STR "runcfg", dir->root_runinfo_path);
	if (!ExistsDirA(tmp))
		CreateDirRecursiveA(tmp);

	dir->dep_base_path = shm_strdup_printf("%s" SPLIT_SLASH_STR "dep", dir->root_path);
	if (!ExistsDirA(dir->dep_base_path)) {
		CreateDirRecursiveA(dir->dep_base_path);
	}
	memset(tmp, 0, sizeof(tmp));
	sprintf(tmp, "%s" SPLIT_SLASH_STR ADAPTER_VERSION_FILE_NAME, dir->dep_base_path);

	memset(ver, 0, sizeof(ver));
	if (sp_dir_inner_get_content(tmp, ver) == 0) {
		dir->dep_ver_path = shm_strdup_printf("%s" SPLIT_SLASH_STR "%s", dir->dep_base_path, ver);
	}
	else {
		//TODO:   [Gifur@20241014]
		dir->dep_ver_path = NULL;
	}

	*p_dir = dir;
	rc = 0;

	return rc;	
}

void sp_dir_destroy(sp_dir_t* dir)
{
	if (dir) {
		if (dir->base_path)
			shm_free(dir->base_path);
		if (dir->rvc_path)
			shm_free(dir->rvc_path);
		if (dir->bin_path)
			shm_free(dir->bin_path);
		if (dir->dep_path)
			shm_free(dir->dep_path);
		if (dir->cfg_path)
			shm_free(dir->cfg_path);
		if (dir->mod_path)
			shm_free(dir->mod_path);
		if (dir->obj_path)
			shm_free(dir->obj_path);
		if (dir->dbg_path)
			shm_free(dir->dbg_path);
		if (dir->slv_path)
			shm_free(dir->slv_path);
		if (dir->dmp_path)
			shm_free(dir->dmp_path);
		if (dir->root_path)
			shm_free(dir->root_path);
		if (dir->root_hardwarecfg_path)
			shm_free(dir->root_hardwarecfg_path);
		if (dir->root_runinfo_path)
			shm_free(dir->root_runinfo_path);
		if (dir->root_ver_path)
			shm_free(dir->root_ver_path);
		if (dir->dep_base_path)
			shm_free(dir->dep_base_path);
		if (dir->dep_ver_path)
			shm_free(dir->dep_ver_path);
		shm_free(dir);
	}
}

static int __dir_get_path(char *base_dir, int flag, const char *cat_name, char *buf, int len, const char *site, int mode)
{
	int rc = 0;
	int needed = strlen(base_dir);

	if (flag == SP_DIR_ENTITY_INI) {
		needed += strlen(cat_name) + 6;
	} else if (flag == SP_DIR_SHELL_INI) {
		needed += 11;
	} else if (flag == SP_DIR_SHELLVAR_INI) {
		needed += 22;
	} else if (flag == SP_DIR_MODULE_BIN) {
		needed += strlen(cat_name) + 6;
	} else if (flag == SP_DIR_ROOT_INI) {
		needed += strlen("root.ini") + 10;
	} else if (flag == SP_DIR_DEVICE_ENTITY_INI) {
		needed += strlen(cat_name) + 6;
	} else if (flag == SP_DIR_RUNINFO_INI) {
		needed += strlen(cat_name) + 6 + 7;
    } else if (flag == SP_DIR_RUNINFO_GLOBAL_INI) {
        needed += strlen("Global.ini") + 2;
    } else if (flag == SP_DIR_RUNINFO_BOOT_LOG) {
		needed += strlen(cat_name) + 6 + 8;
	} else if (flag == SP_DIR_INSTALL_INI) {
		needed += 13;
	} else if (flag == SP_DIR_EXPLORER_INI) {
		needed += 16;
	}	else if (flag == SP_DIR_CENTER_SETTING_INI){
		needed += 18;
	} else if (flag == SP_DIR_ENTITY_DBG_LOG) {
		needed += strlen(cat_name) + 2 + 4 + 8;
	}
	else if (flag == SP_DIR_ENV_INI) {
		needed += strlen("env.ini") + 10;
	}
	else if (flag == SP_DIR_DEPVER_TXT) {
		needed += 12;
	}
	else {
		rc = Error_Param;
	}
	if (buf) {
		if (len && len < needed)
			return Error_TooSmallBuffer;
	} else {
		return needed;
	}

	if (flag == SP_DIR_ENTITY_INI || flag == SP_DIR_DEVICE_ENTITY_INI) 
	{
		strcpy(buf, base_dir);
		strcat(buf, SPLIT_SLASH_STR);
		strcat(buf, cat_name);
		strcat(buf, ".ini");
	}
	else if (flag == SP_DIR_RUNINFO_INI)
	{
		strcpy(buf, base_dir);
		strcat(buf, SPLIT_SLASH_STR "runcfg" SPLIT_SLASH_STR);
		strcat(buf, cat_name);
		strcat(buf, ".ini");
	}
	else if (flag == SP_DIR_RUNINFO_GLOBAL_INI) {
        strcpy(buf, base_dir);
        strcat(buf, SPLIT_SLASH_STR "Global.ini");
	}
	else if (flag == SP_DIR_RUNINFO_BOOT_LOG) {
		strcpy(buf, base_dir);
		strcat(buf, SPLIT_SLASH_STR "bootrec" SPLIT_SLASH_STR);
		strcat(buf, cat_name);
		strcat(buf, ".log");
	} else if (flag == SP_DIR_ENTITY_DBG_LOG ) {
		time_t timep;
		struct tm *p;
		char td[128] = { 0 };
		time(&timep);
		p = gmtime(&timep);
		sprintf(td, "%04d%02d%02d.log", 1900+p->tm_year, p->tm_mon+1, p->tm_mday);
		strcpy(buf, base_dir);
		strcat(buf, SPLIT_SLASH_STR);
		strcat(buf, cat_name);
		strcat(buf, SPLIT_SLASH_STR);
		strcat(buf, td);
	}
	else if (flag == SP_DIR_SHELLVAR_INI){
		strcpy(buf, base_dir);
		strcat(buf, SPLIT_SLASH_STR "runcfg" SPLIT_SLASH_STR "shellVar.ini");
	}else if (flag == SP_DIR_SHELL_INI) {
		strcpy(buf, base_dir);
		strcat(buf, SPLIT_SLASH_STR "shell.ini");
	}
	else if (flag == SP_DIR_ENV_INI) {
		strcpy(buf, base_dir);
		strcat(buf, SPLIT_SLASH_STR "env.ini");
	}	
	else if (flag == SP_DIR_MODULE_BIN) {
		strcpy(buf, base_dir);
		strcat(buf, SPLIT_SLASH_STR);
#if defined(RVC_OS_WIN)
		strcat(buf, cat_name);
		strcat(buf, ".dll");
#else
		strcat(buf, "lib");
		strcat(buf, cat_name);
		strcat(buf, ".so");
#endif //RVC_OS_WIN

	} else if (flag == SP_DIR_ROOT_INI) {
		strcpy(buf, base_dir);
		if(mode == 1) strcat(buf, SPLIT_SLASH_STR "root-ST.ini");
		else if(mode == 2) strcat(buf, SPLIT_SLASH_STR "root-UAT.ini");
		else strcat(buf, SPLIT_SLASH_STR "root.ini");
	} else if (flag == SP_DIR_INSTALL_INI) {
		strcpy(buf, base_dir);
		strcat(buf, SPLIT_SLASH_STR "install.ini");
	}
	else if (flag == SP_DIR_CENTER_SETTING_INI)
	{
        strcpy(buf, base_dir);
		strcat(buf, SPLIT_SLASH_STR  "CenterSetting.ini");
	}
	else if (flag == SP_DIR_DEPVER_TXT) {
		strcpy(buf, base_dir);
		strcat(buf, SPLIT_SLASH_STR  ADAPTER_VERSION_FILE_NAME);
	}
	else {
		rc = (int)Error_Param;
	}
	return rc;
}

int sp_dir_get_path(sp_dir_t* dir, int flag, const char *cat_name, char *buf, int len)
{
	return sp_dir_get_path_new(dir, flag, cat_name, buf, len, 0);
}

int sp_dir_get_path_new(sp_dir_t* dir, int flag, const char *cat_name, char *buf, int len, int mode)
{
    char* base_path = NULL;

	switch (flag)
	{
	case SP_DIR_ROOT_INI:
	case SP_DIR_DEVICE_ENTITY_INI:
		base_path = dir->root_hardwarecfg_path;
		break;
	case SP_DIR_SHELL_INI:
	case SP_DIR_ENTITY_INI:
	case SP_DIR_CENTER_SETTING_INI:
	case SP_DIR_ENV_INI:
		base_path = dir->cfg_path;
		break;
	case SP_DIR_MODULE_BIN:
		base_path = dir->mod_path;
		break;
	case SP_DIR_RUNINFO_INI:
	case SP_DIR_SHELLVAR_INI:
	case SP_DIR_RUNINFO_GLOBAL_INI:
	case SP_DIR_RUNINFO_BOOT_LOG:
		base_path = dir->root_runinfo_path;
		break;
	case SP_DIR_INSTALL_INI:
		base_path = dir->base_path;
		break;
	case SP_DIR_EXPLORER_INI:
		base_path = dir->root_path;
		break;
	case SP_DIR_ENTITY_DBG_LOG:
		base_path = dir->dbg_path;
		break;
	case SP_DIR_DEPVER_TXT:
		base_path = dir->dep_base_path;
		break;
	default:
		return Error_Param;
	}
    return __dir_get_path(base_path, flag, cat_name, buf, len, NULL, mode);
}

int sp_dir_get_path_version(sp_dir_t* dir, int major, int minor, int revision, int build, int flag, const char *cat_name, char *buf, int len, int mode)
{
	char tmp[MAX_PATH];
	char *base_path = NULL;
	
	if (flag == SP_DIR_ROOT_INI || flag == SP_DIR_DEVICE_ENTITY_INI) {
		base_path = dir->root_hardwarecfg_path;
	} else if (flag == SP_DIR_RUNINFO_INI || flag == SP_DIR_RUNINFO_BOOT_LOG) {
		base_path = dir->root_runinfo_path;
	} else if (flag == SP_DIR_SHELL_INI || flag == SP_DIR_ENTITY_INI) {
		sprintf(tmp, "%s" SPLIT_SLASH_STR "%d.%d.%d.%d" SPLIT_SLASH_STR "cfg", dir->root_ver_path, major, minor, revision, build);
		base_path = tmp;
	} else if (flag == SP_DIR_MODULE_BIN) {
		sprintf(tmp, "%s" SPLIT_SLASH_STR "%d.%d.%d.%d" SPLIT_SLASH_STR "mod", dir->root_ver_path, major, minor, revision, build);
		base_path = tmp;
	} else if (flag == SP_DIR_INSTALL_INI) {
		sprintf(tmp, "%s" SPLIT_SLASH_STR "%d.%d.%d.%d", dir->root_ver_path, major, minor, revision, build);
		base_path = tmp;
	} else {
		return Error_Param;
	}
	return __dir_get_path(base_path, flag, cat_name, buf, len, NULL, mode);
}

void sp_dir_get_cur_drive(char* path)
{
	char drive[_MAX_DRIVE] = {'\0'};
	char dir[_MAX_DIR] = { '\0' };
	char fname[_MAX_FNAME] = { '\0' };
	char ext[_MAX_EXT] = { '\0' };
	char chpath[MAX_PATH] = { '\0' };
	GetModuleFileNameA(NULL, (LPSTR)chpath, sizeof(chpath));
	_splitpath(chpath, drive, dir, fname, ext);
	memcpy(path, drive, sizeof(drive));
}

int sp_dir_inner_get_content(const char* file, char* ver)
{
	FILE* pFile = NULL;
	if (!ExistsFileA(file)) {
		return Error_NotExist;
	}
	pFile = fopen(file, "rb+");
	if (pFile != NULL)
	{
		char szTemp[256];
		int i, n;
		memset(szTemp, 0, sizeof(szTemp));
		n = fread(szTemp, 1, 256, pFile);
		fclose(pFile);
		memset(ver, 0, SP_MAX_VER_LEN);
		strncpy(ver, szTemp, SP_MAX_VER_LEN);
		if (strlen(ver) == 0) {
			return Error_Null;
		}
	}
	else
	{
		return Error_IO;
	}
	return 0;
}

SPBASE_API int sp_dir_refresh_dep_path(sp_dir_t* dir)
{
	char tmp[MAX_PATH];
	char ver[SP_MAX_VER_LEN];
	int result = 0;
	if (dir && dir->dep_base_path != NULL && strlen(dir->dep_base_path) > 0) {
		memset(tmp, 0, sizeof(tmp));
		sprintf(tmp, "%s" SPLIT_SLASH_STR ADAPTER_VERSION_FILE_NAME, dir->dep_base_path);
		result = sp_dir_inner_get_content(tmp, ver);
		if (result == 0) {
			if (dir->dep_ver_path != NULL) {
				shm_free(dir->dep_ver_path);
			}
			dir->dep_ver_path = shm_strdup_printf("%s" SPLIT_SLASH_STR "%s", dir->dep_base_path, ver);
		}
		return result;
	}
	return Error_InvalidState;
}