#include <stdio.h>
#include <stdlib.h>
#include <sys/stat.h>
#include <string.h>  
#include <sys/socket.h>  
#include <netinet/in.h>  
#include <arpa/inet.h>  
#include <netdb.h>  
#include <unistd.h>
#include <sys/types.h>
#include <fcntl.h>
#include<time.h>
#include <sys/mman.h>
#include <time.h>
#include <sys/time.h>
#include <signal.h>
#include <pthread.h>



int port = 12555;
char line[4096];
char file[64];
char file1[64];
char file2[64];
char file3[64];
int count=0;

int count_flag=1;
int wr_idx = 0;
int wr_idx1 = 0;
int wr_idx2 = 0;
int wr_idx3 = 0;
int rec_st = 1;
int rec_cnt = 1;
float card_cap = 0;

void rec_off(void);



long get_file_size(const char *path)
{
    unsigned long filesize = -1;
    struct stat statbuff;
    if(stat(path, &statbuff) < 0)
	return filesize;
    else
        return statbuff.st_size;
}

int readline(FILE* f)
{
    char c;
    int len = 0;
  
    //printf("++%s\n", __FUNCTION__); 
    while ( (c = fgetc(f) ) != EOF && c != '\n' && (len < 1024))
    {
	//printf("%c", c);
        line[len++] = c;
        line[len] = '\0';
    }
    //printf("--%s\n", __FUNCTION__); 
    if(len > 1000)
	return 0;
    return len;
}

int searchstr(char *main, char *pattern)
{
    int step, i;
    int mlen = strlen(main);
    int plen = strlen(pattern);

    //printf("++%s\n", __FUNCTION__); 
    step = mlen - plen;
    if(step < 0)
	return 0;

    i = 0;
    do {
	if(strncmp(&main[i], pattern, plen) == 0)
	    return 1;
	i++;
	step--;
    } while(step >= 0);
    return 0;
}

int kill_ffmpeg(void)
{
    char kill_cmd[64];
    FILE* fp;
    int len;
    int hit;
    int pid;

    system("ps > /tmp/ps.txt");
    fp = fopen("/tmp/ps.txt", "r");
    if(fp == NULL) {
        printf("cannot open /tmp/ps.txt\n");
        //rec_off();
        //exit(0);
	return -1;
    }
    do {
        len = readline(fp);
        //printf("len %d\n", len);
        hit = 0;
        if(len > 12) { //9+3
            //check "mmcblk1p1" "mnt" present on line
            //printf("%s\n", line);
            hit = searchstr(line, "ffmpeg");
            if(!hit)
                continue;
	    else {
		sscanf(line,"%05lu ", &pid);
		sprintf(kill_cmd, "kill -9 %d", pid);
		printf("found ffmpeg pid %d!\n", pid);
		system(kill_cmd);
    		fclose(fp);
		return 1;
	    }
            //break;
        }
    } while(len>0);
    fclose(fp);
}

int check_sdcard(int *usage)
{
    int cd_prsnt;
    FILE* fp;
    int len;
    int hit1, hit2;
    int mount;
    int cd;
    unsigned long total, used, aval;
    //float total, used, aval;
    char dev[52];

    system("df > /tmp/df.txt");
    fp = fopen("/tmp/df.txt", "r");
    if(fp == NULL) {
	printf("cannot open /tmp/df.txt\n");
	rec_off();
	exit(0);
    }
    do {
	len = readline(fp);
	//printf("len %d\n", len);
	hit1 = 0;
	hit2 = 0;
	if(len > 12) { //9+3
	    //check "mmcblk1p1" "mnt" present on line
	    //printf("%s\n", line);
	    hit1 = searchstr(line, "sda1");
	    if(!hit1)
		continue;
	    hit2 = searchstr(line, "media");
	    if(hit1 && hit2) {
		sscanf(line,"%20s %10lu  %10lu %10lu %03u%%", dev, &total, &used, &aval, usage);
		//sscanf(line,"%20s %09lu  %9lu %09lu %03u%%", dev, &total, &used, &aval, usage);
		//printf("parse result:\n");
		//printf("%20s %10lu  %10lu %10lu %03u%%\n", dev, total, used, aval, *usage);
		//printf("%20s %09lu  %9lu %9lu %03u%%\n", dev, total, used, aval, *usage);
		//card_cap = total/1000.0/1000.0;
		card_cap = total/1024.0/1024.0;
	    	break;
	    }
	}
    } while(len>0);
    fclose(fp);
    mount = hit1 && hit2;
    cd = access("/dev/sda1", 0);
    if(mount && (cd < 0))
	system("umount /media");
    return mount && (cd == 0);
}

