#if !defined(_STATEMENT_H_)
#define _STATEMENT_H_

#include "figures.h"
#include "graphics_context.h"
#include "expression.h"
#include "drawable_list.h"

/* STATEMENTS ARE DEFINED IN FIGURES, LIKE
 *     
 * figure huggy(A,B,...) {
 *
 *     draw circle([A,B],70);  // THIS IS A STATEMENT
 *     ...
 * }
 *
 * THEY CANNOT BE INSTANTIATED UNTIL THE FIGURE ACTUALLY
 * EXECUTES, IE A,B WILL ONLY BE KNOWN WHEN huggy IS CALLED
 *
 * A STATEMENT IS A WRAPPER FOR AN ACTUAL ACTION
 * FOR EXAMPLE:
 *
 *    draw_circle* CS = new draw_circle(ox,oy,r);
 *    // where ox,oy and r are expressions
 *
 * WHEN CS IS "EXECUTED" WITH GRAPHICS CONTEXT AND VARIABLE
 * LIST, THEN ox, oy AND r ARE EVALUATED, AND A NEW CIRCLE
 * WITH THE CURRENT SETTINGS OF GRAPHICS CONTEXT IS INSERTED
 * INTO THE DRAWABLE LIST
 *
 * IMPLEMNTING EXECUTE:
 *
 *    void draw_circle::execute(graphics_context& GC, drawable_list& L,
 *                              coordsys& S, double* B) {
 *         circle *c = new circle(S,coordinate(x->evaluate(B),y->evaluate(B)),
 *                                r->evaluate(B));
 *         // copy the settings of GC into C
 *         L.insert(c);
 *         // bingo! c is in L and x,y and r are "call time" evaluated
 *         // each time execute is called
 *    }
 *
 */
class statement {
   public:
      // S.execute(GC,L,SYS,BINDIGS)
      // where:
      //      GC     : the current graphics context
      //      L      : list of figures
      //      SYS    : current coordinate system
      //      BINDIGS: the current settings of variables
      virtual void execute(graphics_context&,drawable_list&,coordsys&,
                           double*) = 0;
};

// [red,green,blue]
class set_color: public statement {
   protected:
      expression* red;
      expression* green;
      expression* blue;

      color evaluate(double*) const;
 
   public:
      set_color(expression*,expression*,expression*);
      virtual ~set_color();
};

// set pen_color [red,green,blue]
class set_pen_color: public set_color {
   public:
      set_pen_color(expression*,expression*,expression*);
      void execute(graphics_context&,drawable_list&,coordsys&,double*);
};

// set fill_color [red,green,blue]
class set_fill_color: public set_color {
   public:
      set_fill_color(expression*,expression*,expression*);
      void execute(graphics_context&,drawable_list&,coordsys&,double*);
};

// expr
class set_single_val: public statement {
   protected:
      expression* expr;
   public:
      set_single_val(expression*);
      double evaluate(double*) const;
      virtual ~set_single_val();
};

// set filled exrp;
class set_filled: public set_single_val {
   public:
      set_filled(expression*);
      void execute(graphics_context&,drawable_list&,coordsys&,double*);
};

// set rotate expr;
class set_rotate: public set_single_val {
   public:
      set_rotate(expression*);
      void execute(graphics_context&,drawable_list&,coordsys&,double*);
};

// set center_angle expr;
class set_center_angle: public set_single_val {
   public:
      set_center_angle(expression*);
      void execute(graphics_context&,drawable_list&,coordsys&,double*);
};

// set rotation_angle expr;
class set_rotation_angle: public set_single_val {
   public:
      set_rotation_angle(expression*);
      void execute(graphics_context&,drawable_list&,coordsys&,double*);
};

// set depth expr;
class set_depth: public set_single_val {
   public:
      set_depth(expression*);
      void execute(graphics_context&,drawable_list&,coordsys&,double*);
};

// set order expr;
class set_order: public set_single_val {
   public:
      set_order(expression*);
      void execute(graphics_context&,drawable_list&,coordsys&,double*);
};

// [x,y]
class set_coordinate: public statement {
   protected:
       expression* x;
       expression* y;

       coordinate evaluate(double*) const;

   public:
       set_coordinate(expression*,expression*);
       virtual ~set_coordinate();
};

// set rotation_center [x,y];
class set_rotation_center: public set_coordinate {
   public:
       set_rotation_center(expression*,expression*);
       void execute(graphics_context&,drawable_list&,coordsys&,double*);
};

// draw_point([x,y]);
class draw_point: public set_coordinate {
   public:
       draw_point(expression*,expression*);
       void execute(graphics_context&,drawable_list&,coordsys&,double*);
};

// draw_line([x1,y1],[x2,y2]);
class draw_line: public statement {
   protected:
       expression* x1;
       expression* y1;
       expression* x2;
       expression* y2;
   public:
       draw_line(expression*,expression*,expression*,expression*);
       virtual ~draw_line();
       void execute(graphics_context&,drawable_list&,coordsys&,double*);
};

// draw circle([x,y],r);
class draw_circle: public statement {
   protected:
       expression* x;
       expression* y;
       expression* r;
   public:
       draw_circle(expression*,expression*,expression*);
       virtual ~draw_circle();
       void execute(graphics_context&,drawable_list&,coordsys&,double*);
};

// draw triangle([x1,y1],[x2,y2],[x3,y3]);
class draw_triangle: public statement {
   protected:
      expression* x1;
      expression* y1;
      expression* x2;
      expression* y2;
      expression* x3;
      expression* y3;
   public:
      draw_triangle(expression*,expression*,expression*,
                    expression*,expression*,expression*);
      virtual ~draw_triangle();
      void execute(graphics_context&,drawable_list&,coordsys&,double*);
}; 

// draw square([x,y],s);
class draw_square: public statement {
   protected:
      expression* x;
      expression* y;
      expression* s;
   public:
      draw_square(expression*,expression*,expression*);
      virtual ~draw_square();
      void execute(graphics_context&,drawable_list&,coordsys&,double*);
};

// draw rectangle([x,y],a,b]);
class draw_rectangle: public statement {
   protected:
      expression* x;
      expression* y;
      expression* a;
      expression* b;
   public:
      draw_rectangle(expression*,expression*,expression*,expression*);
      virtual ~draw_rectangle();
      void execute(graphics_context&,drawable_list&,coordsys&,double*);
};

// draw ellipse([x,y],a,b]);
class draw_ellipse: public statement {
   protected:
      expression* x;
      expression* y;
      expression* a;
      expression* b;
   public:
      draw_ellipse(expression*,expression*,expression*,expression*);
      virtual ~draw_ellipse();
      void execute(graphics_context&,drawable_list&,coordsys&,double*);
};

// print("....");
class print_statement: public statement {
   protected:
      char* str;
   public:
      print_statement(const char*);
      virtual ~print_statement();
      void execute(graphics_context&,drawable_list&,coordsys&,double*);
};

#endif