#include "statement.h"
#include "conditional.h"
#include <string.h>
#include <iostream.h>

// SEE STATEMENT.H, CONDITIONAL.H
// 

conditional::conditional(expression* e):condition(e) {
}

void conditional::add_statement(statement* s) {
   statements.insert(s);
}

void conditional::add_else_statement(statement* s) {
   else_statements.insert(s);
}

void conditional::execute(graphics_context& GC, drawable_list& L, coordsys& S,
   double* B) {
   list_iterator<statement*> I = condition->evaluate(B) > 0 ?
                                 statements.first() : else_statements.first();

   while(I.has_more_elements()) {
      (*I)->execute(GC,L,S,B);
      I++;
   }
}

conditional::~conditional() {
   delete condition;
}

set_color::set_color(expression* r, expression* g, expression* b):
   red(r),green(g),blue(b) {
}

color set_color::evaluate(double* B) const {
   return color((short int)red->evaluate(B),
                (short int)green->evaluate(B),
                (short int)blue->evaluate(B));
}

set_color::~set_color() {
   delete red;
   delete green;
   delete blue;
}

set_pen_color::set_pen_color(expression* r, expression* g, expression* b):
   set_color(r,g,b) {
}

void set_pen_color::execute(graphics_context& GC, drawable_list&, coordsys&,
   double* B) {
   GC.pen_color = evaluate(B); 
}

set_fill_color::set_fill_color(expression* r, expression* g, expression* b):
   set_color(r,g,b) {
}

void set_fill_color::execute(graphics_context& GC, drawable_list&, coordsys&,
   double* B) {
   GC.fill_color = evaluate(B); 
}

set_single_val::set_single_val(expression* e):expr(e) {
}

double set_single_val::evaluate(double* B) const {
   return expr->evaluate(B);
}

set_single_val::~set_single_val() {
   delete expr;
}


set_filled::set_filled(expression* e):set_single_val(e) {
}

void set_filled::execute(graphics_context& GC, drawable_list&, coordsys&,
   double* B) {
   GC.filled = evaluate(B) > 0;
}

set_rotate::set_rotate(expression* e):set_single_val(e) {
}

void set_rotate::execute(graphics_context& GC, drawable_list&, coordsys&,
   double* B) {
   GC.rotate = evaluate(B) > 0;
}

set_center_angle::set_center_angle(expression* e):set_single_val(e) {
}

void set_center_angle::execute(graphics_context& GC, drawable_list&, coordsys&,
   double* B) {
   GC.center_angle = evaluate(B);
}

set_rotation_angle::set_rotation_angle(expression* e):set_single_val(e) {
}

void set_rotation_angle::execute(graphics_context& GC, drawable_list&, 
   coordsys&,
   double* B) {
   GC.rotation_angle = evaluate(B);
}

set_depth::set_depth(expression* e):set_single_val(e) {
}

void set_depth::execute(graphics_context& GC, drawable_list&, coordsys&,
   double* B) {
   GC.depth = (int)evaluate(B);
}

set_order::set_order(expression* e):set_single_val(e) {
}

void set_order::execute(graphics_context& GC, drawable_list&, coordsys&,
   double* B) {
   GC.order = (int)evaluate(B);
}

set_coordinate::set_coordinate(expression* _x, expression* _y): x(_x),y(_y) {
}

set_coordinate::~set_coordinate() {
   delete x;
   delete y;
}

coordinate set_coordinate::evaluate(double* B) const {
   return coordinate(x->evaluate(B),y->evaluate(B));
}

set_rotation_center::set_rotation_center(expression* _x, expression* _y):
   set_coordinate(_x,_y) {
}

void set_rotation_center::execute(graphics_context& GC, drawable_list&,
   coordsys&, double* B) {
   GC.rotation_center = evaluate(B);
}

draw_point::draw_point(expression* _x, expression* _y):
   set_coordinate(_x,_y) {
}

void draw_point::execute(graphics_context& GC, drawable_list& L, coordsys& S,
   double* B) {
   point *p = new point(S,evaluate(B));
   p->set_pen_color(GC.pen_color);
   p->set_rotate(GC.rotate);
   p->set_rotation_center(GC.rotation_center);
   p->set_rotation_angle(GC.rotation_angle);
   p->set_depth(GC.depth);
   p->set_order(GC.order);
   L.insert(p);
}

draw_line::draw_line(expression* _x1, expression* _y1, 
   expression* _x2 ,expression* _y2):x1(_x1),y1(_y1),x2(_x2),y2(_y2) {
}

draw_line::~draw_line() {
   delete x1;
   delete y1;
   delete x2;
   delete y2;
}

void draw_line::execute(graphics_context& GC, drawable_list& L, coordsys& S,
   double* B) {
   line *l = new line(S,coordinate(x1->evaluate(B),y1->evaluate(B)),
          coordinate(x2->evaluate(B),y2->evaluate(B)));
   l->set_pen_color(GC.pen_color);
   l->set_rotate(GC.rotate);
   l->set_rotation_center(GC.rotation_center);
   l->set_rotation_angle(GC.rotation_angle);
   l->set_depth(GC.depth);
   l->set_order(GC.order);
   L.insert(l);
}