void valid_filename(char *p)
{
    while(*p != '\0') {
	if((*p==' ') || (*p==':'))
	    *p = '_';
	p++;
    }
}


#if 1
void take_filename(void)
{
    int i, existed, existed1, existed2, existed3;
    int pre_found = 0;
    int pre_found1 = 0;
    int pre_found2 = 0;
    int pre_found3 = 0;
    char pre_file[64];
    char pre_file1[64];
    char pre_file2[64];
    char pre_file3[64];
    int reach_end;
    int reach_end1;
    int reach_end2;
    int reach_end3;
    char rm_cmd[64];
    char rm_cmd1[64];
    char rm_cmd2[64];
    char rm_cmd3[64];

    //existed = access("/media/HD999.ts", 0);
    existed = access("/media/HD_1_999.ts", 0);
    existed1 = access("/media/HD_2_999.ts", 0);
    existed2 = access("/media/HD_3_999.ts", 0);
    existed3 = access("/media/HD_4_999.ts", 0);
    if(existed < 0) 
	reach_end = 0;
    else
	reach_end = 1;

    if(existed1 < 0) 
	reach_end1 = 0;
    else
	reach_end1 = 1;


    if(existed2 < 0) 
	reach_end2 = 0;
    else
	reach_end2 = 1;


    if(existed3 < 0) 
	reach_end3 = 0;
    else
	reach_end3 = 1;
    
    for(i=0; i<1000; i++) {
	sprintf(file, "/media/HD_1_%d.ts", i);
	existed = access(file, 0);
	if(existed < 0) {
	    if(!pre_found) {
		pre_found = 1;
		memcpy(pre_file, file, sizeof(file));
            	
		wr_idx = i;
            	continue;
	    }
	    
	} else {
	    if((i>wr_idx) && (reach_end == 0))
		pre_found = 0;
	}

    }
    for(i=0; i<1000; i++) {
        sprintf(file1, "/media/HD_2_%d.ts", i);
	existed1 = access(file1, 0);
	if(existed1 < 0) {
	    if(!pre_found1) {
		pre_found1 = 1;
		memcpy(pre_file1, file1, sizeof(file1));
            	
            	wr_idx1 = i;
            	continue;
	    }
	    
	} else {
	    if((i>wr_idx1) && (reach_end1 == 0))
		pre_found1 = 0;
	}
    }


    for(i=0; i<1000; i++) {
	sprintf(file2, "/media/HD_3_%d.ts", i);
	existed2 = access(file2, 0);
	if(existed2 < 0) {
	    if(!pre_found2) {
		pre_found2 = 1;
		memcpy(pre_file2, file2, sizeof(file2));
		wr_idx2 = i;
            	continue;
	    }
	    
	} else {
	    if((i>wr_idx2) && (reach_end2 == 0))
		pre_found2 = 0;
	}

    }
	for(i=0; i<1000; i++) {
		sprintf(file3, "/media/HD_4_%d.ts", i);
		existed3 = access(file3, 0);
        if(existed3 < 0) {
	    if(!pre_found3) {
		pre_found3 = 1;
		memcpy(pre_file3, file3, sizeof(file3));
            	wr_idx3 = i;
            	continue;
	    }

	} else {
	    if((i>wr_idx3) && (reach_end3 == 0))
		pre_found3 = 0;
	}
    }
    if(pre_found) {
	memcpy(file, pre_file, sizeof(file));
    }
    else { //take care if 1000 ts file exitsed.
	wr_idx = wr_idx + 1;
	if(wr_idx>=1000)
	   wr_idx = 0;
 	sprintf(file, "/media/HD_1_%d.ts", wr_idx);
	sprintf(rm_cmd, "rm %s", file);
	system(rm_cmd);
    	printf("1000 ts file existed!, %s\n", rm_cmd);
    }

    if(pre_found1){ 
	memcpy(file1, pre_file1, sizeof(file1)); 
    
    }	
    else { //take care if 1000 ts file exitsed.
	wr_idx1 = wr_idx1 + 1;
	if(wr_idx1>=1000)
	   wr_idx1 = 0;
 	sprintf(file1, "/media/HD_2_%d.ts", wr_idx1);
	sprintf(rm_cmd1, "rm %s", file1);
	system(rm_cmd1);
    	printf("1000 ts file1 existed1!, %s\n", rm_cmd1);
    } 
    if(pre_found2){ 
	memcpy(file2, pre_file2, sizeof(file2)); 
    }	
    else { //take care if 1000 ts file exitsed.
	wr_idx2 = wr_idx2 + 1;
	if(wr_idx2>=1000)
	   wr_idx2 = 0;
 	sprintf(file2, "/media/HD_3_%d.ts", wr_idx2);
	sprintf(rm_cmd2, "rm %s", file2);
	system(rm_cmd2);
    	printf("1000 ts file2 existed2!, %s\n", rm_cmd2);
    } 
    if(pre_found3) 
	memcpy(file3, pre_file3, sizeof(file3)); 
    else { //take care if 1000 ts file exitsed.
	wr_idx3 = wr_idx3 + 1;
	if(wr_idx3>=1000)
	   wr_idx3 = 0;
 	sprintf(file3, "/media/HD_4_%d.ts", wr_idx3);
	sprintf(rm_cmd3, "rm %s", file3);
	system(rm_cmd3);
    	printf("1000 ts file3 existed3!, %s\n", rm_cmd3);
    } 
}
#endif

