#include "game_object.h"
#include "animation_block.h"
#include "indent.h"
#include "gpl_assert.h"
#include "error.h"
#include <algorithm>
using namespace std;

// all game objects that have been created but not deleted
// used for (1) error checking via valid() (2) drawing all game objects
/* static */ vector<Game_object *> Game_object::all_game_objects;

// all game objects that have been deleted
// used for error checking via has_been_deleted()
/* static */ vector<Game_object *> Game_object::deleted_game_objects;

/* static */ bool Game_object::graphics_dirty = true;

void
Game_object::insert_into_all_game_objects_vector()
{
    // all_game_objects is a vector sorted by drawing_order
    // Sorted small to large (small drawing_order drawn first/on bottom)

    // find the first iter w/a larger or equal m_drawing_order compared to this
    vector<Game_object *>::iterator iter = all_game_objects.begin();
    while (iter != all_game_objects.end() 
           && (*iter)->m_drawing_order < m_drawing_order)
           iter++;
    
    // this object has a larger drawing_order than any object in vector
    if (iter == all_game_objects.end())
        all_game_objects.push_back(this);
    // the game object pointed to by iter is the first one in the vector
    // that has a drawing order larger or equal to this
    // insert before this object
    else all_game_objects.insert(iter,this);

}

// call when the drawing_order for a Game_object changes
// removes the object from the all_game_objects vector and
// inserts it in the correct position
void 
Game_object::update_order_in_game_objects_vector()
{
    // remove this from all_game_objects
    vector<Game_object *>::iterator iter = 
            find(all_game_objects.begin(), all_game_objects.end(), this);
    assert(iter != all_game_objects.end());
    all_game_objects.erase(iter);

    // now put it back -- it will go in the correct place this time
    insert_into_all_game_objects_vector();
}

/* static */ bool 
Game_object::graphics_out_of_date_with_last_rendering()
{
    bool result = graphics_dirty;
    graphics_dirty = false;
    return result;
}

/* static */ void 
Game_object::animate_all_game_objects()
{
    vector<Game_object *>::iterator iter;
    for (iter = all_game_objects.begin(); 
         iter != all_game_objects.end(); 
         iter++)
    {
        Game_object *cur = *iter;
        if (cur->m_should_animate)
            cur->animate();
    }
}

/* static */ void 
Game_object::draw_all_game_objects()
{
    vector<Game_object *>::iterator iter;
    for (iter = all_game_objects.begin(); 
         iter != all_game_objects.end(); 
         iter++)
    {
        if ((*iter)->m_should_draw)
            (*iter)->draw();
    }
}

