/********************************************************************
**
**  Questo programma e' copyright 1997-98 Paolo Ferraresi.
**
**  E' freeware e puo' essere distribuito liberamente a patto che
**  non venga alterata o cancellata questa intestazione e la scritta
**  che appare sopra il menu aggiorna.
**  Non si puo' inoltre pretendere il pagamento di una qualunque
**  cifra per cederlo ad altri.
**
**  L'uso di questo programma avviene a proprio rischio e pericolo.
**
**  Questo sorgente e' scritto in 100% ANSI C, quindi puo' essere
**  compilato per funzionare su qualsiasi macchina.
**  Per questo motivo e' assente qualunque tipo di interfaccia grafica,
**  ma se avete la pazienza di gestire la vostra fantasquadra tramite
**  la tastiera di un telefono, allora penso che potrete sopportare
**  anche questo.
**
**  L'uso e' molto semplice e percio' non allego nessuna spiegazione.
**  Per lanciare il programma, una volta compilato, digitare:
**  nome_programma [numero_fantasquadra]
**
**  N.B.:i dati cambiati vengono salvati quando si esce dal programma,
**       quindi se ci si accorge di aver fatto un errore interrompere
**       con un CTRL+C prima di uscire e rifare tutto.
**
**  Ciao, ciao!!
**
*************************************************************************
**                                                                     **
**                        AMIGA rulez !!!!!!                           **
**                                                                     **
*************************************************************************/


#include <stdio.h>
#include <string.h>

#define TOTALE 1
#define SQUADRA 2
#define TRUE 1
#define FALSE 0

struct elemento
{
    char nome[15],ruolo;
    int quotaz,gol,assist,partite,codice;
    float punti,puntitot;
    };

struct record
{
    int mil,valore_p,giorcop;
    char segreto[7];
    float ptgior,pttot,ptcop,relativo_p,ptprimo;
    };

struct change
{
    struct elemento *prec,*prox;
    };

unsigned int maschera=0;

/*****************
****   main   ****
******************/

int main(argc,argv)
int argc;
char *argv[];
{
    void Aggiorna(),Elabora(),Nuovo(),Giocatore();
    struct elemento squadra[25];
    struct record rec;
    extern unsigned int maschera;
    long int contr;
    int k;
    char scelta,nometot[20]="PROGDIR:",nomedat[20]="PROGDIR:",id[7];
    FILE *tot,*squad;

    if (argc<2)
    {
        printf("\nNon hai specificato il numero della squadra.\nCodice di identificazione squadra = ");
        scanf("%s",id);
        getchar();
    }
    else
    {
        contr=atol(argv[1]);
        if (contr<1 || contr>999999)
        {
            printf("\nIl numero della squadra specificato non e\' valido.\nInserisci il numero corretto: ");
            scanf("%s",id);
            getchar();
        }
        else
            strcpy(id,argv[1]);
    };

inizio:

    strcat(nometot,id);
    strcat(nometot,".tot");
    strcat(nomedat,id);
    strcat(nomedat,".dat");

/******* Apre il file nometot e se non esiste lo crea *******/

    tot= fopen (nometot,"r");
    if (tot==NULL)
    {
        printf("\33[H\33[JIl file %s.tot non esiste e quindi devi crearlo.\n",id);
        printf("\nN.B: se devi inserire piu\' dati sulla stessa riga devi separarli con uno SPAZIO o con INVIO.\n");
        Nuovo(&rec);
        tot=fopen(nometot,"w");
        fwrite((char *)&rec,sizeof(struct record),1,tot);
        fclose(tot);
    }
    else
    {
        fread((char *)&rec,sizeof(struct record),1,tot);
        fclose(tot);
    };

/******* Apre il file nomedat e se non esiste lo crea *******/

    squad=fopen(nomedat,"r");
    if (squad==NULL)
    {
        printf("\33[H\33[J");
        printf("Il file %s.dat non esiste percio\' devi crearlo.\n",id);

        for(k=0;k<25;k++)
        {
            printf("\nGiocatore %d\n",k+1);
            if (k+1==1 || k+1==12) printf("Deve essere un portiere\n");
            Giocatore(&squadra[k]);
        };

        squad=fopen(nomedat,"w");
        fwrite((char *)squadra,sizeof(struct elemento),25,squad);
        fclose(squad);
    }
    else
    {
        fread((char *)squadra,sizeof(struct elemento),25,squad);
        fclose(squad);
    };

    do
    {
     printf("\33[H\33[J\33[2;25H");
     printf("N. telefono:  166/663570\33[4;26HNumero Squadra: %s\33[6;27HCodice Segreto: %s",id,rec.segreto);
     printf("\33[10;30H1_Vedi squadra\33[12;30H2_Aggiorna\33[14;30H3_Cambia squadra\33[16;30H0_Esci\33[18;30H Scelta:");
     scelta=getchar();
     getchar();

     switch (scelta)
     {
       case '1':Elabora(squadra,rec);
                break;
       case '2':Aggiorna(squadra,&rec);
                break;
       case '3':printf("\n\nNumero della nuova squadra: ");
                scanf("%s",&id);
                getchar();
                if (maschera & SQUADRA)
                {
                    squad=fopen(nomedat,"w");
                    fwrite((char *)squadra,sizeof(struct elemento),25,squad);
                    fclose(squad);
                };
                if (maschera & TOTALE)
                {
                    tot=fopen(nometot,"w");
                    fwrite((char *)&rec,sizeof(struct record),1,tot);
                    fclose(tot);
                };

                maschera=0;
                strcpy(nometot,"PROGDIR:");
                strcpy(nomedat,"PROGDIR:");
                goto inizio;
     };
    }
    while (scelta!='0');

    if (maschera & SQUADRA)
    {
        squad=fopen(nomedat,"w");
        fwrite((char *)squadra,sizeof(struct elemento),25,squad);
        fclose(squad);
    };
    if (maschera & TOTALE)
    {
        tot=fopen(nometot,"w");
        fwrite((char *)&rec,sizeof(struct record),1,tot);
        fclose(tot);
    };

    return 0;
}


