#include <ctype.h>
#include <errno.h>
#include <fcntl.h>
#include <getopt.h>
#include <limits.h>
#include <linux/input.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <time.h>
#include <unistd.h>
#include <dirent.h>
#include <inttypes.h>
#include <errno.h>


#include "minui/minui.h"
#include "common.h"
#include "minzip/DirUtil.h"
#include "recovery_ui.h"

#include "script.h"
#include "test_case.h"
#include "script_parser.h"
#include "debug.h"

#include "Language/language.h"


#include "rtc_test.h"
#include "wlan_test.h"
#include "ddr_test.h"
#include "bt_test.h"
#include "sdcard_test.h"
#include "udisk_test.h"
#include "key_test.h"
#include "screen_test.h"
#include "emmc_test.h"
#include "audio_play_test.h"
#include "audio_record_test.h"

#define SCRIPT_NAME                     "/data/test_config.cfg"

int manual_p_y = 1;
/* current position for auto test tiem in y direction */
int cur_p_y;

pthread_t rtc_tid;
char *rtc_res;
char dt[30] = { "20120927.143045" };
struct rtc_msg *rtc_msg;
int err_rtc;
int rtc_p_y;

pthread_t screen_tid;
pthread_t wlan_tid;
pthread_t bt_tid;
pthread_t sd_tid;
pthread_t udisk_tid;
pthread_t ddr_tid;
pthread_t emmc_tid;
pthread_t led_tid;
pthread_t key_tid;

pthread_t audioplay_tid;
pthread_t audiorecord_tid;

static int total_testcases;
static struct testcase_base_info *base_info;
static struct list_head auto_test_list_head;
static struct list_head manual_test_list_head;


static pthread_mutex_t gCur_p_y = PTHREAD_MUTEX_INITIALIZER;

int get_cur_print_y(void)
{
	int tmp;

	pthread_mutex_lock(&gCur_p_y);
	/*if (gr_fb_height() > 1080)
		cur_p_y--;
	tmp = cur_p_y--;*/
	tmp = cur_p_y++;

	pthread_mutex_unlock(&gCur_p_y);
	printf("cur_print_y:%d\n", tmp);
	return tmp;
}

static int parse_testcase(void)
{
	int i, j, mainkey_cnt;
	struct testcase_base_info *info;
	char mainkey_name[32], display_name[64], binary[16];
	int activated, category, run_type, sim_counts;
	int len;

	mainkey_cnt = script_mainkey_cnt();
	info = (struct testcase_base_info *)
	    malloc(sizeof(struct testcase_base_info) * mainkey_cnt);
	if (info == NULL) {
		db_error("core: allocate memory for temporary test case basic "
			 "information failed(%s)\n", strerror(errno));
		return -1;
	}
	memset(info, 0, sizeof(struct testcase_base_info) * mainkey_cnt);

	for (i = 0, j = 0; i < mainkey_cnt; i++) {
		struct testcase_info *tc_info;

		memset(mainkey_name, 0, 32);
		script_mainkey_name(i, mainkey_name);

		if (script_fetch
		    (mainkey_name, "display_name", (int *)display_name, 16))
			continue;

		if (script_fetch(mainkey_name, "activated", &activated, 1))
			continue;

		if (display_name[0] && activated == 1) {
			strncpy(info[j].name, mainkey_name, 32);
			strncpy(info[j].display_name, display_name, 64);
			info[j].activated = activated;

			if (script_fetch
			    (mainkey_name, "program", (int *)binary, 4) == 0) {
				strncpy(info[j].binary, binary, 16);
			}

			info[j].id = j;

			if (script_fetch(mainkey_name, "category", &category, 1)
			    == 0) {
				info[j].category = category;
			}

			if (script_fetch(mainkey_name, "run_type", &run_type, 1)
			    == 0) {
				info[j].run_type = run_type;
			}

            /*
			if (script_fetch
			    (mainkey_name, "sim_counts", &sim_counts, 1) == 0) {
				simCounts = sim_counts;
			}
			*/

			tc_info = (struct testcase_info *)
			    malloc(sizeof(struct testcase_info));
			if (tc_info == NULL) {
				printf("malloc for tc_info[%d] fail\n", j);
				return -1;
			}
			tc_info->x = 0;
			tc_info->y = 0;
			tc_info->base_info = &info[j];
			if (tc_info->base_info->category)   //manual test
				list_add(&tc_info->list, &manual_test_list_head);
			else    //auto test
				list_add(&tc_info->list, &auto_test_list_head);
			j++;
		}
	}
	total_testcases = j;

	db_msg("core: total test cases #%d\n", total_testcases);
	if (total_testcases == 0)
		return 0;

	len = sizeof(struct testcase_base_info) * total_testcases;

	return total_testcases;
}

