/* main.c - Don Yang (uguu.org)

   07/15/01
                                                                           */

#include<ctype.h>
#include<stdio.h>
#include<stdlib.h>
#include<time.h>
#include"dt.h"
#include"grid.h"
#include"maze.h"
#include"ps.h"
#include"triangle.h"

#ifdef USE_OPENGL
   #ifdef _WIN32
      #include<windows.h>
   #endif
   #include<GL/gl.h>
   #include<GL/glu.h>
   #include<GL/glut.h>
   #include"g.h"
#endif


/* Grid data */
static Grid VertexGrid;
static Triangle *TriangleList;
static Vertex *VertexList;
static FILE *Output, *SolOutput;
#ifdef USE_OPENGL
   static int OutputGL;
#endif

/* Local functions */
static int ProcessOptions(int argc, char **argv);

/******************************************************************** main */
int main(int argc, char **argv)
{
   srand((unsigned)time(NULL));
   TriangleList = NULL;
   VertexList = NULL;

   if( ProcessOptions(argc, argv) )
      return 1;

   if( Triangulate(&TriangleList, &VertexList, &VertexGrid) )  /* (dt.c) */
   {
      fputs("Not enough memory\n", stderr);
   }
   else
   {
      /* Link neighbors */
      if( CreateMaze(TriangleList) )                  /* (maze.c) */
      {
         fputs("Error creating maze\n", stderr);
      }
      else
      {
#ifdef USE_OPENGL
         if( OutputGL )
         {
            glutInit(&argc, argv);
            RenderGL(&TriangleList, &VertexList, &VertexGrid); /* (g.c) */
            /* note that GL renderer does not return! */
         }
#endif
         if( SolOutput )
         {
            RenderPS(TriangleList, VertexList, Output);  /* (ps.c) */
            RenderPSComplete(TriangleList, VertexList, SolOutput);
         }
         else
         {
            RenderPSComplete(TriangleList, VertexList, Output);
         }
      }
   }

   DeleteTriangleList(&TriangleList);     /* (triangle.c) */
   DeleteVertexList(&VertexList);         /* (triangle.c) */
   if( Output != NULL && Output != stdout )
      fclose(Output);
   if( SolOutput != NULL )
      fclose(SolOutput);
   return 0;

} /* main() */