void rm_file(void)
{
    int i, existed, existed1, existed2, existed3;
    int pre_found = 0;
    int pre_found1 = 0;
    int pre_found2 = 0;
    int pre_found3 = 0;
    char pre_file[64];
    char pre_file1[64];
    char pre_file2[64];
    char pre_file3[64];
    int reach_end;
    int reach_end1;
    int reach_end2;
    int reach_end3;
    char rm_cmd[64];

    existed = access("/media/HD_1_999.ts", 0);
    if(existed < 0)
        reach_end = 0;
    else
        reach_end = 1;

    existed1 = access("/media/HD_2_999.ts", 0);
    if(existed1 < 0)
        reach_end1 = 0;
    else
        reach_end1 = 1;

    existed2 = access("/media/HD_3_999.ts", 0);
    if(existed2 < 0)
        reach_end2 = 0;
    else
        reach_end2 = 1;

    existed3 = access("/media/HD_4_999.ts", 0);
    if(existed3 < 0)
        reach_end3 = 0;
    else
        reach_end3 = 1;

    printf("rm file wr_idx:%d\n",wr_idx);
    printf("rm file wr_idx1:%d\n",wr_idx1);
    printf("rm file wr_idx2:%d\n",wr_idx2);
    printf("rm file wr_idx3:%d\n",wr_idx3);
    if(reach_end && (wr_idx != 999)) {
	for(i=999; i>wr_idx; i--) {
            sprintf(file, "/media/HD_1_%d.ts", i);
            existed = access(file, 0);
            if(existed == 0) {
		pre_found = 1;
		memcpy(pre_file, file, sizeof(file));
	    }
	}
    } else {
	for(i=0; i<1000; i++) {
            sprintf(file, "/media/HD_1_%d.ts", i);
            existed = access(file, 0);
            if(existed == 0) {
		pre_found = 1;
                memcpy(pre_file, file, sizeof(file));
		break;
            }
        }
    }

//2
    if(reach_end1 && (wr_idx1 != 999)) {
	for(i=999; i>wr_idx1; i--) {
            sprintf(file1, "/media/HD_2_%d.ts", i);
            existed1 = access(file1, 0);
            if(existed1 == 0) {
		pre_found1 = 1;
		memcpy(pre_file1, file1, sizeof(file1));
	    }
	}
    } else {
	for(i=0; i<1000; i++) {
            sprintf(file1, "/media/HD_2_%d.ts", i);
            existed1 = access(file1, 0);
            if(existed1 == 0) {
		pre_found1 = 1;
                memcpy(pre_file1, file1, sizeof(file1));
		break;
            }
        }
    }

    if(reach_end2 && (wr_idx2 != 999)) {
	for(i=999; i>wr_idx2; i--) {
            sprintf(file2, "/media/HD_3_%d.ts", i);
            existed2 = access(file2, 0);
            if(existed2 == 0) {
		pre_found2 = 1;
		memcpy(pre_file2, file2, sizeof(file2));
	    }
	}
    } else {
	for(i=0; i<1000; i++) {
            sprintf(file2, "/media/HD_3_%d.ts", i);
            existed2 = access(file2, 0);
            if(existed2 == 0) {
		pre_found2 = 1;
                memcpy(pre_file2, file2, sizeof(file2));
		break;
            }
        }
    }


    if(reach_end3 && (wr_idx3 != 999)) {
	for(i=999; i>wr_idx3; i--) {
            sprintf(file3, "/media/HD_4_%d.ts", i);
            existed3 = access(file3, 0);
            if(existed3 == 0) {
		pre_found3 = 1;
		memcpy(pre_file3, file3, sizeof(file3));
	    }
	}
    } else {
	for(i=0; i<1000; i++) {
            sprintf(file3, "/media/HD_4_%d.ts", i);
            existed3 = access(file3, 0);
            if(existed3 == 0) {
		pre_found3 = 1;
                memcpy(pre_file3, file3, sizeof(file3));
		break;
            }
        }
    }

    if(pre_found) {
    	sprintf(rm_cmd, "rm %s", pre_file);
    	system(rm_cmd);
    	printf("do rm, %s\n", rm_cmd);
    }

    if(pre_found1) {
    	sprintf(rm_cmd, "rm %s", pre_file1);
    	system(rm_cmd);
    	printf("do rm, %s\n", rm_cmd);
    }

    if(pre_found2) {
    	sprintf(rm_cmd, "rm %s", pre_file2);
    	system(rm_cmd);
    	printf("do rm, %s\n", rm_cmd);
    }

    if(pre_found3) {
    	sprintf(rm_cmd, "rm %s", pre_file3);
    	system(rm_cmd);
    	printf("do rm, %s\n", rm_cmd);
    }


}
/*
int detect_audio(void)
{
    struct sockaddr_in clientAddr;
    socklen_t alen;
    struct sockaddr_in sockaddr;
    int timeout = 0;
    int sock;
    unsigned int hdr;
    int len;
    int hit = 0;
    char rxbuf[1504];

    sock = init_rx_port(20003, &sockaddr);
    do {
        len = recvfrom(sock, rxbuf, 1504, MSG_DONTWAIT, (struct sockaddr*)&clientAddr, &alen);
        if(len>0) {
	    hit++;
        } else {
	    timeout++;
	}
	if(hit>10) {
	     close(sock);
	     return 1;
	}
   	usleep(10000);
    } while(timeout < 200);
    close(sock);
    return 0;
}


int detect_fps(void)
{
    struct sockaddr_in clientAddr;
    socklen_t alen;
    struct sockaddr_in sockaddr;
    int fps = 0x1234;
    int sock;
    unsigned int hdr;
    int len;
    int timeout = 0;
    char rxbuf[1504];

    sock = init_rx_port(12555, &sockaddr);
    printf("vstream port opened\n");
    do {
	len = recvfrom(sock, rxbuf, 1504, MSG_DONTWAIT, (struct sockaddr*)&clientAddr, &alen);
	if(len>15) {
	    memcpy(&hdr, rxbuf, sizeof(hdr));
	    if((hdr == 0x1000000) && (rxbuf[4] == 0x00) &&  (rxbuf[15] == 0x80)) {
		fps = rxbuf[6];
	    }
	}
	if(len <= 0) {
	    timeout++;
	    usleep(500);
	    if(timeout%1000 == 0)
	   	printf("detect fps timeout %d", timeout);
	}
    } while(fps == 0x1234);
    close(sock);
    return fps;
}
*/
void rec_off(void)
{
    printf("kill record process\n");
    system("echo ""REC OFF"" > /tmp/rec");
    system("sync");
    count=0xAA;
    //system("pkill.sh ffmpeg");
    //system("pkill.sh ffmpeg");
    kill_ffmpeg();
    rec_cnt = 1;
    //sleep(1);
}

