/******************************************************************************
* File: wwwstat.c
* Author: Jason Freund
* Last Edited: 3/2/98
* Purpose: compute hit statistics of web pages, generates various reports
* 1) Compile with: gcc -w -g wwwstat.c -o wwwstat -lc
* 2) Build temporary interest file: 
*    grep interest .../www/httpd/logs/access_log | grep html >! interest_log
* 3) Run wwwstat on that temp file: wwwstat < interest_log >! interest_report
* Note: wwwstat assumes all hits are already given in chronological order.
*       Therefore you cannot concatenate two greps together, otherwise,
*       the temp file will have two ranges of dates, not in order.
*==============================================================================
* void Error(char *s, int status)
* int GetNextLine(FILE *fp, char *line)
* void Usage()
* void ParseLine(char *line, Hit *hit);
* void InsertList(Hit *hit) 
* void UniqueUsers()
* void GenerateReport()
* void Popularity(Hit *docs)
* void ChronoHits(Hit *docs, int numdocs)
* int DocIndex(Hit *docs, char *docname,int numdocs)
******************************************************************************/


/*includes********************************************************************/
#include <stdio.h>
#include <string.h>
#include <stdlib.h>


/*defines*********************************************************************/
#define INPUT_LINE_SIZE		200
#define TRUE			1
#define FALSE			0
#define MAXUSERS		10000
#define MAXDOCUMENTS		1000
#define MIN(x,y) 		(((x)<(y))?(x):(y))
#define MAX(x,y) 		(((x)>(y))?(x):(y))


/*types***********************************************************************/
typedef struct {
  char user[INPUT_LINE_SIZE];
  char document[INPUT_LINE_SIZE];
  int day, month, year;
  int numhits;
} Hit;


/*prototypes******************************************************************/
void Error(char *s, int status);
int GetNextLine(FILE *fp, char *line);
void Usage();
void ParseLine(char *line, Hit *hit);
void InsertList(Hit *hit);
void UniqueUsers();
int Popularity(Hit *docs);
void GenerateReport();
void ChronoHits(Hit *docs, int numdocs);
int DocIndex(Hit *docs, char *docname,int numdocs);


/*globals*********************************************************************/
Hit HitList[MAXUSERS];
int NumHits;
char months[12][5] = {
  "Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"};
int chrono=3,verbose=1;


/******************************************************************************
* void Error(char *s, int status)
******************************************************************************/
void Error(char *s, int status)
{
  fprintf(stderr,"Error: %s\n",s);
  if (status) exit(status);
}


/******************************************************************************
* void Usage()
******************************************************************************/
void Usage()
{
  fprintf(stderr,"Usage: wwwstat \n");
  fprintf(stderr,"\t[-h] [-verbose <n>]\n");
  fprintf(stderr,"\t[-chrono <n>] (tally every n days)\n");
  fprintf(stderr,"\t< logfile > report\n");
  exit(0);
}


/********************************************************************************
* int GetNextLine(FILE *fp, char *line)
* Reads next line of input from fp and returns it in nextline
* Returns TRUE if it found a NON-EMPTY line
* Returns FALSE if it could not find a NON-EMPTY file or it reached EOF.
*******************************************************************************/
int GetNextLine(FILE *fp, char *line)
{
int i,c;
 
  for (i=0;i<INPUT_LINE_SIZE-1 && (c=getc(fp)) != EOF && c!='\n';++i)
    line[i]=c;
  line[i]='\0';
  if (c==EOF) return FALSE; else return TRUE;
}
 

