#include "h/output.h"
#include "getdata.c"
void FormatCodecInfo(char *buffer){
	int Number;
	int AltNumber;
	char *pointer;
	Number=*((int*)buffer);
//	strupr (buffer);
	AltNumber=*((int*)buffer);
	pointer=buffer;
    sprintf(pointer, "Codec: %.4s (%.4s)\n",(char*)&Number, (char*)&AltNumber);
    strcat(pointer, "Name: ");
    pointer+=strlen(pointer);
    get_video_codec_data(pointer, Number, AltNumber, 1,70,5);
	strcat(pointer, "\nDownload URL: ");
	pointer+=strlen(pointer);
    get_video_codec_data(pointer, Number, AltNumber, 0,70,5);
	strcat(pointer, "\nAuthor: ");
	pointer+=strlen(pointer);
    get_video_codec_data(pointer, Number,AltNumber, 3,70,5);
	strcat(pointer, "\nSite: ");
	pointer+=strlen(pointer);
    get_video_codec_data(pointer, Number, AltNumber, 2,70,5);
	strcat(pointer, "\nComments: ");
	pointer+=strlen(pointer);
    get_video_codec_data(pointer, Number, AltNumber, 4,70,10);
}

void print_AVIH_flags(char *output,int dwFlags){//todo!!!
//decoding AVI flags to text form. WARNING! Use new notation // there is a some differnse in the old (1st ver.) and new version of standart
char dev='\x0';
#define AVIF_HASINDEX		0x00000010	// Index at end of file?
#define AVIF_MUSTUSEINDEX	0x00000020
#define AVIF_ISINTERLEAVED	0x00000100
#define AVIF_TRUSTCKTYPE	0x00000800	// Use CKType to find key frames?
#define AVIF_WASCAPTUREFILE	0x00010000
#define AVIF_COPYRIGHTED	0x00020000
#define FLAG_CHECK(a,b) if((dwFlags & a) == a) {if(dev) {*(output++)=' ';*(output++)=dev;*(output++)=' ';} sprintf(output,"%s",b); output+=strlen(output); dev='|';}
FLAG_CHECK(0x10,"AVIF_HASINDEX");
FLAG_CHECK(AVIF_MUSTUSEINDEX,"AVIF_MUSTUSEINDEX");
FLAG_CHECK(AVIF_ISINTERLEAVED,"AVIF_ISINTERLEAVED");
FLAG_CHECK(AVIF_TRUSTCKTYPE,"AVIF_TRUSTCKTYPE");
FLAG_CHECK(AVIF_WASCAPTUREFILE,"AVIF_WASCAPTUREFILE");
FLAG_CHECK(AVIF_COPYRIGHTED,"AVIF_COPYRIGHTED");
return;
}

