<?php
include_once 'engine/action.php';

//include_once 'engine/p.php';
//include_once 'engine/g.php';
include_once 'engine/r.php';

/**
* Mängu tegevus.
* Tegevus, mida mängija saab mängus ette võtta. Selleks saadakse vastav Activity $game objekti meetodiga
* get_action() mille parameetriteks on $action_id ja $activity_id.
* Tegevuse sooritamiseks tuleb kustuda meetod commit().
* 
* @package GameEngine
* @access public
*/
class Activity extends Action {

	/**
	* Tulemuse identifikaator.
	* Saab väärtuse pärast meetodi commit() sooritamist.
	* @access public
	* @var integer
	*/
	var $result_id;

	/**
	* Täringu väärtus.
	* Saab väärtuse pärast meetodi commit() sooritamist.
	* @access public
	* @var integer
	*/
	var $dice;

	/**
	* Tulemus tekstina (toimunu kirjeldus).
	* Saab väärtuse pärast meetodi commit() sooritamist.
	* @access public
	* @var string
	*/
	var $result_text;

	/**
	* Punktiarvestuse kirjeldus.
	* Saab väärtuse pärast meetodi commit() sooritamist.
	* @access public
	* @var string
	*/
	var $points_by_words;

    /**
	* Väljastab kõik mängu tegevused assotsiatiivmassiivina, mille elemendid on kujul (activity_id => name).
	* (Saab kasutada eksemplari loomata, kui väljakutsuv objekt pärineb DAO klassist ehk omab 
	* meetodit get_db_pairs(). See ei ole staatiliselt kasutamine..)
	* 
	* @access public
	* @return array Massiiv elementidega kujul (activity_id => name)
	*/
    function get_items() {
        //viewarr($this->get_records("SELECT action_id, name FROM dsg_action WHERE type='A'"));
		return $this->get_db_pairs("SELECT activity_id, name FROM dsg_activity");
    }

	/**
	* Määrab missugust activitit objekt esindab.
	* 
	* @param integer $id Activity identifikaator.
	*/
	function set_id($id) {
		$sql = "SELECT activity_id, name, time_cost, heading, description, hint, subject_count
				FROM dsg_activity WHERE activity_id = '$id'"; 
		if ($rec = $this->get_db_record($sql)) { //kui tuleb tühi rec - evalueeritakse false-na
			parent::set_id($id);
			$this->assign_vars($rec);
    		return 1;
		} else
			return 0; //kui netist tuleb vale päring, jõuab siia
	}

	/**
	* See implementeeritakse järglastes uuesti, kui on vajadus keerukama päringu järele.
	* Mõne järglase puhul tehakse võibolla tühja tööd, aga praegu vähem kirjutamist.
	* Siin loetakse ka subjektid sisse (luuakse)
	*/
    function load($week) {
		$sql = "SELECT c.week, c.activity_id, c.result_id, c.dice, 
				r.result_text, r.algorithm_id, 
				a.points_by_words, a.points_algorithm, a.comments
				FROM dsg_chronology c, dsg_result r, dsg_algorithm a
				WHERE c.action_id = '{$this->action_id}' AND c.week = '$week'
				AND c.result_id = r.result_id AND c.dice = r.dice 
				AND r.algorithm_id = a.algorithm_id 
				AND c.user_id = '{$this->user_id}' AND c.game_id = '{$this->game_id}' ";
		$this->assign_record($sql);
		$this->subjects = $this->get_subjects($week);
    }

	/**
	* Väljastab yes_result või no_result, milleni jõudis, ükskõik mis seal väljal ka ei ole (null?),
	* ebaõnnestumisel (lõpmatu tsükkel) mittenumbrilise väärtuse (false)
	* 
	* @param array $rules
	* @param mixed $subjects Massiiv või üksikväärtus ($person_id), kellega tegevust tehakse.
	* @return integer
	*/
	function execute_rules($rules, $subjects) {
       	$subj = (is_array($subjects) and count($subjects) == 1) ? $subjects[0] : $subjects;
									
		reset($rules);
		$rule = current($rules);
		for ($result = false, $counter = 0; ($result === false) and ($counter < 50); $counter++) {
			$action_id = $rule['action_id'];
			if (is_null($action_id))
				$is_true = true;
			else {
        		$sub_id = $rule['sub_id']; //universaalne identifikaator
        		$func = $rule['func'];
        		$strParam = $rule['param'];
				$instance_id = (is_null($sub_id) and !is_array($subj)) ? $subj : $sub_id;
				
				//var_dump($instance_id);
				//var_dump($rule);
				
    			$actionObj =& $this->owner->get_action($action_id, $instance_id);
				/*
				* siin peaks olema kontroll et selline meetod $func eksisteerib   method_exists() (või LUBATUD meetodite hulgas)
				* parameetrite lisamise reegel: kui baasis on parameeter, läheb funktsiooni 1. parameetrina,
				* vastasel korral läheb subjekt(id) 1. ja param 2.-na
				* 
				* kui parameetreid/subjekte on 1 -> ei lähe arrayna, sest on funktsioone mis võtavad ainult
				* ühe parameetri - seda peab teadma.
				* Funktsioonid mis võivad võtta mitu elementi arrayna, peavad aktsepteerima ka üksikut väärtust.
				*/
				
				if (is_null($strParam))
	        		$is_true = $actionObj->$func($subj);
				else {
    				$params_array = explode(',', $strParam);
    				$param = (is_array($params_array) and count($params_array) == 1) ? $params_array[0] : $params_array;
    				
    				//funktsioonid millel ainult 1 argument, ei tohiks panna pahaks, kui on lisatud teine.
            		$is_true = $actionObj->$func($param, $subj);
				}
				//kokkkuleppeliselt kui $func mingil põhjusel ei saa kindlat tõde väljastada, väljastab null.
				if (is_null($is_true))
					return false; //tsekka veateateid all..
			}
			
			//var_dump($is_true);
			
			if ($is_true) {
				if (isset($rule['yes'])) {
					$rule = $rules[ $rule['yes'] ];
				} else
					$result = @$rule['yes_result'];
			} else {
				if (isset($rule['no'])) {
					$rule = $rules[ $rule['no'] ];
				} else
					$result = @$rule['no_result'];
			}
			
		}
		return $result;
	}
	