int start_test_pthread(struct testcase_info *tc_info)
{
	int err;
	printf(">>> Currnet test is : [ %s ]\n", tc_info->base_info->name);

#if 1
    if (!strcmp(tc_info->base_info->name, "rtc")) {
		err = pthread_create(&rtc_tid, NULL, rtc_test, tc_info);
		if (err != 0) {
			printf("create screen test thread error: %s/n",
			       strerror(err));
			return -1;
		}
	} if (!strcmp(tc_info->base_info->name, "Lcd")) {
		err = pthread_create(&screen_tid, NULL, screen_test, tc_info);
		if (err != 0) {
			printf("create screen test thread error: %s/n",
			       strerror(err));
			return -1;
		}
	} else if (!strcmp(tc_info->base_info->name, "wifi")) {
        err = pthread_create(&wlan_tid, NULL, wlan_test, tc_info);
        if (err != 0) {
            printf("create screen test thread error: %s/n",
                   strerror(err));
            return -1;
        }
	} else if (!strcmp(tc_info->base_info->name, "ddr")) {
        err = pthread_create(&ddr_tid, NULL, ddr_test, tc_info);
        if (err != 0) {
            printf("create screen test thread error: %s/n",
                   strerror(err));
            return -1;
        }
	}else if (!strcmp(tc_info->base_info->name, "bluetooth")) {
        err = pthread_create(&bt_tid, NULL, bt_test, tc_info);
        if (err != 0) {
            printf("create screen test thread error: %s/n",
                   strerror(err));
            return -1;
        }
	} else if (!strcmp(tc_info->base_info->name, "sdcard")) {
		err = pthread_create(&sd_tid, NULL, sdcard_test, tc_info);
		if (err != 0) {
			printf("create sdcard test thread error: %s/n",
			       strerror(err));
			return -1;
		}
	} else if (!strcmp(tc_info->base_info->name, "emmc")) {
		err = pthread_create(&emmc_tid, NULL, emmc_test, tc_info);
		if (err != 0) {
			printf("create sdcard test thread error: %s/n",
			       strerror(err));
			return -1;
		}
	} else if (!strcmp(tc_info->base_info->name, "udisk")) {
		err = pthread_create(&udisk_tid, NULL, udisk_test, tc_info);
		if (err != 0) {
			printf("create usb host test thread error: %s/n",
			       strerror(err));
			return -1;
		}
	} else if (!strcmp(tc_info->base_info->name, "play")) {
		err = pthread_create(&audioplay_tid, NULL, audio_play_test, tc_info);
		if (err != 0) {
			printf("create audio play test thread error: %s/n",
			       strerror(err));
			return -1;
		}
	} else if (!strcmp(tc_info->base_info->name, "record")) {
		err = pthread_create(&audiorecord_tid, NULL, audio_record_test, tc_info);
		if (err != 0) {
			printf("create audio record test thread error: %s/n",
			       strerror(err));
			return -1;
		}
	} else if (!strcmp(tc_info->base_info->name, "Key")) {
		err = pthread_create(&key_tid, NULL, key_test, tc_info);
		if (err != 0) {
			printf("create key test thread error: %s/n",
			       strerror(err));
			return -1;
		}
	} else {
		printf(">>> unsupport test item: [ %s ] for now!\n", tc_info->base_info->name);
		return -1;
	}
#endif


#if 0

	if (!strcmp(tc_info->base_info->name, "Lcd")) {
		err = pthread_create(&screen_tid, NULL, screen_test, tc_info);
		if (err != 0) {
			printf("create screen test thread error: %s/n",
			       strerror(err));
			return -1;
		}
	} else if (!strcmp(tc_info->base_info->name, "rtc")) {
		err = pthread_create(&rtc_tid, NULL, rtc_test, tc_info);
		if (err != 0) {
			printf("create rtc test thread error: %s/n",
			       strerror(err));
			return -1;
		}
	} else if (!strcmp(tc_info->base_info->name, "battery")) {
		err = pthread_create(&battery_tid, NULL, battery_test, tc_info);
		if (err != 0) {
			printf("create battery_test test thread error: %s/n",
			       strerror(err));
			return -1;
		}
	} else if (!strcmp(tc_info->base_info->name, "ddr_emmc")) {
		err = pthread_create(&ddr_emmc_tid, NULL,
			ddr_emmc_test, tc_info);
		if (err != 0) {
			printf("create ddr_emmc test  thread error: %s/n",
				   strerror(err));
			return -1;
		}
	} else if (!strcmp(tc_info->base_info->name, "Codec")) {
		hasCodec = 1;
		err = pthread_create(&codec_tid, NULL, codec_test, tc_info);
		if (err != 0) {
			printf("create codec test thread error: %s/n",
			       strerror(err));
			return -1;
		}
	} else if (!strcmp(tc_info->base_info->name, "Key")) {
		err = pthread_create(&key_tid, NULL, key_test, tc_info);
		if (err != 0) {
			printf("create key test thread error: %s/n",
			       strerror(err));
			return -1;
		}
	} else if (!strcmp(tc_info->base_info->name, "fm")) {
		err = pthread_create(&fm_tid, NULL, fm_test, tc_info);
		if (err != 0) {
			printf("create fm test thread error: %s/n",
			       strerror(err));
			return -1;
		}
	} else if (!strcmp(tc_info->base_info->name, "camera")) {
		tc_info->dev_id = 0;
		err = pthread_create(&camera_tid, NULL, camera_test, tc_info);
		if (err != 0) {
		       printf("create camera test thread error: %s/n",
		              strerror(err));
		       return -1;
		}
    	}
	else if (!strcmp(tc_info->base_info->name, "wifi")) {
		err = pthread_create(&wlan_tid, NULL, wlan_test, tc_info);
		if (err != 0) {
			printf("create wifi test thread error: %s/n",
			       strerror(err));
		}
	} else if (!strcmp(tc_info->base_info->name, "nand")) {
		err = pthread_create(&nand_tid, NULL, nand_test, tc_info);
		if (err != 0) {
			printf("create nandflash test thread error: %s/n",
			       strerror(err));
		}
	} else if (!strcmp(tc_info->base_info->name, "bluetooth")) {
		printf("bluetooth_test thread created\n");

		err = pthread_create(&bt_tid, NULL, bt_test, tc_info);
		if (err != 0) {
			printf("create bt(bluetooth) test thread error: %s/n",
			       strerror(err));
		}
	} else if (!strcmp(tc_info->base_info->name, "gsensor")) {
		err = pthread_create(&gsensor_tid, NULL, gsensor_test, tc_info);
		if (err != 0) {
			printf("create gsensor test thread error: %s/n",
			       strerror(err));
			return -1;
		}
	} else if (!strcmp(tc_info->base_info->name, "allsensor")) {
		err = pthread_create(&sensor_tid, NULL,
			all_sensor_test, tc_info);
		if (err != 0) {
			printf("create sensor test thread error: %s/n",
			       strerror(err));
			return -1;
		}
	} else if (!strcmp(tc_info->base_info->name, "lsensor")) {
		err =
		    pthread_create(&lsensor_tid, NULL, lightsensor_test,
				   tc_info);
		if (err != 0) {
			printf("create lsensor test thread error: %s/n",
			       strerror(err));
			return -1;
		}
	} else if (!strcmp(tc_info->base_info->name, "gps")) {
		err = pthread_create(&gps_tid, NULL, gps_test, tc_info);
		if (err != 0) {
			printf("create gps test thread error: %s/n",
			       strerror(err));
			return -1;
		}
	} else if (!strcmp(tc_info->base_info->name, "psensor")) {
		err = pthread_create(&psensor_tid, NULL, psensor_test, tc_info);
		if (err != 0) {
			printf("create psensor test thread error: %s/n",
			       strerror(err));
			return -1;
		}
	} else if (!strcmp(tc_info->base_info->name, "compass")) {
		err = pthread_create(&compass_tid, NULL, compass_test, tc_info);
		if (err != 0) {
			printf("create ST compass test thread error: %s/n",
			       strerror(err));
			return -1;
		}
	} else if (!strcmp(tc_info->base_info->name, "udisk")) {
		err = pthread_create(&udisk_tid, NULL, udisk_test, tc_info);
		if (err != 0) {
			printf("create sdcard test thread error: %s/n",
			       strerror(err));
			return -1;
		}
	} else if (!strcmp(tc_info->base_info->name, "sdcard")) {
		sd_err = pthread_create(&sd_tid, NULL, sdcard_test, tc_info);
		if (sd_err != 0) {
			printf("create sdcard test thread error: %s/n",
			       strerror(sd_err));
			return -1;
		}
	} else if (!strcmp(tc_info->base_info->name, "hdmi")) {
		hdmi_err = pthread_create(&hdmi_tid, NULL, hdmi_test, tc_info);
		if (hdmi_err != 0) {
			printf("create hdmi test thread error: %s/n",
			       strerror(hdmi_err));
			return -1;
		}
	} else if (!strcmp(tc_info->base_info->name, "sim")) {
		err = pthread_create(&sim_tid, NULL, sim_test, tc_info);
		if (err != 0) {
			printf("create sim test thread error: %s/n",
			       strerror(err));
			return -1;
		}
	} else if (!strcmp(tc_info->base_info->name, "vibrator")) {
		err =
		    pthread_create(&vibrator_tid, NULL, vibrator_test, tc_info);
		if (err != 0) {
			printf("create vibrator test thread error: %s/n",
			       strerror(err));
			return -1;
		}
	} else if (!strcmp(tc_info->base_info->name, "falshlight")) {
		err =
		    pthread_create(&falshlight_tid, NULL, flashlight_test,
				   tc_info);
		if (err != 0) {
			printf("create flashlight test thread error: %s/n",
			       strerror(err));
			return -1;
		}
	} else if (!strcmp(tc_info->base_info->name, "ddr")) {
		ddr_err = pthread_create(&ddr_tid, NULL, ddr_test, tc_info);
		if (ddr_err != 0) {
			printf("create ddr test thread error: %s/n",
			       strerror(ddr_err));
			return -1;
		}
	} else if (!strcmp(tc_info->base_info->name, "cpu")) {
		cpu_err = pthread_create(&cpu_tid, NULL, cpu_test, tc_info);
		if (cpu_err != 0) {
			printf("create cpu test thread error: %s/n",
			       strerror(cpu_err));
			return -1;
		}
	} else if (!strcmp(tc_info->base_info->name, "lan")) {
		lan_err = pthread_create(&lan_tid, NULL, lan_test, tc_info);
		if (lan_err != 0) {
			printf("create lan test thread error: %s/n",
			       strerror(lan_err));
			return -1;
		}
	} else {
		printf("unsupport test item:%s\n", tc_info->base_info->name);
		return -1;
	}
#endif
	return 0;
}