int AVIH_sprintf_parse(char *output,const char* template, const char *new_template, MainAVIHeader *aviheader, mem_chunk * audio, mem_chunk *video, file_data * file_d){
//return value - number of parsed symbols. (%s - 1char, %Sd 2 char, etc)
	char convert_temp[32];
	char *name_temp;
	switch( *template ){
		case '`': *output++ = '"';
			 break;
		case '!': *output++ = '\n';
			  break;
		case 'f': sprintf( output, "%.2f", (aviheader->dwMicroSecPerFrame == 0) ? 0 : ( 1000000 / (double)aviheader->dwMicroSecPerFrame ) );
				  output += strlen( output );
			  break;
		case 'e': sprintf( output, "%2.f", (aviheader->dwMicroSecPerFrame == 0) ? 0 : ( 1000000 / (double)aviheader->dwMicroSecPerFrame+.5 ) );
				  output += strlen( output );
			  break;
		case 'E': if(aviheader->dwMicroSecPerFrame){
					if(1000000 / (double)aviheader->dwMicroSecPerFrame+.5<19){
						 sprintf(output, "/%2.ffps", 1000000 / (double)aviheader->dwMicroSecPerFrame+.5 );
						  output += strlen( output );
					}
				}
				break;
		case 'x':
			 PRN( aviheader->dwWidth );
			  break;
		case 'y': PRN( aviheader->dwHeight );
				  break;
		case 'r': PRN( aviheader->dwScale );
				  break;
		case 'a': PRN( aviheader->dwRate );
				  break;
		case 'F': PRN( aviheader->dwMicroSecPerFrame );
				  break;
		case 't': PRN( aviheader->dwStreams );
				  break;	
		case 'T': PRN (aviheader->dwTotalFrames);
				  break;
		case 'L': PRN( (int)( (double)aviheader->dwTotalFrames /1000000 * (double)aviheader->dwMicroSecPerFrame ) );
				  break;
		case 'l': 
				  human_time( (int)( (double)aviheader->dwTotalFrames /1000000 * (double)aviheader->dwMicroSecPerFrame ), convert_temp,0);
				  sprintf(output,"%s",convert_temp);
				  output+=strlen(output);
				  break;
		case 'n': sprintf(output, "%s", file_d->filename);
				  output+=strlen(output);
				 break;
		case 'Q': sprintf(output,"%s", GetFileNameOnly(file_d->filename, 0));
				  output+=strlen (output);
				  break;
		case 'J': sprintf(output,"%s", GetFileNameOnly(file_d->filename, 1));
				  output+=strlen (output);
				  break;
    	case 'S': PRN( file_d->size );
				break;
		case 's':
		        human_number((int)file_d->size,convert_temp);
				sprintf(output, "%sb",convert_temp);
				output+=strlen(output);
				break;
		 case 'M': PRN(aviheader->dwMaxBytesPerSec);
		 		break;
		 case 'R': PRN(aviheader->dwReserved1);
	 			break;
		  case 'G': sprintf(output,"%d",aviheader->dwFlags);
					output+=strlen(output);
	  			break;
		 case 'g': print_AVIH_flags(output,aviheader->dwFlags);
					output+=strlen(output);
				break;
		  case 'I': PRN(aviheader->dwInitialFrames);
	  			break;
		case 'b': PRN(aviheader->dwSuggestedBufferSize);
				break;
	    case 'A': PRN (aviheader->dwStart);
    			break;
	    case 'N': PRN (aviheader->dwLength);
    			break;
		case 'v': if(video) sprintf(output,"%.4s",(char*)&video->Data_h->fccHandler);
			output+=strlen(output);
				break;
		case 'V': if(video) sprintf(output,"%.4s",(char*)&video->Data_f.v->biCompression);
			output+=strlen(output);
			break;
		case 'z': 
			if(video){
			get_video_codec_data(output,video->Data_f.v->biCompression,video->Data_h->fccHandler,1,70,5);
			output+=strlen(output);
			}
			break;
		case 'u':if(video){
			get_video_codec_data(output,video->Data_f.v->biCompression,video->Data_h->fccHandler,0,70,5);
			output+=strlen(output);
			}
			break;
		case 'Z':if(video){
			get_video_codec_data(output,video->Data_f.v->biCompression,video->Data_h->fccHandler,3,70,5);
			output+=strlen(output);
			}
			break;
		case 'U': if(video){
			get_video_codec_data(output,video->Data_f.v->biCompression,video->Data_h->fccHandler,2,70,5);
			output+=strlen(output);
			}
			break;
		case 'p': if(video){
			get_video_codec_data(output,video->Data_f.v->biCompression,video->Data_h->fccHandler,4,70,9);
			output+=strlen(output);
			}
			break;
		case 'B': if(video)PRN( video->Data_f.v->biBitCount);
				break;
		case 'w': if(audio) PRN (audio->Data_f.a->wFormatTag);
				break;
		case 'W': if(audio) get_audio_codec_data(output,audio->Data_f.a->wFormatTag,1);
				  output+=strlen(output);
				break;
		case 'P': if(audio) get_audio_codec_data(output,audio->Data_f.a->wFormatTag,2);
				  output+=strlen(output);
				break;
		case 'D': if(audio)PRN (audio->Data_f.a->nSamplesPerSec);
				break;
		case 'd': if(audio)PRN(audio->Data_f.a->nSamplesPerSec/1000);
				break;
		case 'C': if(audio)PRN (audio->Data_f.a->nChannels);
				break;
		case 'c': if(audio){
					switch (audio->Data_f.a->nChannels){
						case 1: name_temp="Mono\x0";
								break;
						case 2: name_temp="Stereo\x0";
								break;
						default: name_temp=convert_temp;
								sprintf(convert_temp,"%d",audio->Data_f.a->nChannels);
					}
					strcat( output, name_temp);
					output+=strlen(output);
				}
	}
	*output++='\x0';
	return 1;
}