int rec_on(void)
{
    int rtn, errno, errno1, errno2, errno3;
    int fps;
    int audio;

    char ffmpeg_cmd[512];
    char ffmpeg_cmd1[512];
    char ffmpeg_cmd2[512];
    char ffmpeg_cmd3[512];

    int do_rec = 0;
    int usage = 100;

    if(check_sdcard(&usage)) {
    	printf("1:found sd card!\n");
        do_rec = 1;
    } else if(access("/dev/sda1", 0) == 0) {
        system("umount /media");
        system("mount /dev/sda1 /media");
        sleep(2);
        if(check_sdcard(&usage)) {
            printf("2:found sd card!\n");
            do_rec = 1;
        }
        } else {
            printf("No TF card!\n");
            do_rec = 0;
            system("echo ""REC OFF(No Card)"" > /tmp/rec");
    }
        if(do_rec) {

	    count=0x55;
//	    system("echo ""REC startup..."" > /tmp/rec");
            printf("--detected fps %d\n", fps);
            //fps = detect_fps();
            fps = 60;
            printf("++detected fps %d\n", fps);
//	    sprintf(ffmpeg_cmd, "echo ""REC ON %d%% of %.2fGB"" > /tmp/rec", usage, card_cap);
	    system(ffmpeg_cmd);
	    system(ffmpeg_cmd1);
	    system(ffmpeg_cmd2);
	    system(ffmpeg_cmd3);
            //audio = detect_audio();
            audio = 0;
            printf("detected audio %s\n", audio ? "enable" : "disable");

            take_filename();
            printf("save file name is %s\n", file);
            printf("save file1 name is %s\n", file1);
            printf("save file2 name is %s\n", file2);
            printf("save file3 name is %s\n", file3);

            if(audio){
            	sprintf(ffmpeg_cmd, "ffmpeg -f h264 -r %d -i udp://localhost:12555 -f aac -i udp://localhost:20003 -vcodec copy -acodec copy -ar 16000 -r %d -f mpegts %s </dev/null &", fps, fps, file);
		sprintf(ffmpeg_cmd1, "ffmpeg -f h264 -r %d -i udp://localhost:12556 -f aac -i udp://localhost:20003 -vcodec copy -acodec copy -ar 16000 -r %d -f mpegts %s </dev/null &", fps, fps, file1);
            	sprintf(ffmpeg_cmd2, "ffmpeg -f h264 -r %d -i udp://localhost:12557 -f aac -i udp://localhost:20003 -vcodec copy -acodec copy -ar 16000 -r %d -f mpegts %s </dev/null &", fps, fps, file2);
            	sprintf(ffmpeg_cmd3, "ffmpeg -f h264 -r %d -i udp://localhost:12558 -f aac -i udp://localhost:20003 -vcodec copy -acodec copy -ar 16000 -r %d -f mpegts %s </dev/null &", fps, fps, file3);
	    }
	    else{
            	sprintf(ffmpeg_cmd, "ffmpeg -f hevc -r 25  -i udp://127.0.0.1:12565 -vcodec copy -an -f mpegts %s </dev/null &",  file);
            	sprintf(ffmpeg_cmd1, "ffmpeg -f hevc -r 25  -i udp://127.0.0.1:12566 -vcodec copy -an -f mpegts %s </dev/null &",  file1);
            	sprintf(ffmpeg_cmd2, "ffmpeg -f hevc -r 25  -i udp://127.0.0.1:12567 -vcodec copy -an -f mpegts %s </dev/null &",  file2);
            	sprintf(ffmpeg_cmd3, "ffmpeg -f hevc -r 25  -i udp://127.0.0.1:12568 -vcodec copy -an -f mpegts %s </dev/null &",  file3);
    	   
	       //printf("file %s",file);	
	       //printf("file1 %s",file1);	
	       //printf("file2 %s",file2);	
	       //printf("file3 %s",file3);	

	   }
	    printf("ffmpeg_cmd: %s\n", ffmpeg_cmd);
	    printf("ffmpeg_cmd1: %s\n", ffmpeg_cmd1);
	    printf("ffmpeg_cmd2: %s\n", ffmpeg_cmd2);
	    printf("ffmpeg_cmd3: %s\n", ffmpeg_cmd3);
            errno = system(ffmpeg_cmd);
            errno1 = system(ffmpeg_cmd1);
            errno2 = system(ffmpeg_cmd2);
            errno3 = system(ffmpeg_cmd3);
            printf("ffmpeg lanuch %d\n", errno);
            system("echo ""REC ON"" > /tmp/rec");
            //rec_st = !rec_st;
	    //return 1;

        } else {
            system("echo ""REC OFF No Card"" > /tmp/rec");
        }
        sleep(1);

	return do_rec;
}