int init_manual_test_item(struct testcase_info *tc_info)
{
	int err = 0;
	printf("start_manual_test_item : %d, %s \r\n", tc_info->y,
	       tc_info->base_info->name);

	manual_p_y += 1;
	tc_info->y = manual_p_y;

	start_test_pthread(tc_info);

	return 0;
}

int start_manual_test_item(int x, int y)
{
	return 1;
//	Camera_Click_Event(x, y);
}

int start_auto_test_item(struct testcase_info *tc_info)
{
	printf("start_auto_test_item : LINE:%d, %s \r\n", tc_info->y,
	       tc_info->base_info->name);

	start_test_pthread(tc_info);

	return 0;
}

int run_test_item_cmd(char* item_bin)
{
    int ret = 0;
    int status = 0;
    if (item_bin == NULL)
        return -1;

    status = system(item_bin);
    if (status == -1) {
        printf("system cmd run :%s error...\n", item_bin);
        ret = -1;
    } else {
        printf("exit status value = [0x%x]\n", status);
        if (WIFEXITED(status)) {
            if (0 == WEXITSTATUS(status)) {
                printf("run item bin successfully.\n");
                ret = 0;
            } else {
                printf("run item bin fail, script exit code: %d\n", WEXITSTATUS(status));
                ret = -2;
            }
        } else {
            printf("exit status = [%d]\n", WEXITSTATUS(status));
            ret = -1;
        }
    }

    return ret;
}