int getwaste (int A, int B){
	int C=A-B;
	return C*100/B;
}
void AVIH_sprintf(char *output,const char* template, MainAVIHeader *aviheader, mem_chunk * audio, mem_chunk *video, file_data * file_d,char *info[23], idxStat *Total, idxStat *Audio, idxStat *Video){
	int state = STATE_NORM;
	const char* pointer;
	char template_temp[32];
	int flag_print=1;
	int info_value=1;
	int key=0;
	char *template_pointer=NULL;
	idxStat *current_idxStat=NULL;
	const char *new_template=D;
	*output='\x0';
	for( pointer = template; *pointer; pointer++ ){
		switch (state){
			case STATE_NORM : 
				switch(*pointer){
					case '^': /*passthrough!*/
					case '%':state=STATE_AVIH;
							break;
					case '@':
                           	state=STATE_INFO;
							flag_print=1;
							break;
					case '&': state=STATE_IDX1_SEL;//index data
							break;
					default: *output++=*pointer;
							 *output='\x0';
					}
					if( state!=STATE_NORM && (*pointer==*(pointer+1))){
						 *output++=*pointer;
						 continue;
					}
					break;
			case STATE_TPL:
			        if (!(((*pointer>='0') && (*pointer <='9'))||	(*pointer=='.')|| (*pointer=='-')|| (*pointer=='+')|| (*pointer==' ')|| (*pointer=='#'))){
			    		*template_pointer++='d';
						*template_pointer='\x0';
						new_template=template_temp;
						state=STATE_AVIH;
						pointer--;
						continue;
					}
					*template_pointer++=*pointer;
					break;
			case STATE_AVIH:
				     if(*pointer=='^'||*pointer=='%'){
				     	state=STATE_NORM;
				    	continue;
				    }
					if (((*pointer>='0') && (*pointer <='9'))||	(*pointer=='.')|| (*pointer=='-')|| (*pointer=='+')|| (*pointer==' ')|| (*pointer=='#')){
					//printf specification copy to the output
							template_pointer=template_temp;
							*template_pointer++='%';
							state=STATE_TPL;
							continue;
					}
					AVIH_sprintf_parse (output, pointer, new_template, aviheader, audio, video, file_d);
					new_template=D;
					output+=strlen(output);
					state = STATE_NORM;
			   		break;
			case STATE_IDX1_SEL:
					state=STATE_IDX1;
					switch(*pointer) {
						case 'a': current_idxStat=Audio;
								  key=0;
								  break;
						case 'A': current_idxStat=Audio;
								  key=1;
								  break;
						case 'v': current_idxStat=Video;
								  key=0;
								  break;
						case 'V': current_idxStat=Video;
								  key=1;
								  break;
						case 't': current_idxStat=Total;
								  key=0;
								  break;
						case 'T': current_idxStat=Total;
								  key=1;
								  break;
						case 'b': if(!flags.disable.index){
									if(video){
										sprintf(output, "%0.2fbpp",(double)Video->TotalSize[0]*8/(double)aviheader->dwWidth/(double)aviheader->dwHeight/(double)aviheader->dwTotalFrames);
									  	output+=strlen(output);
									}
								}
							  	state=STATE_NORM;
								break;
						case 'w': if(!flags.disable.index){
									sprintf(output, "%d", (int)(file_d->size)-(Total->TotalSize[0]));
								  	output+=strlen(output);
									}
								  	state=STATE_NORM;
								  	break;
						case 'W': if(!flags.disable.index){
										sprintf(output, "%d",getwaste (file_d->size,Total->TotalSize[0]));
									  	output+=strlen(output);
									}
								  	state=STATE_NORM;
								  	break;
						case 'c': if(!flags.disable.index){
										sprintf(output,"%d",(int)(24/((double)Video->TotalSize[0]*8/(double)aviheader->dwWidth/(double)aviheader->dwHeight/(double)aviheader->dwTotalFrames)));
										output+=strlen(output);
									}
									state=STATE_NORM;
									break;
						default: state=STATE_NORM;
					}
					break;
			case STATE_IDX1:
			         if(!flags.disable.index){
			          switch (*pointer) {
					 	case 'n': sprintf(output, "%d",current_idxStat->Number[key]);
					 			  output+=strlen(output);
					 			  break;
						case 'f':	sprintf(output, "%.2f", (double)current_idxStat->Number[key] /((double)aviheader->dwTotalFrames /1000000 * (double)aviheader->dwMicroSecPerFrame ) );
									output+=strlen(output);
								  	break;
						case 'F':	sprintf(output, "%.2f", ((double)aviheader->dwTotalFrames /1000000 * (double)aviheader->dwMicroSecPerFrame )/(double)current_idxStat->Number[key]);
									output+=strlen(output);
								  	break;
					 	case 'b': sprintf(output, "%dkbps",(int)( (double)current_idxStat->TotalSize[key]/( (double)aviheader->dwTotalFrames /8000 * (double)aviheader->dwMicroSecPerFrame )));
					 			  output+=strlen(output);
					 			  break;
					 	case 'B': sprintf(output, "%dkB/s",(int)( (double)current_idxStat->TotalSize[key]/( (double)aviheader->dwTotalFrames /1000 * (double)aviheader->dwMicroSecPerFrame )) );
					 			  output+=strlen(output);
					 			  break;
					 	case 'M': sprintf(output, "%d",current_idxStat->MaxSize[key]);
					 			  output+=strlen(output);
					 			  break;
					 	case 'm': sprintf(output, "%d",current_idxStat->MinSize[key]);
					 			  output+=strlen(output);
					 			  break;
					 	case 's': sprintf(output, "%d",current_idxStat->TotalSize[key]);
					 			  output+=strlen(output);
					 			  break;
					  }
					 }
					 state=STATE_NORM;
					 break;
			case STATE_INFO:
					if(*pointer<'a'||*pointer>'w'){//if out of range - turn off visibility
					    flag_print=0;
						continue;
					}
					info_value=*pointer-'a';//index in the info, info_desc, etc.
					if( !info[info_value] ) flag_print=0;//hide line if no such param found
					else if( info[info_value][0]==0 ) flag_print=0;//hide if empty
					state=STATE_NFO1;
					break;
			case STATE_NFO1:
					if (*pointer==']'){
							state=STATE_NORM;
							continue;
					}
					if(flag_print){
						switch(*pointer){
							case '\\':
								*output++='\n'; //sorry, sux symbol... -_-
								break;
							case '$':
								sprintf(output,"%s",info[info_value]);
								output+=strlen(output);
								break;
							    case '#':
							    	sprintf(output,"%s",info_desc[info_value]);
							    	output+=strlen(output);
							    	break;
						    case '*':
						    	sprintf(output,"%.4s",info_names[info_value]);
						    	output+=strlen(output);
						    	break;
							default: *output++=*pointer;
						}
					}
					break;
			}
	}
	*output='\x00';
}            