/********************************************************** ProcessOptions */
static int ProcessOptions(int argc, char **argv)
{
   int i, x, y;

   /* Default page = 8.5in x 11in, 72dpi = 612 x 792
      Grid size below uses one inch margin            */
   VertexGrid.minx = 72;     VertexGrid.maxx = 540;
   VertexGrid.miny = 72;     VertexGrid.maxy = 720;

   Output = stdout;
   SolOutput = NULL;
#ifdef USE_OPENGL
   OutputGL = 0;
#endif

   if( argc < 2 )
   {
      printf(
         "serio 1.0 (7/15/01) - Don Yang (uguu.org)\n\n"
         "No options specified.  Try %s -h for help\n", *argv);
      return 1;
   }

   /* Scan command line for dimension / output flags */
   for(i = 1; i < argc; i++)
   {
      switch( tolower(argv[i][1]) )
      {
         case 'x':
            if( i + 1 >= argc )
               return printf("Not enough arguments\n");
            if( i + 2 < argc && argv[i + 2][0] != '-' )
            {
               sscanf(argv[++i], "%lf", &VertexGrid.minx);
               sscanf(argv[++i], "%lf", &VertexGrid.maxx);
            }
            else
            {
               sscanf(argv[++i], "%lf", &VertexGrid.maxx);
               VertexGrid.minx = 72;
               VertexGrid.maxx += 72;
            }
            break;
         case 'y':
            if( i + 1 >= argc )
               return printf("Not enough arguments\n");
            if( i + 2 < argc && argv[i + 2][0] != '-' )
            {
               sscanf(argv[++i], "%lf", &VertexGrid.miny);
               sscanf(argv[++i], "%lf", &VertexGrid.maxy);
            }
            else
            {
               sscanf(argv[++i], "%lf", &VertexGrid.maxy);
               VertexGrid.miny = 72;
               VertexGrid.maxy += 72;
            }
            break;
         case 'd':
            if( i + 1 >= argc )
               return printf("Not enough arguments\n");
            srand(atoi(argv[++i]));
            break;
         case 'o':
            if( i + 1 >= argc )
               return printf("Not enough arguments\n");
            if( (Output = fopen(argv[++i], "wt+")) == NULL )
               return printf("Can not create %s\n", argv[i]);

            if( (i + 1 < argc) && argv[i + 1][0] != '-' )
            {
               if( (SolOutput = fopen(argv[++i], "wt+")) == NULL )
                  return printf("Can not create %s\n", argv[i]);
            }
            break;
         case 'i':
         case 'r':
            if( i + 1 >= argc )
               return printf("Not enough arguments\n");
            i++;
            break;
#ifdef USE_OPENGL
         case 'g':
            if( Output != NULL && Output != stdout )
               fclose(Output);
            if( SolOutput != NULL )
               fclose(SolOutput);
            OutputGL = 1;
            break;
#endif
         case 'b':
         case 'c':
         case 's':
         case 't':
         case 'u':
            if( i + 2 >= argc )
               return printf("Not enough arguments\n");
            i += 2;
            break;
         default:
            puts(
               "serio 1.0 (7/15/01) - Don Yang (http://omoikane.cjb.net)\n\n"
               "Options:\n"
               "-x <minx> <maxx>    set x range (default is 72 540)\n"
               "-y <miny> <maxy>    set y range (default is 72 720)\n"
               "-d <seed>           seed random number generator with <seed>\n"
               "                    (default is to use time)\n");
#ifdef USE_OPENGL
            puts("-g                  render to glut window");
#endif
            puts(
               "-o <output> [sol]   set output files (default is stdout)\n"
               "                    if [sol] is anything not starting with\n"
               "                    '-', solution path will be written to\n"
               "                    that file.\n");
            puts(
               "-i <file>           add points listed in <file>\n"
               "-u <column> <row>   add uniform rectangular grid points\n"
               "-t <column> <row>   add uniform triangular grid points\n"
               "-b <column> <row>   add blob grid points\n"
               "-c <ring> <div>     add circular grid points\n"
               "-s <spoke> <step>   add spiral grid points\n"
               "-r <count>          add <count> random points\n");
            return 1;
      }
   }

   /* Scan command line to add points */
   for(i = 1; i < argc; i++)
   {
      switch( tolower(argv[i][1]) )
      {
         case 'x':
         case 'y':
         case 'o':
            i++;
            if( i + 1 < argc && argv[i + 1][0] != '-' )
               i++;
            break;
         case 'd':
            i++;
            break;
         case 'b':
            x = atoi(argv[++i]);
            y = atoi(argv[++i]);
            if( BlobGrid(&VertexList, &VertexGrid, x, y) )
               fputs("BlobGrid() failed\n", stderr);
            break;
         case 'c':
            x = atoi(argv[++i]);
            y = atoi(argv[++i]);
            if( CircularGrid(&VertexList, &VertexGrid, x, y) )
               fputs("CircularGrid() failed\n", stderr);
            break;
         case 'i':
            if( FileGrid(&VertexList, &VertexGrid, argv[++i]) )
               fprintf(stderr, "LoadGrid(\"%s\") failed\n", argv[i]);
            break;
         case 'r':
            if( RandomGrid(&VertexList, &VertexGrid, atoi(argv[++i])) )
               fputs("RandomGrid() failed\n", stderr);
            break;
         case 's':
            x = atoi(argv[++i]);
            y = atoi(argv[++i]);
            if( SpiralGrid(&VertexList, &VertexGrid, x, y) )
               fputs("SpiralGrid() failed\n", stderr);
            break;
         case 't':
            x = atoi(argv[++i]);
            y = atoi(argv[++i]);
            if( TriangleGrid(&VertexList, &VertexGrid, x, y) )
               fputs("TriangleGrid() failed\n", stderr);
            break;
         case 'u':
            x = atoi(argv[++i]);
            y = atoi(argv[++i]);
            if( UniformGrid(&VertexList, &VertexGrid, x, y) )
               fputs("UniformGrid() failed\n", stderr);
            break;
         default:
            break;
      }
   }
   return 0;

} /* ProcessOptions() */