int parse_test_result(char* rst_filename, char* test_item, char* para0)
{
    int ret = -1;
    char read_buf[128];
    char test_buf[10];
    int flag = 0;

    if (rst_filename == NULL || test_item == NULL)
        return -1;

    //read test result from /tmp dir
    if(access(rst_filename, F_OK) == 0) {
        //have find result file. we read this result file and parse.
        FILE *fp;

        fp = fopen(rst_filename, "r");
        memset(read_buf, 0 ,sizeof(read_buf));
        if (!fp) {
            printf("%s fopen err:%s\n",__func__,strerror(errno));
            return ret;
        }

        while(!feof(fp)) {
            char* test_ret= NULL;
            fgets(read_buf,sizeof(read_buf),fp);

            if((strstr(read_buf,test_item))!= NULL) {
                char *result = NULL;
                char delims[] = ",";

                result = strtok(read_buf, delims );
                while( result != NULL ) {
                    if(para0 != NULL && !flag) {
                        //just get extrernal first string, do'nt care others.
                        printf(">>>>> will get extern param is %s \n", result);
                        memcpy(para0, result, strlen(result));
                        flag = 1;
                    }

                    if(strstr(result,"PASS")!= NULL ||
                        strstr(result,"FAIL")!= NULL) {
                        test_ret = result;
                        break;
                    }
                    result = strtok( NULL, delims );
                }

                if(test_ret) {
                    char ch;
                    int i = 0;
                    ch = *test_ret;
                    while(ch != '\0') {
                        if (isalpha(ch)) {
                            test_buf[i++] = ch;
                            ch = *test_ret++;
                        } else {
                            ch = *test_ret++;
                        }
                    }
                    //printf(" >>>>> We get test result is %s <<<<<\n", test_buf);

                    if(0 == strcmp(test_buf, "PASS")) {
                        //pass
                        ret = 0;
                    } else if (0 == strcmp(test_buf, "FAIL")) {
                        //fail
                        ret= -1;
                    }
                } else {
                    printf(" >>>>> Error!!! wrong test result format. <<<<<\n");
                }
            }
        }
        fclose(fp);
    }

    return ret;
}

