// FILENAME: dogclass.cpp

// ** NOTE in order for file to be "readable",
// the racing program is cut down to one race, & all of the
// 2-digit nums in one-eigth & stretch must be truncated
// and the race header is also removed.

#include "dogclass.h"
#include "unit1.h"

// GLOBAL DECLARATIONS

#define RACENUM 6

//************************* Constructor/Destructor ****************************
Dog::Dog( float record, int dist )
{
	trackrecord = record;
    recdist = dist;
    inout = 'n';
}
//-----------------------
Dog::~Dog( void )
{  }
//-------------------------------------------------------
void Dog::getinfo(FILE* &ins)
{
    int ctr;
  //  char *str = NULL;

    eatspace(ins);
    getname(ins);
    eatheader(ins);

    for (ctr = 0;ctr < RACENUM;ctr++)
    	if (!fillrace(ins,race[ctr]))
            {
            race[ctr].dist = race[ctr-1].dist;
            race[ctr].pp = race[ctr-1].pp;
            race[ctr].time = race[ctr-1].time;
            race[ctr].gate = race[ctr-1].gate;
            race[ctr].oneeigth = race[ctr-1].oneeigth;
            race[ctr].stretch = race[ctr-1].stretch;
            race[ctr].finish = race[ctr-1].finish;
            race[ctr].grade = race[ctr-1].grade;
            }


    eatspace(ins);

    geteffgrade();
    calcform();

    calculate();


}

//----------------------------------------------------------
// Gets one integer from input file and return it to program
void Dog::getname(FILE*& ins)
{
    fgetc(ins); fgetc(ins);  fgetc(ins);
    fgets(dogname,25,ins);
}