/***********************
*****    Nuovo    ******
************************/

void Nuovo(punt)
struct record *punt;
{
    double inp;
    
    printf("Codice segreto personale:");
    scanf("%s",&punt->segreto);
    printf("Punti totalizzati fino ad ora (compresa l\'ultima giornata): ");
    scanf("%lf",&inp);
    punt->pttot=(float) inp;
    printf("Punti totalizzati nell\'ultima giornata: ");
    scanf("%lf",&inp);
    punt->ptgior=(float) inp;
    printf("Punti fantacoppa: ");
    scanf("%lf",&inp);
    punt->ptcop=(float) inp;
    printf("Numero giornata di fantacoppa (1,2,3 o 4): ");
    scanf("%d",&punt->giorcop);
    printf("Punti primo in classifica: ");
    scanf("%lf",&inp);
    punt->ptprimo=(float)inp;
    punt->relativo_p=((float)inp)-punt->pttot;
    printf("Miliardi ancora a disposizione: ");
    scanf("%d",&punt->mil);
    punt->valore_p=0;
    getchar();

    return;
}


/**********************
*****  Giocatore  *****
***********************/

void Giocatore(punt)
struct elemento *punt;
{
    double inp;

    printf("Nome (non inserire degli spazi): ");
    scanf("%s",&punt->nome);
    getchar();
    printf("Codice: ");
    scanf("%d",&punt->codice);
    getchar();
    printf("Ruolo (p,d,c,a): ");
    punt->ruolo=getchar();
    printf("Gol fatti, assist, quotazione (in totale): ");
    scanf("%d%d%d",&punt->gol,&punt->assist,&punt->quotaz);
    printf("Punti ottenuti nell\'ultima giornata: ");
    scanf("%lf",&inp);
    punt->punti=(float) inp;
    getchar();
    punt->puntitot=punt->punti;
    if (punt->punti==0)
        punt->partite=0;
    else
        punt->partite=1;

    return;
}


/********************
****   Elabora   ****
*********************/

void Elabora(squadra,rec)
struct elemento squadra[25];
struct record rec;
{
    int i,valore=0;
    float media;

    for(i=0;i<25;i++)
    {
        valore+=squadra[i].quotaz;
    };