Game_object::Game_object(double red /* =  0.5 */,
                         double green /* = 0.5 */,
                         double blue /* =  0.5 */
                        )
{
    m_x = 0;
    m_y = 0;
    m_w = 10;
    m_h = 10;
    m_red = red;
    m_green = green;
    m_blue = blue;
    m_animation_block = 0;
    m_visible = 1;
    m_proximity = 4;
    m_drawing_order = 0;
    m_user_int = 0;
    m_user_double = 0.0;
    m_user_string = "";
    m_user_int2 = 0;
    m_user_double2 = 0.0;
    m_user_string2 = "";
    m_user_int3 = 0;
    m_user_double3 = 0.0;
    m_user_string3 = "";
    m_user_int4 = 0;
    m_user_double4 = 0.0;
    m_user_string4 = "";
    m_user_int5 = 0;
    m_user_double5 = 0.0;
    m_user_string5 = "";

    // OpenGL is not initialized enough yet to create our
    // display list.  Use a unique number so that draw()
    // will know it is the first time it is called.
    m_display_list = 0;
    m_display_list_dirty = true;

    // objects that are place holders for parameters to animation_blocks
    // should never be drawn or animated (they are not "real" objects)
    // the functions never_draw() and never_animate() reset these
    // however, all others objects should be drawn and animated
    m_should_draw = true;
    m_should_animate = true;

    // Set my type name
    // --> must be done by all that inherit me
        m_object_type_name = "Game_object"; 

    // register my variable that can be set/get from parser
    // --> each object that inherits me that wants to have any of 
    // --> its member variables settable, must do the same for each
    register_member_variable("x", &m_x);
    register_member_variable("y", &m_y);
    register_member_variable("w", &m_w);
    register_member_variable("h", &m_h);
    register_member_variable("red", &m_red);
    register_member_variable("green", &m_green);
    register_member_variable("blue", &m_blue);
    register_member_variable("animation_block", &m_animation_block);
    register_member_variable("visible", &m_visible);
    register_member_variable("proximity", &m_proximity);
    register_member_variable("drawing_order", &m_drawing_order);
    register_member_variable("user_int", &m_user_int);
    register_member_variable("user_double", &m_user_double);
    register_member_variable("user_string", &m_user_string);
    register_member_variable("user_int2", &m_user_int2);
    register_member_variable("user_double2", &m_user_double2);
    register_member_variable("user_string2", &m_user_string2);
    register_member_variable("user_int3", &m_user_int3);
    register_member_variable("user_double3", &m_user_double3);
    register_member_variable("user_string3", &m_user_string3);
    register_member_variable("user_int4", &m_user_int4);
    register_member_variable("user_double4", &m_user_double4);
    register_member_variable("user_string4", &m_user_string4);
    register_member_variable("user_int5", &m_user_int5);
    register_member_variable("user_double5", &m_user_double5);
    register_member_variable("user_string5", &m_user_string5);

    insert_into_all_game_objects_vector();
}


Game_object::~Game_object()
{

    vector<Game_object *>::iterator iter = 
            find(all_game_objects.begin(), all_game_objects.end(), this);
    assert(iter != all_game_objects.end());

    deleted_game_objects.push_back(*iter);

    all_game_objects.erase(iter);
}

void 
Game_object::draw()
{
    if (!m_visible)
            return;
    if (m_display_list_dirty)
    {
        if (m_display_list == 0)
            m_display_list = glGenLists(1);

        build_display_list();
        m_display_list_dirty = false;
    }
    //   it might be more efficient to move the translation for m_x and m_y
    //   out of the display list
    //   a) if most objects move, it will probably be faster to take it out of
    //      the display list
    //   b) if most objects don't move, it will be faster to leave it in
    //   unclear if there is an efficiency problem...

    glCallList(m_display_list);
}

Status 
Game_object::get_member_variable_type(string name, Gpl_type &type)
{
    Typed_void_ptr* typed_void_ptr = lookup_registered_member_variable(name);

    if (typed_void_ptr)
    {
        type = typed_void_ptr->m_type;
        return OK;
    }
    else 
    {
        return MEMBER_NOT_DECLARED;
    }
}

Status 
Game_object::set_member_variable(string name, int value)
{
    graphics_dirty = true;
    Typed_void_ptr *variable = lookup_registered_member_variable(name);
    if (!variable)
            return MEMBER_NOT_DECLARED;
    if (variable->m_type != INT)
        return MEMBER_NOT_OF_GIVEN_TYPE;
    assert(variable->m_value);


    if (variable->m_derived)
        Error::error(Error::CANNOT_CHANGE_DERIVED_ATTRIBUTE, 
                     name, m_object_type_name);
    
    else *((int *) variable->m_value) = value;

    // when drawing_order is changed, need to update the drawing order 
    if (name == "drawing_order")
        update_order_in_game_objects_vector();

    updated(name);
    return OK;
}

Status 
Game_object::set_member_variable(string name, double value)
{
    graphics_dirty = true;
    Typed_void_ptr *variable = lookup_registered_member_variable(name);
    if (!variable)
            return MEMBER_NOT_DECLARED;
    if (variable->m_type != DOUBLE)
        return MEMBER_NOT_OF_GIVEN_TYPE;

    assert(variable->m_value);

    *((double *) variable->m_value) = value;

    updated(name);
    return OK;
}