/******************************************************************************
* void ParseLine(char *line, Hit *hit)
******************************************************************************/
void ParseLine(char *line, Hit *hit)
{
int i,j,k,index=0;
char tempstring[INPUT_LINE_SIZE],daystr[3],monthstr[20],yearstr[10];
char junk[INPUT_LINE_SIZE];

    /* Init stuff */
  if (strlen(line)<1) return;
  strcpy(tempstring,line);
  if (verbose>1) fprintf(stderr,"Parsing Line=  %s.\n",line);
  for (i=0;i<INPUT_LINE_SIZE;i++) {
    hit->user[i]=0;
    hit->document[i]=0;
  }
  hit->day = hit->month = hit->year = hit->numhits=0;

    /* parse out user address */
  for (i=0;i<INPUT_LINE_SIZE-3;i++) if (line[i]=='-' && line[i+1]==' ' && line[i+2]=='-') break;
  strncpy(hit->user,line,i-1);

    /* parse out day of month */
  daystr[0]=line[i+5]; 
  daystr[1]=line[i+6]; 
  hit->day = atoi(daystr);

    /* parse out month */
  monthstr[0] = line[i+8];
  monthstr[1] = line[i+9];
  monthstr[2] = line[i+10];
  for (k=0;k<12;k++) if (strcmp(monthstr,months[k])==0) break;
  hit->month = k+1;

    /* parse out year */
  yearstr[0] = line[i+12];
  yearstr[1] = line[i+13];
  yearstr[2] = line[i+14];
  yearstr[3] = line[i+15];
  hit->year = atoi(yearstr);

    /* Parse out document */
  for (i=0;i<INPUT_LINE_SIZE-3;i++) 
    if (line[i]=='G' && line[i+1]=='E' && line[i+2]=='T') break;
  for (j=i+3;j<INPUT_LINE_SIZE-4;j++) 
    if (line[j]=='H' && line[j+1]=='T' && line[j+2]=='T' && line[j+3]=='P') break;
  i+=4; j-=1;
  while (i<j) hit->document[index++]=line[i++];

  hit->numhits=0;

   /* Report -- for debugging only */
/*
  fprintf(stderr,"Parsing line: %s.\n",line);
  fprintf(stderr,"User=%s, %d/%d/%d, doc=%s.\n",hit->user,
    hit->day, hit->month,hit->year, hit->document);
  fprintf(stderr,"----------------------------------------------\n");
*/
}


/******************************************************************************
* void InsertList(char *user, Hit *hit) 
******************************************************************************/
void InsertList(Hit *hit) 
{
int i;

  strcpy(HitList[NumHits].user,hit->user);
  strcpy(HitList[NumHits].document,hit->document);
  HitList[NumHits].day = hit->day;
  HitList[NumHits].month = hit->month;
  HitList[NumHits].year = hit->year;
  HitList[NumHits].numhits = hit->numhits;
  NumHits++;
  if (NumHits>MAXUSERS-2) Error("Too many users",1);
}


/******************************************************************************
* void UniqueUsers()
******************************************************************************/
void UniqueUsers()
{
int unique,hits,i,k,j,seenthisone,numusers=0;
char temp2[INPUT_LINE_SIZE],temp[INPUT_LINE_SIZE],user[INPUT_LINE_SIZE];
Hit tempuser,users[MAXUSERS];

    /* Init stuff */
  for (i=0;i<MAXUSERS;i++) {
    for (j=0;j<INPUT_LINE_SIZE;j++) {
      users[i].user[j]=0;
      users[i].document[j]=0;
    }
    users[i].numhits = 0;
    users[i].day = 0;
    users[i].month = 0;
    users[i].year = 0;
  }
  tempuser.numhits = 0;
  unique=NumHits;
  fprintf(stdout,"\n                         Unique Users report\n");
  fprintf(stdout,"                         ====================\n");

    /* Compute #hits for each unique user */
  for (i=0;i<NumHits;i++) {
      /* Get current user */
    strcpy(user,HitList[i].user);
      /* Have I already seen this user?  If so, continue. */
    seenthisone=FALSE;
    for (k=i-1;k>=0;k--) {
      strcpy(temp2,HitList[k].user);
      if (strcmp(temp2,user)==0) seenthisone=TRUE;
    }
      /* Have not seen this user, compute total hits from him. */
    if (!seenthisone) {
      hits=1;
      for (j=i+1;j<NumHits;j++) {
        strcpy(temp,HitList[j].user);
        if (strcmp(temp,user)==0) hits++;
      }    
        /* Save and report total #hits for this user */
      strcpy(users[numusers].user,user);
      users[numusers].numhits = hits;
      numusers++;
      HitList[i].numhits = hits;
    }
  }
    /* List users in structure in order of #hits */
  for (i=0;i<numusers-1;i++) {
    for (j=i+1;j<numusers;j++) {
      if (users[i].numhits<users[j].numhits) {
        strcpy(tempuser.document,users[i].document);
        tempuser.numhits = users[i].numhits;
 
        strcpy(users[i].document,users[j].document);
        users[i].numhits = users[j].numhits;
 
        strcpy(users[j].document,tempuser.document);
        users[j].numhits = tempuser.numhits;
      }
    }
  }
  for (i=0;i<numusers;i++)
    fprintf(stdout,"User %s hit %d times\n",
      users[i].user,users[i].numhits); 

  fprintf(stdout,"\n%d Unique users with a total of %d hits.\n\n",numusers,NumHits);
}


