#include "diabolo.h"
#include "fichier.h"


block_type_modele 	bktm2;		// memoire pour block local pour fabrication block
block_type_bolo		blk_bol;
block_type_synchro_sol	blk_sync;
int			index=0;
int			num_block=0;
unsigned long		temps_debut_arch;

/*
void  valide_block(block_type_modele* blk,int type,int block_num)
	{
	int somme;
	def_long_block
	blk->debut		=	debut_block_mesure;
	blk->code2		=	(block_num & 0xffffff ) | ( (type<<24)&0xff000000 );
	blk->mot[(long_block[type]/4)-4]  =	fin_block_mesure;
	calcul_somme_block(blk,longueur);
	blk->code1		=	(long_block[type]<<16)	|	somme;
	}

*/



void	fabrique_block_type_param(void)
{
#define blk  ((block_type_param*)(&bktm2)) 	// pointeur sur la memoire locale
blk->param	=	parametr;

valide_block(&bktm2,block_param,num_block);
#undef blk
ecrit_fichier_ARCH(&bktm2);
}



void	fabrique_block_type_reglage(void)
{
#define blk  ((block_type_reglage*)(&bktm2)) 	// pointeur sur la memoire locale
blk->reglage	=	gg->reglage;

valide_block(&bktm2,block_reglage,num_block);
#undef blk
ecrit_fichier_ARCH(&bktm2);
}




void	fabrique_block_type_une_periode(void)
{
#define blk  ((block_type_une_periode*)(&bktm2)) 	// pointeur sur la memoire locale

//  a ecrire boucle pour copier les periodes simples
int j,i;		
for(j=0;j<nb_max_bolo;j++)	for (i=0;i<nb_max_mes_per;i++)
		blk->bol_per[j][i]=gg->bol_per[j][i]^0x7fff;	// 16 bit -> 15 bit utile + phase
								// change le signe des 15 bits utiles		
valide_block(&bktm2,block_une_periode,num_block);
#undef blk
ecrit_fichier_ARCH(&bktm2);
}

//	short 		bol_per[nb_max_bolo][nb_max_mes_per];		



//  cette fonction rempli un block coups par coups et l'ecrit quand il est plein

void	fabrique_block_type_bolo_synchro(void)
{
int j;
int nb_coups,aa,s;
static compt_block_reg=0;

nb_coups= gg->reglage.horloge.nb_mesures/2 - gg->reglage.horloge.temp_mort;
aa = (nb_coups<<14) + (nb_coups*190) ;
if( index%2) s=1;else	s=-1;
//gg->don.don_bolo[j] =  s*(((blk->data_bolo[j][i]-aa)<<1)/nb_coups)
for(j=0;j<nb_max_bolo;j++)	blk_bol.data_bolo[j][index]=aa+((gg->don.don_bolo[j]*s*nb_coups)>>1);
for(j=0;j<nb_sync;j++)		blk_sync.synchro[j][index]=gg->don.sync[j];

index++;
if( index < (nb_per_block*2) ) return;

index=0;
num_block++;

valide_block( (block_type_modele*) &blk_sync,block_synchro_sol,num_block);
ecrit_fichier_ARCH( (block_type_modele*) &blk_sync);


valide_block( (block_type_modele*) &blk_bol,block_bolo,num_block);
ecrit_fichier_ARCH( (block_type_modele*) &blk_bol);

compt_block_reg++;
if(compt_block_reg>20)
	{
	compt_block_reg=0;
	fabrique_block_type_reglage();
	}
}





//---------------------------------------------------------------------------------------
//---------------    ecrit  les  fichiers     ARCH  	  -------------------------------
//---------------------------------------------------------------------------------------


void	ecrit_fichier_ARCH(block_type_modele * bktp)
{
unsigned long ttx;
int long_b=longueur_block(bktp);

GetDateTime(&ttx);
if(gg->scan_en_cours)	temps_debut_arch=ttx;
if( (!gg->scan_en_cours)  && ( (ttx-temps_debut_arch) > 2*temps_max_fichier) )
	{
//	printf(" fichier Archeops sans scan de plus de 10 minutes: fich_new \n");
	GetDateTime(&temps_debut_arch);		// pour ne pas le faire deux fois
	fich_new(0,0);				// pour limiter la duree des fichiers arch
	}

if(fenetre(fichier_arch_1))
	{
//	position(fichier_arch_1,fin_f);
	ecritF(fichier_arch_1,long_b,bktp);
	}
if(fenetre(fichier_arch_2))
	{
//	position(fichier_arch_2,fin_f);
	ecritF(fichier_arch_2,long_b,bktp);
	}
}



void exec_ARCH(int fen,int item,double valeur,...) 	// exec du fichier lui_meme
 							// apellé pour les deux fichiers ARCH ouverts et fermés
{
switch(item)
	{
	case ouverture	:	
     		if( (fen!=fichier_arch_1) && (fen!=fichier_arch_2) )	
     			{
#ifdef _archeops
     			ouvre('ACTI',0,10,"lit_fichier_arch",exec_lit_fichier_ARCH,(void*)fen);
#else
			printf(" ne peut pas relire les fichiers archeops \n");
			printf("il faut compiler avec archeops ou planck  \n");
#endif
     			break;
     			}
//											
//*****************************************************************************************
		printf("nouveau fichier archeops : %s  \n",titre(fen));
		gg->fichier_arch_ouvert=1;
		GetDateTime(&temps_debut_arch);
		fabrique_block_type_param();
		fabrique_block_type_reglage();
		break;


	case fermeture :
		gg->fichier_arch_ouvert=0;

//		if( (fen!=fichier_arch_1) && (fen!=fichier_arch_2) )  break;
//		fich_save_partiel(3);

//		litD(fenetre_fichier,f_comment,E->commentaires);
//		ecritD(fenetre_fichier,f_comment,"../..");
		break;
		
	}
}