Status 
Game_object::set_member_variable(string name, string value)
{
    graphics_dirty = true;
    Typed_void_ptr *variable = lookup_registered_member_variable(name);
    if (!variable)
            return MEMBER_NOT_DECLARED;
    if (variable->m_type != STRING)
        return MEMBER_NOT_OF_GIVEN_TYPE;

    assert(variable->m_value);

    *((string *) variable->m_value) = value;
    updated(name);
        
    return OK;
}

Status 
Game_object::set_member_variable(string name, Animation_block *value)
{
    graphics_dirty = true;
    Typed_void_ptr *variable = lookup_registered_member_variable(name);
    if (!variable)
        return MEMBER_NOT_DECLARED;
    if (variable->m_type != ANIMATION_BLOCK)
        return MEMBER_NOT_OF_GIVEN_TYPE;

    assert(variable->m_value);

    // note, we don't dereference m_value as above because
    // we store Animation_blocks as pointers
    *((Animation_block **) variable->m_value) = value;

    updated(name);
    return OK;
}

Status 
Game_object::get_member_variable(string name, int &value)
{
    Typed_void_ptr *variable = lookup_registered_member_variable(name);
    if (!variable)
        return MEMBER_NOT_DECLARED;
    if (variable->m_type != INT)
        return MEMBER_NOT_OF_GIVEN_TYPE;

    value = *((int *) variable->m_value);
    return OK;
} 

Status 
Game_object::get_member_variable(string name, double &value)
{
    Typed_void_ptr *variable = lookup_registered_member_variable(name);
    if (!variable)
        return MEMBER_NOT_DECLARED;

    if (variable->m_type == DOUBLE)
    {
        value = *((double *) variable->m_value);
        return OK;
    }
    else return MEMBER_NOT_OF_GIVEN_TYPE;
} 

Status 
Game_object::get_member_variable(string name, string &value)
{
    Typed_void_ptr *variable = lookup_registered_member_variable(name);
    if (!variable)
        return MEMBER_NOT_DECLARED;
    if (variable->m_type != STRING)
        return MEMBER_NOT_OF_GIVEN_TYPE;

    value = *((string *) variable->m_value);
    return OK;
} 

Status 
Game_object::get_member_variable(string name, Animation_block *&value)
{
    Typed_void_ptr *variable = lookup_registered_member_variable(name);
    if (!variable)
        return MEMBER_NOT_DECLARED;
    if (variable->m_type != ANIMATION_BLOCK)
        return MEMBER_NOT_OF_GIVEN_TYPE;

    // note, we don't dereference m_value as above because
    // we store Animation_blocks as pointers
    value = *((Animation_block **) variable->m_value);
    return OK;
}


static bool
overlap(int ax1, int ay1, int ax2, int ay2,
        int bx1, int by1, int bx2, int by2)
{
    return !(ax2 < bx1 || ax1 > bx2 || ay1 > by2 || ay2 < by1);
}

// since gpl does not have a bool, touches() and near() return an int to reduce
// confusion between ints and bools
int
Game_object::touches(Game_object *obj)
{

/*****
LIMITATION

touches uses the bounding box of the object which is created at object
construction.

The bounding box is not a very good representation of triangles or circles.
And it does not take into account the rotation of either triangles
or rectangles.  

It would make the touches mechanism better if objects were represented 
with a more accurate boundary.

Idea 1:  use a polygon to represent the bounding boxes.  Each type of 
object could create and update their polygon.  When line segments of the
polygons of two objects intersect the two objects would be considered touching.
This approach does not handle containment (when one object is completely
inside another).

Idea 2: represent each object as a set of triangles.  When segments of
triangles of two objects intersect, the objects touch.  Could also look
for a vertex inside of another object's triangle.
*****/


    // true if the bounding boxes of this and obj overlap
    return overlap(m_x, m_y, m_x + m_w, m_y + m_h,
                   obj->m_x, obj->m_y, obj->m_x + obj->m_w, obj->m_y+obj->m_h);
}