	/**
	* Kontrollib kas eeltingimused, mis lubavad tegevust sooritada on rahuldatud.
	* Kui ei ole rahuldatud, paneb message = by_words et kasutaja saaks aru milles oli probleem.
	* 
	* @param mixed $subjects Massiiv või üksikväärtus ($person_id), kellega tegevust tehakse.
	* @return boolean
	*/
	function preconditions_satisfied($subjects) {
		$sql = "SELECT rule_nr, action_id, sub_id, func, param, yes, no, yes_result, no_result, by_words 
				FROM dsg_rules WHERE activity_id = '{$this->id}' AND rule_nr < 0 ORDER BY rule_nr DESC";
		$rules = $this->get_db_key_records($sql);
	
		if (empty($rules)) {
			return 1; //Ei ole eeltingimusi
		}
		$satisfied = $this->execute_rules($rules, $subjects);
		return $satisfied;
	}
	
	/**
	* 
	* @param mixed $subjects Massiiv või üksikväärtus ($person_id), kellega tegevust tehakse.
	* @return mixed
	*/
	function determine_result($subjects) {
		//määrame result_id

		$sql = "SELECT rule_nr, action_id, sub_id, func, param, yes, no, yes_result, no_result, by_words 
				FROM dsg_rules WHERE activity_id = '{$this->id}' AND rule_nr > 0 ORDER BY rule_nr";
		//$rules = $this->get_db_key_records($sql);
		$rules = $this->get_db_key_records($sql);
		//var_dump($rules);
		/*
		for ($nr = 0; $nr < count($rules); $nr++ ) {
			$rule = $rules[$nr];
			eval($rule['condition']);
		}
		*/
		if (empty($rules)) {
			$this->message = "Ei ole reegleid tulemuse leidmiseks!";
			return 0;
		}
		
		//igaks petteks ajutine muutuja:
		$result_id = $this->execute_rules($rules, $subjects);
		
		if (!is_numeric($result_id)) {
			$this->message = "Tulemuse leidmise algoritm ebaõnnestus!";
			if (is_null($result_id)) 
				$this->message .= " Vigane algoritm.";
			if ($result_id === false) 
				$this->message .= " Tühi alamfunktsiooni tulemus või lõpmatu tsükkel.";
			return 0;
		}
		
		$this->result_id = $result_id; 
		
		//määrame dice
		$dice_values = $this->get_db_vertical_values(
			"SELECT dice FROM dsg_result WHERE result_id = '{$this->result_id}'");
		//var_dump($dice_values);
		$this->dice = $dice_values[array_rand($dice_values)];

		//loeme resulti sisse
		$sql = "SELECT result_text, r.algorithm_id, points_by_words, points_algorithm 
				FROM dsg_result r 
				LEFT JOIN dsg_algorithm a ON r.algorithm_id = a.algorithm_id
				WHERE result_id = '{$this->result_id}' AND dice = '{$this->dice}' ";
		$this->assign_vars($this->get_db_record($sql));
		
		return 1; //$this->result_id;
	}
	
	/**
	*/
    function save($week) {
		$sql = "INSERT INTO dsg_chronology 
		(user_id, game_id, week, action_id, activity_id, result_id, dice) 
		VALUES ('{$this->user_id}', '{$this->game_id}', '$week', '{$this->action_id}', 
		'{$this->id}', '{$this->result_id}', '{$this->dice}' ) ";
		return $this->exec_sql($sql);
    }