    puts("\33[H\33[JGiocatori titolari\n");
    puts("                      Quotaz.  Giocate   Media    Gol  Assist   Punti\n");
    for(i=0;i<11;++i)
    {
        if (squadra[i].partite!=0)
            media=squadra[i].puntitot/squadra[i].partite;
        else
            media=0;
        printf("%-16s(%3d)%6d%8d%10.1f%7d%7d%9.1f\n",squadra[i].nome,squadra[i].codice,squadra[i].quotaz,squadra[i].partite,media,squadra[i].gol,squadra[i].assist,squadra[i].punti);
    };
    puts("\n\nSquadra\n");
    printf("Punti totali:  %7.1f\nPunti giornata: %5.1f\n",rec.pttot,rec.ptgior);
    printf("Punti fantacoppa:%5.1f\n",rec.ptcop);
    printf("Valore squadra:   %d  era %d\n",valore,rec.valore_p);
    printf("Distanza dalla vetta:%6.1f  era%6.1f\n",rec.ptprimo-rec.pttot,rec.relativo_p);
    printf("Miliardi a disposizione: %d\n",rec.mil);
    puts("\n\nPremi invio per continuare");
    getchar();
    puts("\33[H\33[JGiocatori panchina\n");
    puts("                      Quotaz.  Giocate   Media    Gol  Assist   Punti\n");
    for (i=11;i<18;++i)
    {
        if (squadra[i].partite!=0)
            media=squadra[i].puntitot/squadra[i].partite;
        else
            media=0;
        printf("%-16s(%3d)%6d%8d%10.1f%7d%7d%9.1f\n",squadra[i].nome,squadra[i].codice,squadra[i].quotaz,squadra[i].partite,media,squadra[i].gol,squadra[i].assist,squadra[i].punti);
    };
    puts("\n\nGiocatori tribuna\n");
    puts("                      Quotaz.  Giocate   Media    Gol  Assist   Punti\n");
    for (i=18;i<25;++i)
    {
        if (squadra[i].partite!=0)
            media=squadra[i].puntitot/squadra[i].partite;
        else
            media=0;
        printf("%-16s(%3d)%6d%8d%10.1f%7d%7d%9.1f\n",squadra[i].nome,squadra[i].codice,squadra[i].quotaz,squadra[i].partite,media,squadra[i].gol,squadra[i].assist,squadra[i].punti);
    };
    puts("\n\nPremi invio per continuare");
    getchar();

    return;
}

/********************
****  Aggiorna   ****
*********************/

void Aggiorna(base,prec)
struct elemento *base;
struct record *prec;
{
    void Bl_copy();
    float Punteggio();
    struct elemento *psquad=base,*sost,*con,temp;
    struct change controllo[10];
    extern unsigned int maschera;
    int tit_sost[11][2],tem,posto=0,i,k,val_p,val_n,dif,cen,att;
    char scelta,tasto,risp;
    float te;
    double inp;
    int agito;

    tit_sost[0][0]=-1;