int main(int argc, char **argv)
{
	int ret, w;
	char *script_buf;
	struct list_head *pos;
	int success = 0;
	char rfCalResult[10];

#if 0
	freopen("/dev/ttyFIQ0", "a", stdout);
	setbuf(stdout, NULL);
	freopen("/dev/ttyFIQ0", "a", stderr);
	setbuf(stderr, NULL);
#endif
    printf("*****************************************\n");
    printf("***         pcba test start           ***\n");
    printf("***         Rockchip.Co.Ld.           ***\n");
    printf("*****************************************\n");

	ui_init();
	ui_set_background(BACKGROUND_ICON_INSTALLING);
	ui_print_init();
	w = gr_fb_width();
    printf(" @@@ w= %d \n", w);
	ui_print_xy_rgba((((w >> 1) - strlen(PCBA_VERSION_NAME)*CHAR_WIDTH/2)
		/CHAR_WIDTH), 0, 0, 255, 0, 255, "%s\n", PCBA_VERSION_NAME);

//	printf("Now in PCBA_test %d\n",__LINE__);
	ui_print_xy_rgba(((w >> 2) / CHAR_WIDTH - 4), 1, 255, 255, 0, 255,
			 "%s\n", PCBA_MANUAL_TEST);
//	printf("Now in PCBA_test %d\n",__LINE__);

//	drawline_4(255, 255, 0, 255, 0, (1 * CHAR_HEIGHT - (CHAR_HEIGHT>>2)),
//		w>>1, CHAR_HEIGHT, 3);

//	printf("Now in PCBA_test %d\n",__LINE__);
    //return 0;

	/*cur_p_y = (gr_fb_height() / CHAR_HEIGHT) - 1;*/

	INIT_LIST_HEAD(&manual_test_list_head);
	INIT_LIST_HEAD(&auto_test_list_head);
	script_buf = parse_script(SCRIPT_NAME);
	if (!script_buf) {
		printf("parse script failed\n");
		return -1;
	}

	ret = init_script(script_buf);
	if (ret) {
		db_error("core: init script failed(%d)\n", ret);
		return -1;
	}

	ret = parse_testcase();
	if (ret < 0) {
		db_error("core: parse all test case from script failed(%d)\n",
			 ret);
		return -1;
	} else if (ret == 0) {
		db_warn("core: NO TEST CASE to be run\n");
		return -1;
	}

	printf("\n\t manual testcase:\n");
	list_for_each(pos, &manual_test_list_head) {
		struct testcase_info *tc_info =
		    list_entry(pos, struct testcase_info, list);
		init_manual_test_item(tc_info);
	}
	manual_p_y += 1;

//	cur_p_y = manual_p_y+1;   /*for auto add items*/
    cur_p_y = MAX_ROWS / 2;
    ui_print_xy_rgba(((w >> 2) / CHAR_WIDTH - 4), cur_p_y - 1, 255, 255,
            0, 255, "%s\n", PCBA_AUTO_TEST);



//	ui_print_xy_rgba(((w >> 2) / CHAR_WIDTH - 4), manual_p_y, 255, 255,
//			 0, 255, "%s\n", PCBA_AUTO_TEST);
//	drawline_4(255, 255, 0, 255, 0,
//		   (CHAR_HEIGHT * (manual_p_y) - (CHAR_HEIGHT>>2)), w>>1,
//		   CHAR_HEIGHT, 3);

	printf("\n\t auto testcase:\n");
	list_for_each(pos, &auto_test_list_head) {
		struct testcase_info *tc_info =
		    list_entry(pos, struct testcase_info, list);
		start_auto_test_item(tc_info);
	}

	start_input_thread();

	printf("pcba test over!\n");

    //clear misc, and ready to entern main system.

	return success;
}