draw_circle::draw_circle(expression* _x, expression* _y, expression* _r):
   x(_x),y(_y),r(_r) {
}

draw_circle::~draw_circle() {
   delete x;
   delete y;
   delete r;
}

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));
   c->set_pen_color(GC.pen_color);
   c->set_rotate(GC.rotate);
   c->set_rotation_center(GC.rotation_center);
   c->set_rotation_angle(GC.rotation_angle);
   c->set_depth(GC.depth);
   c->set_order(GC.order);
   c->set_fill_color(GC.fill_color);
   c->set_filled(GC.filled);
   c->set_center_angle(GC.center_angle);
   L.insert(c);
}

draw_triangle::draw_triangle(expression* _x1, expression* _y1,
   expression* _x2, expression* _y2, expression* _x3, expression* _y3):
   x1(_x1),y1(_y1),x2(_x2),y2(_y2),x3(_x3),y3(_y3) {
}

draw_triangle::~draw_triangle() {
   delete x1;
   delete y1;
   delete x2;
   delete y2;
   delete x3;
   delete y3;
}

void draw_triangle::execute(graphics_context& GC, drawable_list& L,
   coordsys& S, double* B) {
   triangle * t = new triangle(S,coordinate(x1->evaluate(B),y1->evaluate(B)),
              coordinate(x2->evaluate(B),y2->evaluate(B)),
              coordinate(x3->evaluate(B),y3->evaluate(B)));
   t->set_pen_color(GC.pen_color);
   t->set_rotate(GC.rotate);
   t->set_rotation_center(GC.rotation_center);
   t->set_rotation_angle(GC.rotation_angle);
   t->set_depth(GC.depth);
   t->set_order(GC.order);
   t->set_fill_color(GC.fill_color);
   t->set_filled(GC.filled);
   t->set_center_angle(GC.center_angle);
   L.insert(t);
}

draw_square::draw_square(expression* _x, expression* _y, expression* _s):
   x(_x),y(_y),s(_s) {
}

draw_square::~draw_square() {
   delete x;
   delete y;
   delete s;
}

void draw_square::execute(graphics_context& GC, drawable_list& L, 
   coordsys& S, double* B) {
   square *sq =new square(S,coordinate(x->evaluate(B),y->evaluate(B)),
            s->evaluate(B));
   sq->set_pen_color(GC.pen_color);
   sq->set_rotate(GC.rotate);
   sq->set_rotation_center(GC.rotation_center);
   sq->set_rotation_angle(GC.rotation_angle);
   sq->set_depth(GC.depth);
   sq->set_order(GC.order);
   sq->set_fill_color(GC.fill_color);
   sq->set_filled(GC.filled);
   sq->set_center_angle(GC.center_angle);
   L.insert(sq);
}

draw_rectangle::draw_rectangle(expression* _x, expression* _y,
   expression* _a, expression* _b):x(_x),y(_y),a(_a),b(_b) {
} 

draw_rectangle::~draw_rectangle() {
   delete x;
   delete y;
   delete a;
   delete b;
}

void draw_rectangle::execute(graphics_context& GC, drawable_list& L,
   coordsys& S, double* B) {
   rectangle *r = new rectangle(S,coordinate(x->evaluate(B),y->evaluate(B)),
               a->evaluate(B),b->evaluate(B));
   r->set_pen_color(GC.pen_color);
   r->set_rotate(GC.rotate);
   r->set_rotation_center(GC.rotation_center);
   r->set_rotation_angle(GC.rotation_angle);
   r->set_depth(GC.depth);
   r->set_order(GC.order);
   r->set_fill_color(GC.fill_color);
   r->set_filled(GC.filled);
   r->set_center_angle(GC.center_angle);
   L.insert(r);
}

draw_ellipse::draw_ellipse(expression* _x, expression* _y,
   expression* _a, expression* _b):x(_x),y(_y),a(_a),b(_b) {
}   

draw_ellipse::~draw_ellipse() {
   delete x;
   delete y;
   delete a;
   delete b;
}

void draw_ellipse::execute(graphics_context& GC, drawable_list& L,
   coordsys& S, double* B) {
   ellipse * e = new ellipse(S,coordinate(x->evaluate(B),y->evaluate(B)),
               a->evaluate(B),b->evaluate(B));
   e->set_pen_color(GC.pen_color);
   e->set_rotate(GC.rotate);
   e->set_rotation_center(GC.rotation_center);
   e->set_rotation_angle(GC.rotation_angle);
   e->set_depth(GC.depth);
   e->set_order(GC.order);
   e->set_fill_color(GC.fill_color);
   e->set_filled(GC.filled);
   e->set_center_angle(GC.center_angle);
   L.insert(e);
}

print_statement::print_statement(const char* s):str(new char[strlen(s)+1]) {
   strcpy(str,s);
}

print_statement::~print_statement() {
   delete [] str;
}

void print_statement::execute(graphics_context&,drawable_list&,coordsys&,
   double*) {
   cout << str;
   cout.flush();
}