#define EXTERN
#define MAIN     1

/*--------------------------
**  include files
**--------------------------
*/
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <stdarg.h>
#include <string.h>
#include <math.h>
#include <errno.h>

#include "ir1.h"

/*--------------------------------------
** structures
**--------------------------------------
*/

/*---------------------------
** function prototypes
**---------------------------
*/
int cmd_execute( char * cmd_buf);
int do_help( char *par );
int do_quit( char *par );
int do_test( char *par );
int do_show( char *par );

/*-------------------------------------
*  Global variables
*-------------------------------------
*/

struct PARSE_TABLE
{
  char * kw;        /* The opcode string  */
  int (* pfi)();    /* pfi is pointer to function returning an integer */
  char *  desc;     /* Description of command */
};

struct PARSE_TABLE parse_table[] =
{
   { "Help",       do_help,        "Help - Lists the available commands." },
   { "Quit",       do_quit,        "Quit - Quit the application." },
   { "test",       do_test,        "test" },
   { "s",          do_show,        "s - show data" },
};

int num_parse_item = { sizeof(parse_table) / sizeof(struct PARSE_TABLE) };

int Quit;
int Verbose;

/*********** position data **********************/

struct pt_t {
   double x;
   double y;
};

#define NDATA 10

// moris data
struct pt_t M[NDATA] = {
{  75, 433 },
{  91, 229 },
{ 217, 198 },
{ 188, 399 },
{ 325, 342 },
{ 343, 412 },
{ 360,  94 },
{ 379, 253 },
{ 504,  74 },
{ 491, 228 },
};

// spex data
struct pt_t S[NDATA] = {
 {  19, 392 },
 {  31, 192 },
 { 154, 157 },
 { 128, 355 },
 { 264, 297 },
 { 283, 365 },
 { 293,  52 },
 { 315, 208 },
 { 433,  30 },
 { 425, 180 },
};

struct pt_t A[NDATA];
struct pt_t B[NDATA];
struct pt_t C[NDATA];

/*---------------------------------
** main()
**---------------------------------
*/
int main( int argc, char * argv[])
{
  char buf[80];

   /* main loop for commands */
   Quit = FALSE;

   while( !Quit )
   {
      /* Get command */
      printf("Enter Command: ");
      gets( buf );

      cmd_execute( buf );
   }

   return 0;
}

/*-------------------------------------------------------------
** cmd_execute() - Executes a command line instruction
**-------------------------------------------------------------
*/
int cmd_execute( char * cmd_buf )
{
   char copy_buf[80];
   int error,
      found,
      i;

   char * kw,
        * par;
   /*
   **  Search table for keyword
   */
   strxcpy( copy_buf, cmd_buf, sizeof(copy_buf));

   kw  = strtok(copy_buf, " ");
   if( (kw == NULL) || (*kw=='#') )
      return( ERR_NONE );

   if( (par = strtok( (char*)NULL, "")) != NULL )
      unpad( par, ' ' );

   /*
   **  Search table for keyword. If found call function.
   */
   error = ERR_INV_KW;
   for(i=0, found = FALSE; i<num_parse_item && found == FALSE; )
   {
      if( !stricmp( kw, parse_table[i].kw ) )
      {
         found = TRUE;
         error = (parse_table[i].pfi)(par);
      }
      else
         i++;
   }
   /*
   **  Provide user feedback
   */

   if( error != ERR_NONE )
   {
      printf("%s - %s\n", cmd_buf, error_string(error) );
   }

   return( error );
}

/********************************************************************
**                      COMMAND FUNCTIONS                          **
********************************************************************/

/*----------------------------------------------------------------------
**  do_help()
**----------------------------------------------------------------------
*/
int do_help( char * par )
{
   int i;

   printf("\n"
   "Test program. Summary of commands:\n\n"
   " Usage: test\n"
   " List of Commands\n");

   for( i=0; i<num_parse_item; i++)
   {
      printf("   %s\n", parse_table[i].desc);
   }
   printf("\n");
   printf("Note: * indicates interactive commands.\n");
   printf("\n");
   return ERR_NONE;
}

/*----------------------------------------------------------------------
**  do_test()
**----------------------------------------------------------------------
*/
int do_test( char * par )
{
   int i, n;
   t2d_matrix m;

   n = NDATA;

   // A = center orgin in middle of array( S )
   t2d_forward_matrix( m, -256, -256, 1, 1, 0);
   for(i=0; i<n; i++ )
      t2d_apply_to_point( &A[i].x, &A[i].y, m,  S[i].x, S[i].y);

   // B = apply spex to moris terms.
   t2d_forward_matrix( m,  61,  44, 1.01315, 1.01315, 1.2);
   for(i=0; i<n; i++ )
      t2d_apply_to_point( &B[i].x, &B[i].y, m,  A[i].x, A[i].y);

   //  C = return orgin to 0,0
   t2d_forward_matrix( m,  256,  256, 1, 1, 0);
   for(i=0; i<n; i++ )
      t2d_apply_to_point( &C[i].x, &C[i].y, m,  B[i].x, B[i].y);

   for(i=0; i<n; i++ )
      printf(" %d  %4.0f %4.0f \n", i, C[i].x, C[i].y);

   FILE * fp;
   fp = fopen( "x.txt", "w");
   for(i=0; i<n; i++ )
      fprintf( fp , " %d  %4.0f %4.0f \n", i, C[i].x, C[i].y);
   fclose( fp );


   return 0;
}

/*----------------------------------------------------------------------
**  do_show() show the data
**----------------------------------------------------------------------
*/
int do_show( char * par )
{
   int i, n;
   n = NDATA;

   printf("moris data: \n");
   for(i=0; i<n; i++ )
      printf(" %d  %4.0f %4.0f \n", i, M[i].x, M[i].y);
   printf("spex data: \n");
   for(i=0; i<n; i++ )
      printf(" %d  %4.0f %4.0f \n", i, S[i].x, S[i].y);
   return 0;
}

/*----------------------------------------------------------------------
**  do_quit() - set Quit flag to TRUE.
**----------------------------------------------------------------------
*/
int do_quit( char * par )
{
   Quit = TRUE;
   return 0;
}

/********************************************************************
**                     SUPPORTING FUNCTIONS                        **
********************************************************************/


void tf (
   double *ox, double *oy,   // O: output x,y
   double  ix, double  iy,   // I: input  x,y
   double  sx, double  sy,   // I: scale
   double  rx, double  ry,   // I: rotate, radins
   double  tx, double  ty    // I: tranpose
)
{
//                                (  sx  rx  0 )
//   (ox, oy, 1)  =  (ix, iy, 1 ) (  ry  sy  0 )
//                                (  tx  ty  1 )


}