#include "symbol_table.h"

const char* type2str[5] = {
	"<NO TYPE>",
	"int",
	"double",
	"string",
	"<INVALID>"
};
void Symbol::print(ostream &target) {
}

Symbol_table *Symbol_table::m_instance = NULL;

Symbol_table *Symbol_table::instance() {
	if (m_instance == NULL)
		m_instance = new Symbol_table();
	return m_instance;
}

void Symbol_table::print(ostream &target) {
	map<string,Symbol>::iterator iter;
	for (iter=contents.begin(); iter != contents.end(); ++iter) {
                //if (iter->second.type == 0) continue;//fixme
		target << type2str[iter->second.type] << " ";
		target << iter->first << " ";
		if (iter->second.type == TYPE_INT) {
			target << iter->second.value.t_int;
		} else if (iter->second.type == TYPE_DOUBLE) {
			target << iter->second.value.t_double;
		} else if (iter->second.type == TYPE_STRING) {
			target << "\"" << *(iter->second.value.t_string) << "\"";
		} else {
			target << "<?-?-?> " << iter->second.type;
			target << " " << iter->second.value.t_int;
		}
		target << endl;
	}
}

void Symbol_table::get_type(char *name, Gpl_type &type) {
	// ADDME
}
// Add get function that is overloaded.

int Symbol_table::type(string *name) {
    if (!has_symbol(name)) return 0;
    Symbol tmp = contents[*name];
    return tmp.type;
}
void Symbol_table::add_symbol(string *name, int type, Expression *init) {
	Symbol  new_symbol;
	new_symbol.name = name;
	new_symbol.type = type;
        if (init != NULL && init->type() > type) {
            cout << "Some kind of type error: " << init->type() << " != " << type << endl;  
            assert(0);
        }
           
	switch (type) {
		case TYPE_INT:
		    if(init != NULL)
                        new_symbol.value.t_int = init->as_int();
                    else
                        new_symbol.value.t_int = 0;
                    
		break;
		case TYPE_DOUBLE:
                    if(init != NULL)
                        new_symbol.value.t_double = init->as_float();
                    else
			new_symbol.value.t_double = 0.0;
		break;
		case TYPE_STRING:
                    if(init != NULL) {
                        //cout << "--------" << *init->as_string() << endl;
                        new_symbol.value.t_string = init->as_string();
                    } else
			new_symbol.value.t_string = new string("");
		break;
	}
//	new_symbol.value = init;
	contents[*name] = new_symbol;
}

void Symbol_table::del_symbol(string *name) {
}


long Symbol_table::as_int(string *name) {
    assert(has_symbol(name));
    Symbol tmp = contents[*name];
    assert(tmp.type == TYPE_INT);
    return tmp.value.t_int;
}
double Symbol_table::as_float(string *name) {
    assert(has_symbol(name));
    Symbol tmp = contents[*name];
    assert(tmp.type <= TYPE_DOUBLE);
    switch(tmp.type) {
        case TYPE_DOUBLE:
            return tmp.value.t_double;
        case TYPE_INT:
            return tmp.value.t_int;
        default:
            assert(0);
    }
}

string *Symbol_table::as_string(string *name) {
    assert(has_symbol(name));
    Symbol tmp = contents[*name];
    assert(tmp.type <= TYPE_STRING);
    char buffer[90];
    string *tst;
    switch (tmp.type) {
        case TYPE_DOUBLE:
            sprintf(buffer, "%lg", tmp.value.t_double);
            tst = new string(buffer);
            return tst;
        case TYPE_INT:
            sprintf(buffer, "%ld", tmp.value.t_int);
            tst = new string(buffer);
            return tst;
        case TYPE_STRING:
            return tmp.value.t_string;
    }
    assert(0);
}