void strh_sprintf (char key, char* output,const char* template, mem_chunk *data, int stream){
//generate output line from template and strh header (mem_chunk *data)
    const char *new_template=D;
	switch (key){
		case '!':   *output++='\n';
					break;
		case 'n':	PRN(stream);
					break;
		case 'f':
					sprintf(output,"%.4s",(char*)&data->Data_h->fccType);
					output+=strlen(output);
					break;
		case 'F': PRN(data->Data_h->dwFlags);
					break;
		case 'R': PRN(data->Data_h->dwReserved1);
					break;
		case 'i': PRN(data->Data_h->dwInitialFrames);
					break;
		case 'r': PRN(data->Data_h->dwRate);
					break;
		case 's': PRN(data->Data_h->dwStart);
					break;
		case 'c': PRN(data->Data_h->dwScale);
					break;
		case 'l': PRN(data->Data_h->dwLength);
					break;
		case 'b': PRN(data->Data_h->dwSuggestedBufferSize);
					break;
		case 'q': PRN(data->Data_h->dwQuality);
					break;
		case 'S': PRN(data->Data_h->dwSampleSize);
					break;
		case 'h':  sprintf(output,"%.4s",(char*)&data->Data_h->fccHandler);
				*(output+5)='\x0';
					break;
		default: 	break;
	}
	*output='\x0';
}
void strf_sprintf(char key, char* output,const char* template, mem_chunk *data, int fccType){
//generate output line from template and strf header (mem_chunk *data) for audio or video data
    const char *new_template=D;
	if(fccType==SIGN_VIDS)
		switch (key){ //BITMAPINFO 
			case 's': PRN(data->Data_f.v->biSize); 				//biSize;         
					 break;
			case 'w':PRN(data->Data_f.v->biWidth);  			     //biWidth;  		
					 break;
			case 'h':PRN(data->Data_f.v->biHeight); 			     //biHeight; 		
					 break;
			case 'p':PRN(data->Data_f.v->biPlanes);  			     //biPlanes;  	
					 break;
			case 'c':PRN(data->Data_f.v->biBitCount);  			 //biBitCount  	
					 break;
			case 'C':sprintf(output,"%.4s",(char*)&data->Data_f.v->biCompression); 		     //biCompression; 
					 break;
			case 'S':PRN(data->Data_f.v->biSizeImage);  	        //biSizeImage;  	
					 break;
			case 'X':PRN(data->Data_f.v->biXPelsPerMeter);        //biXPelsPerMeter;
					 break;
			case 'Y':PRN(data->Data_f.v->biYPelsPerMeter);        //biYPelsPerMeter;
					 break;
			case 'u':PRN(data->Data_f.v->biClrUsed);              //biClrUsed;  	
					 break;
			case 'i':PRN(data->Data_f.v->biClrImportant);         //biClrImportant; 
					 break;				
			default: *output='\x0';
		}
	else{//WAVEFORMATEX or PCMWAVEFORMAT...
		switch (key){	
			case 'f': PRN(data->Data_f.a->wFormatTag);
					break;
			case 'H': PRN(data->Data_f.a->nChannels);
					break;
			case 'p': PRN(data->Data_f.a->nSamplesPerSec); 
					break;
			case 'a': PRN(data->Data_f.a->nAvgBytesPerSec);
					break;
			case 'b': PRN(data->Data_f.a->nBlockAlign);    
					break;
			case 'B': PRN(data->Data_f.a->wBitsPerSample); 
					break;
			case 'z': PRN(data->Data_f.a->cbSize);
					break;
			default: *output='\x0';
		};
	}
	*output='\x0';
}
void STRD_sprintf(char* output,const char* template, mem_chunk *data, MainAVIHeader *aviheader, idxStat *current_idxStat ){
	const char *pointer;
	int state = STATE_NORM;
	static int stream=0;
	stream++;
	for( pointer = template; *pointer; pointer++ ){
			if( state==STATE_NORM ){
			switch (*pointer) {
				case '$': state = STATE_STRH;
						  break;
				case '#': state = STATE_STRF;
						  break;
				case '&': if(flags.disable.index) pointer++;
						  else state=STATE_IDX1;
						  break;
				default: *output++ = *pointer;
			}
			if (*pointer==*(pointer+1)&& state!=STATE_NORM){
				*output++=*pointer++;
		 		state=STATE_NORM;
			}
			continue;
		}
	    switch (state){
			case STATE_STRH: if(data->DataSize_h)
					strh_sprintf(*pointer, output,template,data, stream);
					output+=strlen(output);
					break;
			case STATE_STRF:
					strf_sprintf(*pointer, output,template,data, data->Data_h->fccType);
					output+=strlen(output);
				break;
			case STATE_IDX1:
				 switch (*pointer) {
				 	case 'n': sprintf(output, "%d",current_idxStat->Number[0]);
				 			  output+=strlen(output);
				 			  break;
				 	case 'N': sprintf(output, "%d",current_idxStat->Number[1]);
				 			  output+=strlen(output);
				 			  break;
				 	case 'b': sprintf(output, "%dkbps",(int)( (double)current_idxStat->TotalSize[0]/( (double)aviheader->dwTotalFrames /8000 * (double)aviheader->dwMicroSecPerFrame )+1));
				 			  output+=strlen(output);
				 			  break;
				 	case 'B': sprintf(output, "%dkbps",(int)( (double)current_idxStat->TotalSize[1]/( (double)aviheader->dwTotalFrames /8000 * (double)aviheader->dwMicroSecPerFrame )+1) );
				 			  output+=strlen(output);
				 			  break;
				 	case 'M': sprintf(output, "%d",current_idxStat->MaxSize[0]);
				 			  output+=strlen(output);
				 			  break;
				 	case 'm': sprintf(output, "%d",current_idxStat->MinSize[0]);
				 			  output+=strlen(output);
				 			  break;
				 	case 'K': sprintf(output, "%d",current_idxStat->MaxSize[1]);
				 			  output+=strlen(output);
				 			  break;
				 	case 'k': sprintf(output, "%d",current_idxStat->MinSize[0]);
				 			  output+=strlen(output);
				 			  break;
				 	case 's': sprintf(output, "%d",current_idxStat->TotalSize[0]);
				 			  output+=strlen(output);
				 			  break;
				 	case 'S': sprintf(output, "%d",current_idxStat->TotalSize[1]);
				 			  output+=strlen(output);
				 			  break;
				 }
			default:;
		}
		state=STATE_NORM;
	}
	*output='\x00';
}