void check_disk(void)
{
    int usage = 0;
    //int rec_cnt = 1;
    int do_rec;
    char card_st[64];

    do {
	do_rec = check_sdcard(&usage);
	if(!do_rec) {
	    //rec_st = 0;
	    rec_off();
	} else {
	    sprintf(card_st, "echo ""REC ON %d%% of %.2fGB"" > /tmp/rec", usage, card_cap);
	    system(card_st);
		if(count == 0xAA){
			rec_on();
		}
	}
	
	if(usage > 90) {
	    rec_off();
	    rm_file();
	    //rm_file();
	    system("echo ""card almost full"" > /tmp/rec");
	    do_rec = check_sdcard(&usage);
	    if(!do_rec)
		system("echo ""REC OFF no card"" > /tmp/rec");
	    if(usage<=90 && do_rec) {
		system("echo ""REC ON"" > /tmp/rec");
		rec_on();
		rec_cnt = 1;
	    }
	}
    } while(usage>90);

    rec_cnt++;
    if((rec_cnt%30) == 0) { //a file about 300 second
	printf("split file\n");
	rec_off();
	rec_on();
	rec_cnt = 1;
    }
}

void set_timer()
{
        struct itimerval itv, oldtv;
        itv.it_interval.tv_sec = 300;
        itv.it_interval.tv_usec = 0;
        itv.it_value.tv_sec = 300;
        itv.it_value.tv_usec = 0;
        setitimer(ITIMER_REAL, &itv, &oldtv);
}