//----------------------------------------------------------
// Reads and discard "white space" from file
void Dog::eatspace(FILE *&ins)
{
    char ch;

    do
        {
        ch = (char)fgetc(ins);
        }
    while ((isspace(ch))||(ch =='-'));

    ungetc(ch,ins);

    return;
}
//----------------------------------------------------------
/// burn 3 lines of header...
void Dog::eatheader(FILE*& ins)
{
    while (fgetc(ins) != '\n') {}
    while (fgetc(ins) != '\n') {}
    while (fgetc(ins) != '\n') {}
}
//-----------------------------------------------------------
//  POSTCONDITION: Avg time, early speed, and
//			 front/back runner info is calculated
void Dog::calculate( void )
{
    int ctr, tot=0;
    float tot18=0.0, totfin=0.0;
    float tottime=0.0;
    float allsix=0.0, lastthree=0.0; //, pptimes=0.0;

    for(ctr=0;ctr<RACENUM;ctr++)
      {
      tot += race[ctr].gate;
      tot18 += race[ctr].oneeigth;
      totfin += race[ctr].finish;
      }

    early_speed = tot/RACENUM;
    avg_oneeigth = tot18/RACENUM;
    avg_finish = totfin/RACENUM;

    closing = avg_oneeigth - avg_finish;

    // effective time....
        // all races avg...
    for(ctr=0;ctr<6;ctr++)
      tottime += (race[ctr].time / (race[ctr].dist / 1000.0));

    allsix = ((tottime/6.0) - (trackrecord / (recdist/1000.0 ))) * 10;

    tottime = 0;

    //  last three avg...
    for(ctr=0;ctr<3;ctr++)
      tottime += (race[ctr].time / (race[ctr].dist / 1000.0));

    lastthree = ((tottime/3.0) - (trackrecord / (recdist/1000.0 ))) * 10;

    tottime = 0;

 /*   // pp avg...

    for(ctr=0;ctr<6;ctr++)
      {
      if (race[ctr].pp == current racing pp)
      tottime += (race[ctr].time / (race[ctr].dist / 1000.0));
      }
    pptimes = ((tottime/3.0) - (trackrecord / (recdist/1000.0 ))) * 10;  */


    //  avg togther

    avg_time = (allsix + lastthree) / 2.0;     // + pptimes

    calcstyle(early_speed);

}
//-----------------------------------------------------------
bool Dog::fillrace(FILE*& ins, Race &race)
{
   int i; char ch;
   AnsiString str;

   ch = (char)fgetc(ins);
   if (!isdigit(ch))
        {
          if (ch == '-')
            return false;
          while (fgetc(ins) != '\n') {}
          return false;
        }
   //for (i=0;i<31;i++)   fgetc(ins);
   for (i=0;i<10;i++)   fgetc(ins);

   str = AnsiString((char)fgetc(ins));
   str += AnsiString((char)fgetc(ins));
   str += AnsiString((char)fgetc(ins));
   str += AnsiString((char)fgetc(ins));
    if (AnsiStrScan(str.c_str(),'-')!=NULL)
        race.dist = 1650;
    else if (AnsiStrScan(str.c_str(),' ')!=NULL)
        race.dist = 1650;
    else
        race.dist = str.ToInt();

   for (i=0;i<17;i++)   fgetc(ins);

   race.pp = AnsiString((char)fgetc(ins)).ToInt();
   for (i=0;i<3;i++)   fgetc(ins);

   ch = (char)fgetc(ins);
   if (!isdigit(ch))
        race.gate = 8;
   else
        race.gate = AnsiString(ch).ToInt();

   for(i=0;i<5;i++)   fgetc(ins);
   ch = (char)fgetc(ins);
   if (!isdigit(ch))
        race.gate = 8;
   else
        race.oneeigth = AnsiString(ch).ToInt();

   for(i=0;i<5;i++)   fgetc(ins);
   ch = (char)fgetc(ins);
   if (!isdigit(ch))
        race.gate = 8;
   else
        race.stretch = AnsiString(ch).ToInt();

    for(i=0;i<5;i++)   fgetc(ins);
   ch = (char)fgetc(ins);
   if (!isdigit(ch))
        race.gate = 8;
   else
        race.finish = AnsiString(ch).ToInt();

    for(i=0;i<5;i++)   fgetc(ins);
   str = AnsiString((char)fgetc(ins));
   str += AnsiString((char)fgetc(ins));
   str += AnsiString((char)fgetc(ins));
   str += AnsiString((char)fgetc(ins));
   str += AnsiString((char)fgetc(ins));
    if (AnsiStrPos(str.c_str(),"Oop")!=NULL)
        race.time = trackrecord + 3.0;
    else if (AnsiStrPos(str.c_str(),"Dnf")!=NULL)
        race.time = trackrecord + 3.0;
    else if (AnsiStrPos(str.c_str(),"Rfd")!=NULL)
        race.time = trackrecord + 3.0;
    else
        race.time = str.ToDouble();

   for(i=0;i<9;i++)   fgetc(ins);
   str = AnsiString((char)fgetc(ins));
   str += AnsiString((char)fgetc(ins));
   str += AnsiString((char)fgetc(ins));
   race.grade = str;

   while (fgetc(ins)!='\n')  {}

   return true;
}
//---------------------------------------------------------------
void Dog::geteffgrade(void)
{
//		<< " [A+]=1 [B+]=4 [C+]=7 [D+]=10 [E+]=13  ";
    int total = 0;
    int num = 0;
    float avg = 0.0;
    int i;

    for (i=0;i<RACENUM;i++)
        if ((race[i].finish == 1)||(race[i].finish == 2)||(race[i].finish == 3))
             {
                num++;
              if ((AnsiStrPos(race[i].grade.c_str(),"AA")!=NULL)  ||
                   (AnsiStrPos(race[i].grade.c_str(),"TAA")!=NULL) ||
                    (AnsiStrPos(race[i].grade.c_str(),"SAA")!=NULL) )
                total += 5;
              else if (StrScan(race[i].grade.c_str(),'A'))
                total += 4;
              else if (StrScan(race[i].grade.c_str(),'B'))
                total += 3;
              else if (StrScan(race[i].grade.c_str(),'C'))
                total += 2;
              else if (StrScan(race[i].grade.c_str(),'D'))
                total += 1;
              // if a grade M race, add no points...
             }
    if ((num == 0)||(total == 0))
        effective_grade = 15;  // worst effective grade: E-
    else
        {
        avg = (float)total / (float)num;
        if (avg == 5.0)
            effective_grade = 1;    // A+
        else if (avg >= 4.75)
            effective_grade = 2;
        else if (avg >= 4.50)
            effective_grade = 3;
        else if (avg >= 4.10)
            effective_grade = 4;    // B+
        else if (avg >= 3.75)
            effective_grade = 5;
        else if (avg >= 3.50)
            effective_grade = 6;
        else if (avg >= 3.10)
            effective_grade = 7;   // C+
        else if (avg >= 2.75)
            effective_grade = 8;
        else if (avg >= 2.50)
            effective_grade = 9;
        else if (avg >= 2.10)
            effective_grade = 10;   // D+
        else if (avg >= 1.75)
            effective_grade = 11;
        else if (avg >= 1.50)
            effective_grade = 12;
        else if (avg >= 1.10)
            effective_grade = 13;   // E+
        else if (avg >= 0.75)
            effective_grade = 14;
        else
            effective_grade = 15;
        }
}
//-=----------------------------------------------------------------
void Dog::calcform(void)
{
   if (((race[0].finish <= race[1].finish) && (race[1].finish <= race[2].finish))
        && ((race[0].finish <= 5) && (race[1].finish <= 5) && (race[2].finish <= 5)))
            form = 'g';
   else
        form = 'u';

   if ((race[0].finish == 8) || (race[1].finish == 8) || (race[2].finish == 8))
        form = 'i';

   if (((race[0].finish >= race[1].finish) && (race[1].finish >= race[2].finish))
        && ((race[0].finish >= 4) && (race[1].finish >= 4) && (race[2].finish >= 4)))
        form = 'o';

   // in case a good dog slipped through....   saftey net
   if ((race[0].finish <= 3) && (race[1].finish <= 3) && (race[2].finish <= 3))
        form = 'g';
}
//-------------------------------------------------------------------
void Dog::calcstyle(float early_speed)
{
    int ctr;
    int incount = 0;
    int outcount = 0;

    if (early_speed <= 4)
        style = 'f';
    else
        style = 'b';

    if (style == 'f')
      {
      for (ctr=0;ctr<6;ctr++)
        {
        if ((race[ctr].pp == 1) || (race[ctr].pp == 2))
            if ((race[ctr].finish == 1) || (race[ctr].finish == 2))
                incount++;
        if ((race[ctr].pp == 7) || (race[ctr].pp == 8))
            if ((race[ctr].finish == 1) || (race[ctr].finish == 2))
                outcount++;
        }

      if (incount > outcount)  // if happened twice...
            inout = 'i';
      else if (incount < outcount)
            inout = 'o';
      else
            inout = 'n';
      incount = 0;
      outcount = 0;
      //cout << "(I)nside, (O)utside, or (N)o preference runner? ";
      }
}