#include <stdio.h>
#include "LogExaminer.h"
#include <clib/alib_protos.h>
#include <clib/dos_protos.h>
#include <stdlib.h>

#include <HBBS/ANSI_Codes.h>
#include <HBBS/Defines.h>
#include <HBBS/types.h>
#include <HBBS/structures.h>
#include <HBBS/hbbscommon_protos.h>
#include <HBBS/hbbscommon_pragmas.h>
#include <HBBS/Hbbsnode_protos.h>
#include <HBBS/Hbbsnode_pragmas.h>

#include <HBBS/release.h>
char *versionstr="$VER: LogExaminer "RELEASE_STR;

/* hbbs variables */
struct Library *HBBSCommonBase=NULL;
struct BBSGlobalData *BBSGlobal=NULL;

struct List *List_NodeList=NULL,*List_SelectedNodes=NULL;
BOOL UseSelectedNodes=FALSE;

static VOID cleanup(ULONG num)
{
  if (HBBSCommonBase)
  {
    HBBS_CleanUpCommon();
    CloseLibrary (HBBSCommonBase);
  }

  if (num) printf("Door Error = %d\n",num);

  exit(0);
}

static VOID init(char *name)
{
  if(!(HBBSCommonBase = OpenLibrary("HBBSCommon.library",0)))
  {
    cleanup(1);
  }

  if (!(HBBS_InitCommon()))
  {
    cleanup(2);
  }

  if (!(BBSGlobal=HBBS_GimmeBBS()))
  {
    cleanup(5);
  }
  SetProgramName(name);
}

BOOL CheckRequired( void )
{
  BOOL AllOK=TRUE;

  if (strlen(((struct StringInfo *)(MainWinGadgets[MainWin_Handle]->SpecialInfo))->Buffer)==0)
  {
    AllOK=FALSE;
  }

  if ((UseSelectedNodes) && (HBBS_NodesInList(List_SelectedNodes)==0))
  {
    AllOK=FALSE;
  }

  if (AllOK)
  {
    GT_SetGadgetAttrs(MainWinGadgets[MainWin_GO],MainWin,NULL,GA_Disabled,FALSE,TAG_DONE);
  }
  else
  {
    GT_SetGadgetAttrs(MainWinGadgets[MainWin_GO],MainWin,NULL,GA_Disabled,TRUE,TAG_DONE);
  }
  return(AllOK);
}

void InitGadgets( void )
{
  GT_SetGadgetAttrs(MainWinGadgets[MainWin_SelectedNodes],MainWin,NULL,GTLV_Labels,NULL,GA_Disabled,TRUE,TAG_DONE);
  GT_SetGadgetAttrs(MainWinGadgets[MainWin_NodeList],MainWin,NULL,GTLV_Labels,NULL,GA_Disabled,TRUE,TAG_DONE);
}

BOOL InitLists( void )
{
  if ((List_NodeList=HBBS_CreateList()) && (List_SelectedNodes=HBBS_CreateList())) return(TRUE); else return(FALSE);
}

void FreeLists( void )
{
  FreeStrList(List_NodeList);
  FreeStrList(List_SelectedNodes);
}

BOOL GetHBBSInfo( void )
{
  BOOL AllOK=FALSE;
  short loop;
  char tmpstr[20];
  struct Node *NewNode;

  for (loop=0;loop<BBSGlobal->BBSNodes;loop++)
  {
    sprintf(tmpstr,"Node %d",loop);
    if (NewNode=HBBS_CreateNode(tmpstr,0))
    {
      NewNode->ln_Pri=0-loop;
      AddTail(List_NodeList,NewNode);
    }
  }

  if (HBBS_NodesInList(List_NodeList)) AllOK=TRUE;

  return(AllOK);
}


void GenerateReport( void )
{
  FILE *logfile;
  short CurrentNode=0,fn=0;
  struct Node *SelectedNode;
  BOOL Done=FALSE;

  do
  {
    if (UseSelectedNodes)
    {
      SelectedNode=GetNode(List_SelectedNodes,fn);
      CurrentNode=0-SelectedNode->ln_Pri;
      fn++;
    }

    // do stuff
    printf("current node = %d\n",CurrentNode);

    if (UseSelectedNodes)
    {
      if (fn>=HBBS_NodesInList(List_SelectedNodes)) Done=TRUE;
    }
    else
    {
      CurrentNode++;
      if (CurrentNode>=BBSGlobal->BBSNodes) Done=TRUE;
    }
  } while (!Done);

}