void sigalrm_handler(int sig)
{
       // count++;
         //       count_flag =1;
        printf("timer signal.. %d\n", count);
}



int main(int argc, char **argv)
{
    int i, j=0;
    int rtn, errno;
    int fps;
    int audio;

    uint8_t led = 0, led_ctrl;
    int led_fd;
    int cnt = 1;

    //int i, j=0;
    //int rtn, errno;
    int do_rec;
    //int rec_st = 0;
    int usage = 100;
    int rec_init = 1;

    int fd;
    unsigned int tmp;


	signal(SIGALRM, sigalrm_handler);
        set_timer();

/*
    led_fd = open("/sys/class/leds/led2/brightness", O_WRONLY); //data receive indicator
    if(led_fd < 0) {
        printf("open led failed\n");
        return -1;
    }
*/

	 rec_on();

    
    while(1) {
        

//	if(count_flag  == 1){
//		count_flag =0;
//		rec_off();
//		rec_on();
//	}
	usleep(20000);
	cnt++;
	if((cnt%45 == 0) && rec_st) {
	  //  led ^= 0x1;
         //   led_ctrl = led+0x30;
         //   write(led_fd, &led_ctrl, 1);
	    if(cnt%270 == 0)
            	system("sync");
	} else if(!rec_st && (cnt%10 == 0)){
	 //   led ^= 0x1;
         //   led_ctrl = led+0x30;
         //   write(led_fd, &led_ctrl, 1);
	}
	if((cnt%250 == 0) && rec_st){ //check disk every 10s	
	#if 0
		if(access("/dev/sda1", 0) == 0){
			system("mount /dev/sda1 /media");
	
			usleep(2000000);
		}
	#endif
		check_disk();

	}
    }//while 1

    close(led_fd);
    printf("write file finish\r\n");
}