/******************************************************************************
* int Popularity(Hit *docs)
******************************************************************************/
int Popularity(Hit *docs)
{
int total=0,hits,i,k,j,numdocs=0,seenthisone;
char temp2[INPUT_LINE_SIZE],temp[INPUT_LINE_SIZE],document[INPUT_LINE_SIZE];
Hit tempdoc;

    /* Init stuff */
  for (i=0;i<MAXDOCUMENTS;i++) {
    for (j=0;j<INPUT_LINE_SIZE;j++) {
      docs[i].user[j]=0;
      docs[i].document[j]=0;
    }
    docs[i].numhits = 0;
  }
  tempdoc.numhits = 0;
  fprintf(stdout,"\n                         Page Popularity report\n");
  fprintf(stdout,"                         ======================\n");

    /* Get count for each unique document into docs structure */
  for (i=0;i<NumHits;i++) {
      /* Get current page */
    strcpy(document,HitList[i].document);
      /* Have I already seen this document?  If so, continue. */
    seenthisone=FALSE;
    for (k=i-1;k>=0;k--) {
      strcpy(temp2,HitList[k].document);
      if (strcmp(temp2,document)==0) seenthisone=TRUE;
    }
      /* Have not seen this document, compute total hits for it. */
    if (!seenthisone) {
      strcpy(docs[numdocs].document,document);
      hits=1;
      for (j=i+1;j<NumHits;j++) {
        strcpy(temp,HitList[j].document);
        if (strcmp(temp,document)==0) {
          hits++;
        }
      }    
      docs[numdocs].numhits = hits;
      numdocs++; 
      if (numdocs>MAXDOCUMENTS) Error("Too many documents",1);
      total+=hits;
    }
  }

    /* List docs in structure in order of #hits */
  for (i=0;i<numdocs-1;i++) {
    for (j=i+1;j<numdocs;j++) {
      if (docs[i].numhits<docs[j].numhits) {
        strcpy(tempdoc.document,docs[i].document);
        tempdoc.numhits = docs[i].numhits;

        strcpy(docs[i].document,docs[j].document);
        docs[i].numhits = docs[j].numhits;

        strcpy(docs[j].document,tempdoc.document);
        docs[j].numhits = tempdoc.numhits;
      }
    }
  }
  for (i=0;i<numdocs;i++) 
    fprintf(stdout,"%d) Document %s hit %d times\n",i,
      docs[i].document,docs[i].numhits); 
  fprintf(stdout,"\n%d documents hit a total of %d times.\n\n",numdocs,total);
  return numdocs;
}


/******************************************************************************
* int DocIndex(Hit *docs, char *docname, int numdocs)
* Given list of docs and a doc name, tells you which doc# it was
* Returns -1 if not found.
******************************************************************************/
int DocIndex(Hit *docs, char *docname, int numdocs)
{
int i;

  for (i=0;i<numdocs;i++) if (strcmp(docname,docs[i].document)==0) return i;
  return -1;
}