int
Game_object::near(Game_object *obj)
{

    // expand the bounding boxes of this and obj by their respective m_proximity
    // true if the expanded bounding boxes of this and obj overlap
    return overlap(m_x - m_proximity, m_y - m_proximity, 
                       m_x + m_w + m_proximity, m_y + m_h + m_proximity,
                   obj->m_x - obj->m_proximity, obj->m_y - obj->m_proximity, 
                   obj->m_x + obj->m_w + obj->m_proximity, 
                   obj->m_y+obj->m_h + obj->m_proximity);
}

Game_object::Typed_void_ptr*
Game_object::lookup_registered_member_variable(string name)
{
        // Check if name in map of registered_member_variables
        map<string, Typed_void_ptr *>::iterator iter;
        iter = m_variable_registry.find(name);
        if (iter == m_variable_registry.end())
        {
            return 0;
        }
        return (*iter).second;
}

void 
Game_object::register_member_variable(Gpl_type type, 
                                      string name, 
                                      void *value
                                     )
{
        assert(type == INT || type == DOUBLE 
               || type == STRING || type == ANIMATION_BLOCK);

        // make sure this member variable has not already been registered
        assert(!lookup_registered_member_variable(name));

        // insert this member variable into the registry as type "type"
        m_variable_registry[name] = new Typed_void_ptr(type, (void *)value);
}

Status 
Game_object::mark_member_variable_as_derived(string name)
{
    Typed_void_ptr *variable = lookup_registered_member_variable(name);
    if (!variable)
        return MEMBER_NOT_DECLARED;
    variable->m_derived = true;
    return OK;
}


void 
Game_object::animate()
{
    if (m_animation_block)
    {
        // Call our own animation block
        // Animation blocks are special type of statement block that ALWAYS
        // contain a pointer to a symbol in the symbol_table that represent
        // a parameter.

        // When this object calls its animation block, it must pass itself 
        // <this> to the execute function of the animation_block


        if (!m_animation_block->empty())
            m_animation_block->execute(this);

        // else do nothing

    }
}

bool 
Game_object::valid() const
{
    vector<Game_object *>::iterator iter = 
            find(all_game_objects.begin(), all_game_objects.end(), this);
    return iter != all_game_objects.end();
}

ostream &
Game_object::print(ostream &os) const
{
    os << indent << m_object_type_name /* << "<" << (void *) this << ">" */
       << endl << indent << "{" << endl;
    os.flush();
    indent++;

    map<string, Typed_void_ptr *>::const_iterator iter;
    for (iter = m_variable_registry.begin(); 
         iter != m_variable_registry.end();
         iter++
        )
    {
        if (iter != m_variable_registry.begin())
            os << "," << endl;

        Typed_void_ptr *cur_member = (*iter).second;
        string cur_name = (*iter).first;

        os << indent << cur_name << " = "; 
        switch (cur_member->m_type)
        {
            case INT:
                os << "int(" << *((int *) cur_member->m_value) << ")";
                break;
            case DOUBLE:
                os << "double(" << *((double *) cur_member->m_value) << ")";
                break;
            case STRING:
                os << "string(\"" << *((string *) cur_member->m_value)<< "\")";
                break;
            case ANIMATION_BLOCK:
                if (*((Animation_block **) (cur_member->m_value)) == 0)
                    os << "animation_block(0)";
                else 
                {
                    indent++;
                    os << endl<< *((Animation_block **) (cur_member->m_value));
                    indent--;
                }
                break;
            default:
                // there is a programming bug if this is ever executed
                assert(false);
        }
    } // for loop iterating through all registered member variables
    os << endl;
    indent--;
    os << indent << "}";
    return os;
}

ostream &
operator<<(ostream &os, const Game_object &game_object)
{
    return game_object.print(os);
}

ostream &
operator<<(ostream &os, const Game_object *game_object)
{
    if (!game_object)
    {
        os << indent << "Game_object{NULL}";
        return os;
    }
    else return game_object->print(os);
}