    do
    {
        printf("\33[H\33[J\33[4;20HDeveloped on AMIGA by Paolo Ferraresi");
        printf("\33[10;30H1_Sostituzioni\33[12;30H2_Mercato\33[14;30H3_Aggiornamento dati\33[16;30H4_Correzione dati\33[18;30H0_Menu principale\33[20;30H Scelta:");
        scelta=getchar();
        getchar();

/********* Sostituzioni *********/

        switch (scelta)
        {
            case '1':maschera|=SQUADRA;
                     do
                     {
                         printf("\33[H\33[JPremi N e B (+INVIO) per scorrere i giocatori;\nS,P e T per saltare all\'inizio della squadra, panchina o tribuna;\nSPACE per confermare.\nSostituisci:");
                         printf("\33[16;0H       ************************************************************\n\n");
                         for (psquad=base;psquad<base+11;psquad++)
                         {
                             sost=psquad+11;
                             con=psquad+18;
                             if (psquad<base+7)
                                 printf("      %-25s%-25s%s\n",psquad->nome,sost->nome,con->nome);
                             else
                                 printf("      %s\n",psquad->nome);
                         };

                         psquad=base;
                         do
                         {
                             printf("\33[6;0H%-11s",psquad->nome);
                             tasto=getchar();
                             getchar();
                             if (tasto=='n' && psquad<base+24) psquad++;
                             if (tasto=='b' && psquad>base) psquad--;
                             if (tasto=='s') psquad=base;
                             if (tasto=='p')
                                 psquad=base+11;
                             if (tasto=='t')
                                 psquad=base+18;
                         }
                         while (tasto!=' ');
                         sost=psquad;
                         printf("\33[8;0Hcon");
                         psquad=base;
                         do
                         {
                             printf("\33[10;0H%-11s",psquad->nome);
                             tasto=getchar();
                             getchar();
                             if (tasto=='n' && psquad<base+24) psquad++;
                             if (tasto=='b' && psquad>base) psquad--;
                             if (tasto=='s') psquad=base;
                             if (tasto=='p')
                                 psquad=base+11;
                             if (tasto=='t')
                                 psquad=base+18;
                         }
                         while (tasto!=' ');
                         con=psquad;

                         if ((sost->ruolo=='p' && con->ruolo!='p') || (con->ruolo=='p' && sost->ruolo!='p'))
                         {
                             risp='s';
                             break;
                         };

                         if (sost->codice!=con->codice)
                         {
                             if (sost<base+11)
                             {
                                 tit_sost[posto][0]=sost->codice;
                                 tit_sost[posto][1]=con->codice;
                                 posto++;
                                 tit_sost[posto][0]=-1;
                             }
                             else
                             {
                                 if (con<base+11)
                                 {
                                     tit_sost[posto][1]=sost->codice;
                                     tit_sost[posto][0]=con->codice;
                                     posto++;
                                     tit_sost[posto][0]=-1;
                                 };
                             };

         /***** Scambia 2 blocchi della lista ******/

                             Bl_copy(&temp,sost);
                             Bl_copy(sost,con);
                             Bl_copy(con,&temp);

         /***** Ordina la squadra titolare *****/

                             if (sost<base+11 || con<base+11)
                             {
                                 do
                                 {
                                     agito=FALSE;
                                     sost=base+1;
                                     for(con=base+2;con<base+11;con++)
                                     {
                                         if (con->ruolo>sost->ruolo)
                                         {
                                             agito=TRUE;
                                             Bl_copy(&temp,sost);
                                             Bl_copy(sost,con);
                                             Bl_copy(con,&temp);
                                         };
                                         sost++;
                                     };
                                 }
                                 while(agito==TRUE);
                             };
                         };
                         printf("\nAncora (s,n)? ");
                         risp=getchar();
                         getchar();
                     }
                     while (risp=='s');

                     printf("\33[H\33[J\nSostituzione titolari:\n\n");
                     posto=0;
                     while (tit_sost[posto][0]!=-1)
                     {
                         printf("%7d -> %3d\n",tit_sost[posto][0],tit_sost[posto][1]);
                         posto++;
                     };
                     printf("\n\nNuova panchina:\n\n");
                     for (psquad=base+11;psquad<base+18;psquad++)
                         printf("%7d\n",psquad->codice);
                     dif=0;
                     cen=0;
                     att=0;
                     for (psquad=base;psquad<base+11;psquad++)
                     {
                         if (psquad->ruolo=='d') dif++;
                         if (psquad->ruolo=='c') cen++;
                         if (psquad->ruolo=='a') att++;
                     };
                     printf("\n\nIl modulo di gioco e\':  %d-%d-%d\n",dif,cen,att);
                     printf("\n\nPremi invio");
                     getchar();
                     break;

/*********** Mercato *****************/

            case '2':i=0;
                     do
                     {
                       psquad=base;
                       printf("\33[H\33[JInserisci il codice del giocatore che vuoi vendere: ");
                       scanf("%d",&tem);

                       while(psquad->codice!=tem && psquad<=base+25)
                         psquad++;

                       if (psquad>=base+25)
                       {
                           printf("\n\nIl giocatore con questo codice non esiste.\n\nPremi invio");
                           getchar();
                           break;
                       };
                       controllo[i].prec=psquad;
                       controllo[i].prox=(struct elemento *)malloc(sizeof(struct elemento));

                       printf("\n%s\n\ncon\n\n",psquad->nome);

                       Giocatore(controllo[i].prox);

                       i++;

                       printf("\nAncora (s,n)?");
                       risp=getchar();
                       getchar();
                     }
                     while(risp=='s');

                     val_p=0;
                     val_n=0;

                     for (k=0;k<i;k++)
                     {
                          val_p+=controllo[k].prec->quotaz;
                          val_n+=controllo[k].prox->quotaz;
                     };
                     val_p+=prec->mil;

                     if (val_p<val_n)
                     {
                         printf("\nMi spiace ma non hai abbastanza denaro.\n\nPremi invio");
                         getchar();
                         break;
                     }
                     else
                     {
                         maschera|=SQUADRA;
                         maschera|=TOTALE;
                         for (k=0;k<i;k++)
                             Bl_copy(controllo[k].prec,controllo[k].prox);
                         prec->mil=val_p-val_n;
                     };

                     for (k=0;k<i;k++)
                     {
                         free(controllo[k].prox);
                     };
                     break;

/************* Aggiorna i dati ***************/

            case '3':maschera|=TOTALE;
                     maschera|=SQUADRA;
                     prec->relativo_p=prec->ptprimo-prec->pttot;
                     prec->valore_p=0;
                     for(psquad=base;psquad<base+25;psquad++)
                     {
                         prec->valore_p+=psquad->quotaz;
                     };
                     printf("\33[H\33[J");
                     printf("\nDevi inserire, per ogni giocatore, i dati relativi all'ultima giornata.\n");
                     for(psquad=base;psquad<base+25;psquad++)
                     {
                         printf("\n%s\n",psquad->nome);
                         printf("Punti: ");
                         scanf("%lf",&inp);
                         psquad->punti=(float) inp;
                         if (inp!=0)
                         {
                             psquad->puntitot+=(float) inp;
                             psquad->partite++;
                             printf("Gol: ");
                             scanf("%d",&tem);
                             psquad->gol+=tem;
                             printf("Assist: ");
                             scanf("%d",&tem);
                             psquad->assist+=tem;
                         };
                         printf("Quotazione: ");
                         scanf("%d",&psquad->quotaz);
                     };
                     prec->ptgior=Punteggio(base);
                     prec->pttot+=prec->ptgior;
                     prec->giorcop++;
                     if (prec->giorcop>4)
                     {
                         prec->giorcop=1;
                         prec->ptcop=prec->ptgior;
                     }
                     else
                         prec->ptcop+=prec->ptgior;
                     printf("\nPunteggio primo: ");
                     scanf("%lf",&inp);
                     prec->ptprimo=(float) inp;
                     getchar();
                     break;

/*********** Correzione dati ********/

            case '4':psquad=base;
                     printf("\33[H\33[JInserisci il codice del giocatore di cui vuoi correggere i dati:");
                     scanf("%d",&tem);

                     while(psquad->codice!=tem && psquad<=base+25)
                         psquad++;

                     if (psquad>=base+25)
                     {
                         printf("\n\nIl giocatore con questo codice non esiste.\n\nPremi invio");
                         getchar();
                         break;
                     };
                     maschera|=SQUADRA;
                     printf("\n%s\n\nGol fatti, assist, quotazione (in totale): ",psquad->nome);
                     scanf("%d%d%d",&psquad->gol,&psquad->assist,&psquad->quotaz);
                     printf("Partite giocate (%d): ",psquad->partite);
                     scanf("%d",&psquad->partite);
                     printf("Punti ultima giornata: ");
                     scanf("%lf",&inp);
                     if (psquad->punti!=(float)inp)
                     {
                         psquad->puntitot=psquad->puntitot-psquad->punti+(float)inp;
                         psquad->punti=(float)inp;
                     };
                     te=Punteggio(base);
                     if (te!=prec->ptgior)
                     {
                         maschera|=TOTALE;
                         prec->pttot=prec->pttot-prec->ptgior+te;
                         prec->ptcop=prec->ptcop-prec->ptgior+te;
                         prec->ptgior=te;
                     };
                     getchar();
                     break;
        };
    }
    while (scelta!='0');
    return;
}