/******************************************************************************
* void ChronoHits(Hit *docs, int numdocs)
******************************************************************************/
void ChronoHits(Hit *docs, int numdocs)
{
int i=0,lastday,currday,lastmonth,currmonth,lastyear,curryear;
int modprint,index,size,hitsforday=1,j,monthtotal=0,doctotals[12];
char buff[255],temp[10];

  size = MIN(numdocs,8);
  for (j=0;j<size;j++) doctotals[j]=0;
  fprintf(stdout,"\n                         Chronological History report\n");
  fprintf(stdout,"                         ============================\n");

  lastday = HitList[i].day;
  lastmonth = HitList[i].month;
  lastyear = HitList[i].year;
  lastyear = lastyear %100;

  if (verbose) {
    fprintf(stdout,"  Date:      ");
    for (j=0;j<size;j++) fprintf(stdout," doc%d  ",j);
    fprintf(stdout,"\n");
  }
  while (i<NumHits) {
    currday = HitList[i].day; 
    currmonth = HitList[i].month; 
    curryear = HitList[i].year; 
    curryear = curryear %100;
    index = DocIndex(docs,HitList[i].document,numdocs);
    if (index>-1 && index<size) doctotals[index]++;
   
    if (currday!=lastday) {
      modprint++;
      if (verbose>0 && modprint%chrono==0) {
        buff[0]=0;
        if (lastmonth<10) sprintf(buff," 0%d/",lastmonth); else
          sprintf(buff," %d/",lastmonth); 
        if (lastday<10) sprintf(temp,"0%d/%d: ",lastday,lastyear); else
          sprintf(temp,"%d/%d: ",lastday,lastyear); 
        strcat(buff,temp);
        for (j=0;j<size;j++) {
          if (doctotals[j]<10) sprintf(temp,"     %d ",doctotals[j]); else
          if (doctotals[j]<100) sprintf(temp,"    %d ",doctotals[j]); else
          if (doctotals[j]<1000) sprintf(temp,"   %d ",doctotals[j]); else
          if (doctotals[j]<10000) sprintf(temp,"  %d ",doctotals[j]); else
          if (doctotals[j]<100000) sprintf(temp," %d ",doctotals[j]);
          strcat(buff,temp);
        }
        sprintf(temp,"  New: %d",hitsforday+chrono-1);
        monthtotal += hitsforday+chrono-1;
        strcat(buff,temp);
        fprintf(stdout,"%s\n",buff);
        modprint=0;
        hitsforday=1;
        for (j=0;j<size;j++) doctotals[j]=0;
      }

      lastday = currday;
      lastyear = curryear;
    } else hitsforday++;
    if (currmonth!=lastmonth) {
      fprintf(stdout,"Total for month of %s, 19%d = %d hits\n",
        months[lastmonth-1],lastyear,monthtotal);
      monthtotal=0;
      lastmonth = currmonth;
    }
    i++;
  }
  fprintf(stdout,"Total for month of %s, 19%d = %d hits\n",
    months[lastmonth-1],lastyear,monthtotal);

  fprintf(stdout,"\nTotal Hits:");
  for (j=0;j<size;j++) {
    if (docs[j].numhits <10) fprintf(stdout,"     %d ",docs[j].numhits); else
    if (docs[j].numhits <100) fprintf(stdout,"    %d ",docs[j].numhits); else
    if (docs[j].numhits <1000) fprintf(stdout,"   %d ",docs[j].numhits); else
    if (docs[j].numhits <10000) fprintf(stdout,"  %d ",docs[j].numhits); else
    if (docs[j].numhits <100000) fprintf(stdout,"  %d ",docs[j].numhits); 
  }
  fprintf(stdout,"       %d\n",NumHits);
}


/******************************************************************************
* void GenerateReport()
******************************************************************************/
void GenerateReport()
{
Hit docs[MAXDOCUMENTS];
int numdocs;

  numdocs = Popularity(docs);
  UniqueUsers();
  ChronoHits(docs,numdocs);
}


/******************************************************************************
* void main(int argc, char **argv)
******************************************************************************/
void main(int argc, char **argv)
{
Hit hit;
char input[INPUT_LINE_SIZE];
int i,gotline=FALSE;

  if (argc>1 && strcmp(argv[1],"-h")==0) Usage();
  for (i=1;i<argc;i++) {
    if (strcmp(argv[i],"-verbose")==0) verbose=atoi(argv[++i]);
    if (strcmp(argv[i],"-chrono")==0) chrono=atoi(argv[++i]);
  }
 
  while (gotline=GetNextLine(stdin,input)) {
    ParseLine(input,&hit);
    InsertList(&hit);
  }
  GenerateReport();
}