	/**
	* Viib tegevuse põhjustatud muudatused andmebaasi.
	* 
	* @param mixed $subjects Massiiv või üksikväärtus ($person_id), kellega tegevust tehakse.
	* @access private
	*/
	function commit_result($subjects) {
		/*
		$sql = "INSERT INTO dsg_chronology 
		(user_id, game_id, week, action_id, activity_id, result_id, dice) 
		VALUES ('{$this->user_id}', '{$this->game_id}', '".$diary->get_week()."', '{$this->action_id}', 
		'{$this->id}', '{$this->result_id}', '{$this->dice}' ) ";
		*/
    		/* ei kehti enam....:
			* praegu eeldame et get_week() ei muutu selle päringu jooksul
			* add_weeks() tõttu.
			* POSTi töötlemine lõpeb ümbersuunamisega, mille järel tehakse 
			* uus päring, mis näitab uut nädalat.
			*/
		$success = 0;

		$diary =& $this->owner->get_diary();
		
		if ($diary->get_weeks_left() < $this->time_cost) {
			$this->message = 'Mängu lõpuni on vähem aega kui tegevuse sooritamiseks vaja.';
			return $success;
		}	
			
		if ($this->save($diary->get_week())) {
			if ($this->add_subjects($diary->get_week(), $subjects)) {
        		if ($diary->add_weeks($this->time_cost)) {
					$this->give_points($subjects);
        			$success = 1;
				}else {
        			$this->message = 'Viga: Mängu lõpuni on vähem aega kui tegevuse sooritamiseks vaja.';
        		}
			}else {
        		$this->message = 'Viga subjektide lisamisel: tegevuse lisamine ebaõnnestus.';
			}
		}else
    		$this->message = 'Viga: tegevuse lisamine ebaõnnestus.';
		
		return $success;
	}

	/**
	* Annab punktid. Selleks peab olema eelnevalt determine_result($subjects) tehtud.
	* 
	* @access privete
	*/
	function give_points($subjects = NULL) {
		
		//if (!isset($this->points_algorithm))
		//	return;
		
		/*	
		if (!function_exists('P')) {
			function P1($id) {
				echo 'anname punktid..', $id;
			}
			echo function_exists('P');
		}
		*/
		//var_dump($this->parent);
		/*
		if (isset($subjects)) {
			if (!is_array($subjects))
				$subjects = array($subjects);
		}else
			$subjects = array();
		*/
		$D =& $this->owner->get_diary(); //ei ole facade obj, vbl kunagi hiljem teen..
		
		$grp =& new Group($this->owner);
		if (isset($subjects))
			$grp->set($subjects);
		
		$subject =& new G($this->owner, $grp);
		//$subject->set_obj($grp);
		$grp =& new Group($this->owner);
		$grp->set_all();
		
		//$prsn =& $this->owner->get_action('P');
		$P =& new G($this->owner, $grp);
		//$P =& new P($this->owner, $this->owner->get_action('P'));
		$R =& new R($this->owner);
		//$R =& new R($this->owner, $this->owner->get_action('R'));
		
		//$this->points_algorithm = "P1('A'); echo \$s; echo \$P,\$p;";
		//($P->i('A'))->add_points(1, AWARENESS);
		//$p = $P->i('B');
		//$p->add_points(1, AWARENESS);
		
		eval($this->points_algorithm);
	}

	/**
	* Paneb toime tegevuse.
	* 
	* @param mixed $subjects Massiiv või üksikväärtus ($person_id), kellega tegevust tehakse.
	* @access public
	*/
	function commit($subjects = null) {
		
		if ($this->subject_count != count($subjects)) {
		//if ($this->subject_count != count($subjects)) {
			$this->message = "Valitud subjektide arv pole õige.";
			return 0;
		}
		//kontroll, kas antud person_id-d ka baasis olemas on...
		//parent::commit(); //??
		
		//$this->exec_sql($sql);
		
		if ($this->preconditions_satisfied($subjects)) {
			if ($this->determine_result($subjects)) {
				return $this->commit_result($subjects);
			}
		}else
			$this->message = "Eeltingimused ei ole täidetud.";
		return 0;
		
    }

	/**
	* Praegu võtab 1 parameetri
	* arv, mitu korda tehtud ÜHE subjektiga..
	* 
	* @param integer $with_subject Subjekt ($person_id) 
	* @return integer arv, mitu korda tehtud (kui on 0, evalueerub false-ks - seda kasutatakse tõeväärtusena)
	*/
    function commited($with_subject) {
		$class = get_class($this);
		return $this->get_db_value("SELECT COUNT(*) 
FROM dsg_chronology c, dsg_action a, dsg_subject s, dsg_activity t 
WHERE a.class_name = '$class' 
AND t.activity_id='{$this->id}' 
AND person_id='$with_subject' 
AND c.activity_id=t.activity_id 
AND c.action_id=a.action_id 
AND c.week=s.week 
AND c.user_id=s.user_id 
AND c.game_id=s.game_id 
AND c.game_id='{$this->game_id}' AND c.user_id='{$this->user_id}' ");
	}

	/*
	function set_id($id) {
		$sql = "SELECT name FROM dsg_action ".
				" WHERE action_id = '$id' AND type='A'"; 
		if ($name = $this->get_db_value($sql)) {
			parent::set_id($id);
			$this->name = $name;
    		return 1;
		} else
			return 0;
	}
	*/
	
}


?>