void steams_sprintf (char *output, const char *template, mem_chunk *str_data, MainAVIHeader *aviheader, idxStat  StreamIndexData[]){
	mem_chunk *pointer = str_data;
	int counter=0;
	while(pointer){
		STRD_sprintf (output, template, pointer, aviheader, StreamIndexData+counter++);
		pointer=pointer->Next;
		output+=strlen(output);
	}
}
void get_first_streams(mem_chunk *in, mem_chunk **audio, mem_chunk **video)
//set audio & video pointers to struct with fist audio and first video streams
//or set them == NULL if not found.
{
	mem_chunk *pointer=in;
	*audio=NULL;
	*video=NULL;
	while(pointer){
		if( pointer->Data_h->fccType==SIGN_VIDS && !*video) *video=pointer;
		if( pointer->Data_h->fccType==SIGN_AUDS && !*audio) *audio=pointer;
//		if(audio && video ) return;
		pointer=pointer->Next;
	}
}

void report( char *output,const char *template1,const char *template2, MainAVIHeader *aviheader, mem_chunk * str_data, file_data * file_d, char *info[23], idxStat StreamData[], idxStat *Global, idxStat *Audio, idxStat *Video){
    mem_chunk *first_audio;
    mem_chunk *first_video;
    get_first_streams(str_data, &first_audio, &first_video);
	AVIH_sprintf (output,template1,aviheader, first_audio, first_video, file_d,info, Global, Audio, Video);
	if(!flags.disable.streams) steams_sprintf(output+strlen(output),template2,str_data, aviheader, StreamData);
	if(flags.disable.eight) kill8(output);
}