<?php
require_once(LIB_PATH.DS.'database.php');

class Account extends DatabaseObject 
{
	
    protected static $table_name="accounts";
	protected static $db_fields = array();
	
    function __construct() {
	// abstracted to get the database fields
	
			global $database;
			$sql = "SELECT * FROM " . self::$table_name . " LIMIT 1";
			$result_set = $database->query($sql);
			$fields_num = $database->num_fields($result_set);
			
				for($i=0; $i<$fields_num; $i++)
				{
					$result = $database->fetch_fields($result_set,$i);
					self::$db_fields[$i] = $result->name;
				}

				foreach(self::$db_fields as $field)
				{
					$this->$field = $field;
				}
    }

	// returns an array of the database fields
	private static function get_field_array()
	{
		$sql = "SHOW FIELDS FROM " . self::$table_name;
		$field_array = self::find_by_sql($sql);
		return $field_array;
	}

	
    //////////////////// Common Database Methods ////////////////////
    public static function find_all() 
	{
        $result = self::find_by_sql("SELECT * FROM ". self::$table_name);
        return ($result);
    }

    public static function find_by_guid($id=0) 
	{
        $result_array = self::find_by_sql("SELECT * FROM ".self::$table_name." WHERE id={$id} LIMIT 1");
        return (!( empty($result_array) ) ? array_shift($result_array) : false);
    }

    public static function find_by_topic_id($id=2) 
	{
        $result_array = self::find_by_sql("SELECT * FROM ".self::$table_name." WHERE topic_id={$id}");
		
		return $result_array;
    }
    
    public static function find_by_sql($sql="") 
	{
        global $database;
        $result_set = $database->query($sql);

        //php needs this for some reason
        $object_array = array();

        while ($row = $database->fetch_array($result_set)) 
		{
            $object_array[] = self::instantiate($row);
        }
		
        return $object_array;
    }

    private static function instantiate($record) 
	{
    // Could check that $record exists and is an array right here
        $object = new self;

        // More dynamic, short-form approach:
        foreach($record as $attribute=>$value) 
		{
            if($object->has_attribute($attribute)) 
			{
                $object->$attribute = $value;
            }
        }
        return $object;
    }

    private function has_attribute($attribute) 
	{
    // We don't care about the value, we just want to know if the key exists
    // Will return true or false
	
        return array_key_exists($attribute, $this->attributes());
    }

    protected function attributes() 
	{
    // return an array of attribute names and their values
	
	
	
	
	
        $attributes = array();
        foreach(self::$db_fields as $field) 
		{
            if(property_exists($this, $field)) 
			{
                $attributes[$field] = $this->$field;
            }
        }
		
        return ($attributes);
    }

    protected function sanitized_attributes() 
	{
        global $database;
        $clean_attributes = array();

        // sanitize the values before submitting
        // Note: does not alter the actual value of each attribute
        foreach($this->attributes() as $key => $value) 
		{
            $clean_attributes[$key] = $database->escape_value($value);
        }
		
        return $clean_attributes;
    }

    public function save() 
	{
    // A new record won't have an id yet.
        $result = isset($this->id) ? $this->update() : $this->create();
		
        return $result;
    }

    public function create() 
	{
        global $database;
        // Don't forget your SQL syntax and good habits:
        // - INSERT INTO table (key, key) VALUES ('value', 'value')
        // - single-quotes around all values
        // - escape all values to prevent SQL injection
        $attributes = $this->sanitized_attributes();
        $sql  = "INSERT INTO ".self::$table_name." (";
        $sql .= join(", ", array_keys($attributes));
        $sql .= ") VALUES ('";
        $sql .= join("', '", array_values($attributes));
        $sql .= "')";
        if($database->query($sql)) 
		{
            $this->id = $database->insert_id();
            return true;
        } 
		else 
		{
            return false;
        }
    }

    public function update() 
	{
        global $database;
        // Don't forget your SQL syntax and good habits:
        // - UPDATE table SET key='value', key='value' WHERE condition
        // - single-quotes around all values
        // - escape all values to prevent SQL injection
        $attributes = $this->sanitized_attributes();
        $attribute_pairs = array();
        foreach($attributes as $key => $value) 
		{
            $attribute_pairs[] = "{$key}='{$value}'";
        }
        $sql  = "UPDATE ".self::$table_name." SET ";
        $sql .= join(", ", $attribute_pairs);
        $sql .= " WHERE id=". $database->escape_value($this->id);
        $database->query($sql);
        return ($database->affected_rows() == 1) ? true : false;
    }

    public function delete() 
	{
        global $database;
        // Don't forget your SQL syntax and good habits:
        // - DELETE FROM table WHERE condition LIMIT 1
        // - escape all values to prevent SQL injection
        // - use LIMIT 1
        $sql  = "DELETE FROM ".self::$table_name;
        $sql .= " WHERE id=". $database->escape_value($this->id);
        $sql .= " LIMIT 1";
        $database->query($sql);
        return ($database->affected_rows() == 1) ? true : false;

    // NB: After deleting, the instance of User still
    // exists, even though the database entry does not.
    // This can be useful, as in:
    //   echo $user->first_name . " was deleted";
    // but, for example, we can't call $user->update()
    // after calling $user->delete().
    }

} // end Account class

?>