/*******************
****   Bl_copy  ****
*******************/

void Bl_copy(pdest,psorg)
struct elemento *pdest,*psorg;
{
    strcpy(pdest->nome,psorg->nome);
    pdest->codice=psorg->codice;
    pdest->ruolo=psorg->ruolo;
    pdest->quotaz=psorg->quotaz;
    pdest->gol=psorg->gol;
    pdest->assist=psorg->assist;
    pdest->partite=psorg->partite;
    pdest->punti=psorg->punti;
    pdest->puntitot=psorg->puntitot;

    return;
}


/********************
****  Punteggio  ****
*********************/

float Punteggio(squadra)
struct elemento squadra[25];
{
    int k,i,panca[7];
    int sostituz=0;
    float total=0;
    char ruol;

    for (k=0;k<7;++k)
    {
        panca[k]=0;
    };

    for (k=0;k<11;++k)
    {
        if (squadra[k].punti==0)
        {
            ruol=squadra[k].ruolo;
            for (i=0;i<7;++i)
            {
                if (squadra[i+11].ruolo==ruol && squadra[i+11].punti!=0 && panca[i]!=-1 && sostituz<3)
                {
                    total+=squadra[i+11].punti;
                    panca[i]=-1;
                    sostituz++;
                    break;
                };
            };
        }
        else
            total+=squadra[k].punti;
    };

    return(total);
}