void ProcessWindowMainWin( LONG Class, UWORD Code, APTR IAddress)
{
  struct Gadget *gad;
  struct Node *SelectedNode;

  switch ( Class )
  {
    case IDCMP_GADGETDOWN :
      /* Gadget message, gadget = gad. */
      gad = (struct Gadget *)IAddress;
      switch ( gad->GadgetID )
        {
        case MainWin_Handle :
          /* String entered   , Text of gadget : Handle */
          CheckRequired();
          break;
        case MainWin_Nodes :
          /* MX changed       , Text of gadget :  */

          switch(Code)
          {
            case 1:
              GT_SetGadgetAttrs(MainWinGadgets[MainWin_SelectedNodes],MainWin,NULL,GTLV_Labels,List_SelectedNodes,GA_Disabled,FALSE,TAG_DONE);
              GT_SetGadgetAttrs(MainWinGadgets[MainWin_NodeList],MainWin,NULL,GTLV_Labels,List_NodeList,GA_Disabled,FALSE,TAG_DONE);
              UseSelectedNodes=TRUE;
              break;
            default:
              InitGadgets();
              UseSelectedNodes=FALSE;
              break;
          }
          CheckRequired();
          break;
        case MainWin_When :
          /* MX changed       , Text of gadget :  */
          switch(Code)
          {
            case 1:
              GT_SetGadgetAttrs(MainWinGadgets[MainWin_Days],MainWin,NULL,GA_Disabled,FALSE,TAG_DONE);
              break;
            default:
              GT_SetGadgetAttrs(MainWinGadgets[MainWin_Days],MainWin,NULL,GA_Disabled,TRUE,TAG_DONE);
              break;
          }
          break;
        case MainWin_Days :
          /* Slider changed   , Text of gadget :  */
          break;
        }
      break;
    case IDCMP_GADGETUP :
      /* Gadget message, gadget = gad. */
      gad = (struct Gadget *)IAddress;
      switch ( gad->GadgetID )
      {
        case MainWin_Handle :
          /* String entered  , Text of gadget : Handle */
          CheckRequired();
          break;
        case MainWin_NodeList :
          /* ListView pressed, Text of gadget : Unselected */
          SelectedNode=GetNode(List_NodeList,Code);
          Remove(SelectedNode);
          Enqueue(List_SelectedNodes,SelectedNode);
          GT_SetGadgetAttrs(MainWinGadgets[MainWin_SelectedNodes],MainWin,NULL,GTLV_Labels,List_SelectedNodes,GA_Disabled,FALSE,TAG_DONE);
          GT_SetGadgetAttrs(MainWinGadgets[MainWin_NodeList],MainWin,NULL,GTLV_Labels,List_NodeList,GA_Disabled,FALSE,TAG_DONE);
          CheckRequired();
          break;
        case MainWin_SelectedNodes :
          /* ListView pressed, Text of gadget : Selected */
          SelectedNode=GetNode(List_SelectedNodes,Code);
          Remove(SelectedNode);
          Enqueue(List_NodeList,SelectedNode);
          GT_SetGadgetAttrs(MainWinGadgets[MainWin_SelectedNodes],MainWin,NULL,GTLV_Labels,List_SelectedNodes,GA_Disabled,FALSE,TAG_DONE);
          GT_SetGadgetAttrs(MainWinGadgets[MainWin_NodeList],MainWin,NULL,GTLV_Labels,List_NodeList,GA_Disabled,FALSE,TAG_DONE);
          CheckRequired();
          break;
        case MainWin_Days :
                /* Slider changed  , Text of gadget :  */
                break;
        case MainWin_GO :
          /* Button pressed  , Text of gadget : Start Searching */
          if (CheckRequired())
          {
            GenerateReport();
          }
          break;
      }
      break;
    case IDCMP_CLOSEWINDOW :
      /* CloseWindow Now */
      break;
    case IDCMP_REFRESHWINDOW :
      GT_BeginRefresh( MainWin);
      /* Refresh window. */
      RendWindowMainWin( MainWin, MainWinVisualInfo );
      GT_EndRefresh( MainWin, TRUE);
      GT_RefreshWindow( MainWin, NULL);
      RefreshGList( MainWinGList, MainWin, NULL, ~0);
      break;
  }
}

int main(void)
{
  int done=0;
  ULONG class;
  UWORD code;
  struct Gadget *pgsel;
  struct IntuiMessage *imsg;
  struct Screen *Scr;

  init("LogExaminer");
  if (InitLists())
  {
    if (GetHBBSInfo())
    {
      OpenDiskFonts();
      if (Scr=LockPubScreen("Workbench"))
      {
        if (OpenWindowMainWin(Scr)==0)
        {
          UnlockPubScreen(NULL,Scr);
          InitGadgets();
          while(done==0)
          {
            Wait(1L << MainWin->UserPort->mp_SigBit);
            imsg=GT_GetIMsg(MainWin->UserPort);
            while (imsg != NULL )
            {
              class=imsg->Class;
              code=imsg->Code;
              pgsel=(struct Gadget *)imsg->IAddress; /* Only reference if it is a gadget message */
              GT_ReplyIMsg(imsg);
              ProcessWindowMainWin(class, code, pgsel);
              /* The next line is just so you can quit, remove when proper method implemented. */
              if (class==IDCMP_CLOSEWINDOW)
                      done=1;
              imsg=GT_GetIMsg(MainWin->UserPort);
            }
          }
          CloseWindowMainWin();
        }
        else
        {
          UnlockPubScreen(NULL,Scr);
          printf("Cannot open window.\n");
        }
      }
    }
  }
  FreeLists();
  cleanup(0);
}