<?php
	ini_set('display_errors', 1);
	error_reporting(E_ALL);

	define('IS_INSTALL', 1);
	define('ADMIN', 1);
	define('FULL_PATH', realpath(dirname(__FILE__).'/..') );
	define('REL_PATH', '/core');

//	print_pre($_POST);

	$install_engine = new kInstallator();
	$install_engine->Init();
	$install_engine->Run();
	$install_engine->Done();

	class kInstallator {

		/**
		 * Reference to kApplication class object
		 *
		 * @var kApplication
		 */
		var $Application = null;

		/**
		 * Connection to database
		 *
		 * @var kDBConnection
		 */
		var $Conn = null;

		/**
		 * Path to config.php
		 *
		 * @var string
		 */
		var $INIFile = '';

		/**
		 * XML file containing steps information
		 *
		 * @var string
		 */
		var $StepDBFile = '';

		/**
		 * Parsed data from config.php
		 *
		 * @var Array
		 */
		var $systemConfig = Array ();
		/**
		 * Step name, that currently being processed
		 *
		 * @var string
		 */
		var $currentStep = '';

		/**
		 * Steps list (preset) to use for current installation
		 *
		 * @var string
		 */
		var $stepsPreset = '';

		/**
		 * Installtion steps to be done
		 *
		 * @var Array
		 */
		var $steps = 	Array(
								'fresh_install'		=>	Array ('check_paths', 'db_config', 'root_password', 'choose_modules', 'finish'),
								'already_installed'	=>	Array ('install_setup'),

								'upgrade'			=>	Array ('install_setup',/* ..., */ 'finish'),
								'db_reconfig'		=>	Array ('install_setup',/* ..., */ 'finish'),
								'fix_paths'			=>	Array ('install_setup',/* ..., */ 'finish'),
						);


		/**
		 * Steps, on which kApplication should not be initialized, because of missing correct db table structure
		 *
		 * @var Array
		 */

		var $skipApplicationSteps = Array ('check_paths', 'db_config', 'install_setup'); // remove install_setup when application will work separately from install

		/**
		 * Folders that should be writeable to continue installation
		 *
		 * @var Array
		 */
		var $writeableFolders = Array ('/', '/system');

		/**
		 * Contains last error message text
		 *
		 * @var string
		 */
		var $errorMessage = '';

		/**
		 * Base path for includes in templates
		 *
		 * @var string
		 */
		var $baseURL = '';

		function Init()
		{
			$this->INIFile = FULL_PATH.'/config.php';
			$this->StepDBFile = FULL_PATH.'/'.REL_PATH.'/install/steps_db.xml';

			$base_path = rtrim(preg_replace('/'.preg_quote(rtrim(REL_PATH, '/'), '/').'$/', '', str_replace('\\', '/', dirname($_SERVER['PHP_SELF']))), '/');
			$this->baseURL = 'http://'.$_SERVER['HTTP_HOST'].$base_path.'/core/install/';

			set_error_handler( Array(&$this, 'ErrorHandler') );

			if (file_exists($this->INIFile)) {
				// if config.php found, then check his write permission too
				$this->writeableFolders[] = '/config.php';
			}

			$this->systemConfig = $this->ParseConfig(true);
			$this->systemConfig['Misc']['WriteablePath'] = '/system'; // for development purposes

			$this->currentStep = $this->GetVar('step');

			$this->SelectPreset();

			if (!$this->currentStep) {
				// first step of current preset
				reset($this->steps[$this->stepsPreset]);
				$this->currentStep = current($this->steps[$this->stepsPreset]);
			}

			$this->InitStep();
		}

		/**
		 * Selects preset to proceed based on various criteria
		 *
		 */
		function SelectPreset()
		{
			$preset = $this->GetVar('preset');

			if ($preset === false) {
				$preset = 'fresh_install'; // default preset

				if (file_exists($this->INIFile)) {
					// only at installation first step
					$status = $this->CheckDatabase(false);
					if ($status && $this->AlreadyInstalled()) {
						$preset = 'already_installed';
					}
				}
			}

			$this->stepsPreset = $preset;
		}

		function GetVar($name)
		{
			return isset($_REQUEST[$name]) ? $_REQUEST[$name] : false;
		}

		/**
		 * Performs needed intialization of data, that step requires
		 *
		 */
		function InitStep()
		{
			$this->InitApplication();

			switch ($this->currentStep) {
				case 'check_paths':
					foreach ($this->writeableFolders as $folder_path) {
						$file_path = FULL_PATH.$folder_path;
						if (!is_writable($file_path)) {
							$this->errorMessage = 'Install cannot write to specified folder in the root directory of your installation';
							break;
						}
					}
					break;

				case 'db_config':
					$section_name = 'Database';
					$fields = Array ('DBType', 'DBHost', 'DBName', 'DBUser', 'DBUserPassword', 'TablePrefix');

					if (!isset($this->systemConfig[$section_name])) {
						$this->systemConfig[$section_name] = Array ();
					}

					// set fields
					foreach ($fields as $field_name) {
						$submit_value = $this->GetVar($field_name);

						if ($submit_value !== false) {
							$this->systemConfig[$section_name][$field_name] = $submit_value;
						}
						elseif (!isset($this->systemConfig[$section_name][$field_name])) {
							$this->systemConfig[$section_name][$field_name] = '';
						}
					}
			        break;

				case 'choose_modules':
					// if no modules found, then proceed to next step
					$modules = $this->ScanModules();
					if (!$modules) {
						$this->currentStep = $this->GetNextStep();
					}
					break;

				case 'install_setup':
					if ($this->stepsPreset == 'already_installed') {
						// if preset was not choosen, then raise error
						$this->errorMessage = 'Please select action to perform';
					}
					else {
						// if preset was choosen, then check root password entered
						$user_name = $this->GetVar('user_name');
						$user_password = $this->GetVar('user_password');

						if ($user_name == 'root') {
							$sql = 'SELECT VariableValue
									FROM '.$this->systemConfig['Database']['TablePrefix'].'
									WHERE VariableName = "RootPass"';
							$root_password = $this->Conn->GetOne($sql);
							$user_password = md5( md5($user_password) . 'b38');
							if ($user_password != $root_password) {
								$this->errorMessage = 'Invalid User Name or Password. If you don\'t know your username or password, contact Intechnic Support';
							}
						}
						else {
							$this->errorMessage = 'By now only login using "root" username is supported';
						}
					}
					break;
			}

			$this->PerformValidation(); // returns validation status (just in case)
		}

		/**
		 * Validates data entered by user
		 *
		 * @return bool
		 */
		function PerformValidation()
		{
			if ($this->GetVar('step') != $this->currentStep) {
				// just redirect from previous step, don't validate
				return true;
			}

			$status = true;

			switch ($this->currentStep) {
				case 'db_config':
					// 1. check if required fields are filled
					$section_name = 'Database';
					$required_fields = Array ('DBType', 'DBHost', 'DBName', 'DBUser');
					foreach ($required_fields as $required_field) {
						if (!$this->systemConfig[$section_name][$required_field]) {
							$status = false;
							$this->errorMessage = 'Please fill all required fields';
							break;
						}
					}
					if (!$status) break;

					// 2. check permissions, that use have in this database
					$status = $this->CheckDatabase();
					break;

				case 'root_password':
					// check, that password & verify password match
					$password = $this->Application->GetVar('root_password');
					$password_verify = $this->Application->GetVar('root_password_verify');

					if ($password != $password_verify) {
						$this->errorMessage = 'Passwords does not match';
					}
					elseif (strlen($password) < 4) {
						$this->errorMessage = 'Root Password must be at least 4 characters';
					}

					$status = $this->errorMessage == '';
					break;
			}

			return $status;
		}

		/**
		 * Perform installation step actions
		 *
		 */
		function Run()
		{
			if ($this->errorMessage) {
				// was error during data validation stage
				return ;
			}

			switch ($this->currentStep) {
				case 'db_config':
					// store db configuration
					$this->SaveConfig();

					// import base data into database
					$this->RunSQL('/core/install/install_schema.sql');
					$this->RunSQL('/core/install/install_data.sql');
					break;

				case 'root_password':
					// update root password in database
					$password = md5( md5($this->Application->GetVar('root_password')) . 'b38');
					$this->SetConfigValue('RootPass', $password);
					
					// set Site_Path (for SSL & old in-portal code)
					$this->SetConfigValue('Site_Path', BASE_PATH.'/');
					
					// import base language for core (english)
					$this->ImportLanguage('/core/install/english');
					
					// set imported language as primary
					$lang =& $this->Application->recallObject('lang.-item', null, Array('skip_autoload' => true));
					/* @var $lang LanguagesItem */
					
					$lang->Load(1); // fresh install => ID=1
					$lang->setPrimary();
					break;

				case 'choose_modules':
					// run module install scripts
					$modules = $this->Application->GetVar('modules');
					foreach ($modules as $module) {
						$install_file = MODULES_PATH.'/'.$module.'/install.php';
						if (file_exists($install_file)) {
							include_once($install_file);
						}
					}
					
					// scan themes
					$themes_helper =& $this->Application->recallObject('ThemesHelper');
					/* @var $themes_helper kThemesHelper */
					
					$themes_helper->refreshThemes();
					break;
			}

			if ($this->errorMessage) {
				// was error during run stage
				return ;
			}

			$this->currentStep = $this->GetNextStep();
			$this->InitStep(); // init next step (that will be shown now)

			$this->InitApplication();

			if ($this->currentStep == -1) {
				// step after last step -> redirect to admin
				$this->Application->Redirect('index', null, '', 'index.php');
			}
		}

		/**
		 * Sets new configuration variable value
		 *
		 * @param string $name
		 * @param mixed $value
		 */
		function SetConfigValue($name, $value)
		{
			$sql = 'UPDATE '.TABLE_PREFIX.'ConfigurationValues
		      		SET VariableValue = '.$this->Conn->qstr($value).'
		      		WHERE VariableName = '.$this->Conn->qstr($name);
			$this->Conn->Query($sql);
		}
		
		function InitApplication()
		{
			if (!in_array($this->currentStep, $this->skipApplicationSteps) && !isset($this->Application)) {
				// step is allowed for application usage & it was not initialized in previous step
				global $debugger;
				include_once(FULL_PATH.'/core/kernel/startup.php');

				$this->Application =& kApplication::Instance();
				$this->Application->Init();
				$this->Conn =& $this->Application->GetADODBConnection();
			}
		}

		/**
		 * Show next step screen
		 *
		 */
		function Done($error_message = null)
		{
			if (isset($error_message)) {
				$this->errorMessage = $error_message;
			}

			include_once (FULL_PATH.'/'.REL_PATH.'/install/incs/install.tpl');

			if (isset($this->Application)) {
				$this->Application->Done();

				echo 'SID: ['.$this->Application->GetSID().']<br />';
			}

			exit;
		}

		function GetModuleVersion($module_name)
		{
			return '0.1.1';
		}

		function ConnectToDatabase()
		{
			include_once FULL_PATH.'/core/kernel/db/db_connection.php';

			$this->Conn = new kDBConnection($this->systemConfig['Database']['DBType'], Array(&$this, 'DBErrorHandler'));
			$this->Conn->Connect($this->systemConfig['Database']['DBHost'], $this->systemConfig['Database']['DBUser'], $this->systemConfig['Database']['DBUserPassword'], $this->systemConfig['Database']['DBName']);
			return $this->Conn->errorCode == 0;
		}

		/**
		 * Checks if core is already installed
		 *
		 * @return bool
		 */
		function AlreadyInstalled()
		{
			return $this->TableExists('ConfigurationAdmin'); //,Category,Permissions');
		}

		function CheckDatabase($check_installed = true)
		{
			// perform various check type to database specified
			// 1. user is allowed to connect to database
			// 2. user has all types of permissions in database


			if (strlen($this->systemConfig['Database']['TablePrefix']) > 7) {
				$this->errorMessage = 'Table prefix should not be longer than 7 characters';
				return false;
			}

			// connect to database
			$status = $this->ConnectToDatabase();
			if ($status) {
				// if connected, then check if all sql statements work
				$sql_tests[] = 'DROP TABLE IF EXISTS test_table';
				$sql_tests[] = 'CREATE TABLE test_table(test_col mediumint(6))';
				$sql_tests[] = 'LOCK TABLES test_table WRITE';
				$sql_tests[] = 'INSERT INTO test_table(test_col) VALUES (5)';
				$sql_tests[] = 'UPDATE test_table SET test_col = 12';
				$sql_tests[] = 'UNLOCK TABLES';
				$sql_tests[] = 'ALTER TABLE test_table ADD COLUMN new_col varchar(10)';
				$sql_tests[] = 'SELECT * FROM test_table';
				$sql_tests[] = 'DELETE FROM test_table';
				$sql_tests[] = 'DROP TABLE IF EXISTS test_table';

				foreach ($sql_tests as $sql_test) {
					$this->Conn->Query($sql_test);
					if ($this->Conn->getErrorCode() != 0) {
						$status = false;
						break;
					}
				}

				if ($status) {
					// if statements work & connection made, then check table existance
					if ($check_installed && $this->AlreadyInstalled()) {
						$this->errorMessage = 'An In-Portal Database already exists at this location';
						return false;
					}
				}
				else {
					// user has insufficient permissions in database specified
					$db_error = 'Permission Error: ('.$this->Conn->getErrorCode().') '.$this->Conn->getErrorMsg();
					return false;
				}
			}
			else {
				// was error while connecting
				$this->errorMessage = 'Connection Error: ('.$this->Conn->getErrorCode().') '.$this->Conn->getErrorMsg();
				return false;
			}

			return true;
		}

		/**
		 * Checks if all passed tables exists
		 *
		 * @param string $tables comma separated tables list
		 * @return bool
		 */
		function TableExists($tables)
		{
			$prefix = $this->systemConfig['Database']['TablePrefix'];

			$all_found = true;
			$tables = explode(',', $tables);
			foreach ($tables as $table_name) {
				$sql = 'SHOW TABLES LIKE "'.$prefix.$table_name.'"';
				if (count($this->Conn->Query($sql)) == 0) {
					$all_found = false;
					break;
				}
			}

			return $all_found;
		}

		function RunSQL($filename, $replace_from = null, $replace_to = null)
		{
			if (!file_exists(FULL_PATH.$filename)) {
				return ;
			}

			$sqls = file_get_contents(FULL_PATH.$filename);

			$table_prefix = $this->systemConfig['Database']['TablePrefix'];

			// add prefix to all tables
			if (strlen($table_prefix) > 0) {
				$replacements = Array ('CREATE TABLE ', 'INSERT INTO ', 'UPDATE ', 'ALTER TABLE ');
				foreach ($replacements as $replacement) {
					$sqls = str_replace($replacement, $replacement.$table_prefix, $sqls);
				}
				$sqls = str_replace('DROP TABLE ', 'DROP TABLE IF EXISTS '.$table_prefix, $sqls);
			}

			if (isset($replace_from) && isset($replace_to)) {
				// replace something additionally, e.g. module root category
				$sqls = str_replace($replace_from, $replace_to, $sqls);
			}

			$sqls = explode(";\n", $sqls);

			foreach ($sqls as $sql) {
				$sql = trim($sql);
				if (!$sql || substr($sql, 0, 1) == '#') {
					continue; // usually last line  || comment
				}
				$this->Conn->Query($sql);
				if ($this->Conn->getErrorCode() != 0) {
    				$this->errorMessage = 'Error: ('.$this->Conn->getErrorCode().') '.$this->Conn->getErrorMsg().'<br /><br />Database Query:<pre>'.htmlspecialchars($sql).'</pre>';
    				$this->Done();
    				break;
    			}
			}
		}

		function ImportLanguage($lang_file)
		{
			$lang_file = FULL_PATH.$lang_file.'.lang';
			if (!file_exists($lang_file)) {
				return ;
			}

			$lang_xml =& $this->Application->recallObjectP('LangXML', null, Array(), false); // false - don't use temp tables
			$lang_xml->Parse($lang_file, '|0|1|2|', '');
		}

		/**
		 * Returns modules list found in modules folder
		 *
		 * @return Array
		 */
		function ScanModules()
		{
			static $modules = null;

			if (!isset($modules)) {
				$modules = Array();
				$fh = opendir(MODULES_PATH);
				while (($sub_folder = readdir($fh))) {
					$folder_path = MODULES_PATH.'/'.$sub_folder;
					if ($sub_folder != '.' && $sub_folder != '..' && is_dir($folder_path)) {
						if ($sub_folder == 'core') {
							// skip modules here
							continue;
						}
						// this is folder in MODULES_PATH directory
						if (file_exists($folder_path.'/install.php') && file_exists($folder_path.'/install/install_schema.sql')) {
							$modules[] = $sub_folder;
						}
					}
				}
			}

			return $modules;
		}

		/**
		 * Returns content to show for current step
		 *
		 * @return string
		 */
		function GetStepBody()
		{
			$step_template = FULL_PATH.'/core/install/step_templates/'.$this->currentStep.'.tpl';
			if (file_exists($step_template)) {
				ob_start();
				include_once ($step_template);
				return ob_get_clean();
			}

			return '{step template "'.$this->currentStep.'" missing}';
		}

		/**
		 * Parses step information file, cache result for current step ONLY & return it
		 *
		 * @return Array
		 */
		function &_getStepInfo()
		{
			static $info = Array('help_title' => null, 'step_title' => null, 'help_body' => null, 'queried' => false);

			if (!$info['queried']) {
				$fdata = file_get_contents($this->StepDBFile);

				$parser = xml_parser_create();
				xml_parse_into_struct($parser, $fdata, $values, $index);
				xml_parser_free($parser);

				foreach ($index['STEP'] as $section_index) {
					$step_data =& $values[$section_index];

					if ($step_data['attributes']['NAME'] == $this->currentStep) {
						$info['step_title'] = $step_data['attributes']['TITLE'];
						if (isset($step_data['attributes']['HELP_TITLE'])) {
							$info['help_title'] = $step_data['attributes']['HELP_TITLE'];
						}
						else {
							// if help title not set, then use step title
							$info['help_title'] = $step_data['attributes']['TITLE'];
						}
						$info['help_body'] = trim($step_data['value']);
						break;
					}
				}

				$info['queried'] = true;
			}

			return $info;
		}

		/**
		 * Returns particular information abou current step
		 *
		 * @param string $info_type
		 * @return string
		 */
		function GetStepInfo($info_type)
		{
			$step_info =& $this->_getStepInfo();

			if (isset($step_info[$info_type])) {
				return $step_info[$info_type];
			}

			return '{step "'.$this->currentStep.'"; param "'.$info_type.'" missing}';
		}

		/**
		 * Returns passed steps titles
		 *
		 * @param Array $steps
		 * @return Array
		 * @see kInstaller:PrintSteps
		 */
		function _getStepTitles($steps)
		{
			$fdata = file_get_contents($this->StepDBFile);

			$parser = xml_parser_create();
			xml_parse_into_struct($parser, $fdata, $values, $index);
			xml_parser_free($parser);

			$ret = Array ();
			foreach ($index['STEP'] as $section_index) {
				$step_data =& $values[$section_index];
				if (in_array($step_data['attributes']['NAME'], $steps)) {
					$ret[ $step_data['attributes']['NAME'] ] = $step_data['attributes']['TITLE'];
				}
			}

			return $ret;
		}

		/**
		 * Returns current step number in active steps_preset.
		 * Value can't be cached, because same step can have different number in different presets
		 *
		 * @return int
		 */
		function GetStepNumber()
		{
			return array_search($this->currentStep, $this->steps[$this->stepsPreset]) + 1;
		}

		/**
		 * Returns step name to process next
		 *
		 * @return string
		 */
		function GetNextStep()
		{
			$next_index = $this->GetStepNumber();
			if ($next_index > count($this->steps[$this->stepsPreset]) - 1) {
				return -1;
			}

			return $this->steps[$this->stepsPreset][$next_index];
		}

		/**
		 * Returns step name, that was processed before this step
		 *
		 * @return string
		 */
		function GetPreviousStep()
		{
			$next_index = $this->GetStepNumber() - 1;
			if ($next_index < 0) {
				$next_index = 0;
			}

			return $this->steps[$this->stepsPreset][$next_index];
		}

		/**
		 * Prints all steps from active steps preset and highlights current step
		 *
		 * @param string $active_tpl
		 * @param string $passive_tpl
		 * @return string
		 */
		function PrintSteps($active_tpl, $passive_tpl)
		{
			$ret = '';
			$step_titles = $this->_getStepTitles($this->steps[$this->stepsPreset]);

			foreach ($this->steps[$this->stepsPreset] as $step_name) {
				$template = $step_name == $this->currentStep ? $active_tpl : $passive_tpl;
				$ret .= sprintf($template, $step_titles[$step_name]);
			}

			return $ret;
		}

		function ParseConfig($parse_section = false)
		{
			if (!file_exists($this->INIFile)) {
				return Array();
			}

			if( file_exists($this->INIFile) && !is_readable($this->INIFile) ) {
				die('Could Not Open Ini File');
			}

			$contents = file($this->INIFile);

			$retval = Array();
			$section = '';
			$ln = 1;
			$resave = false;
			foreach ($contents as $line) {
				if ($ln == 1 && $line != '<'.'?'.'php die() ?'.">\n") {
					$resave = true;
				}

				$ln++;
				$line = trim($line);
				$line = eregi_replace(';[.]*','',$line);
				if (strlen($line) > 0) {
					//echo $line . " - ";
					if(eregi('^[[a-z]+]$',str_replace(' ', '', $line))) {
						//echo 'section';
						$section = substr($line, 1, (strlen($line) - 2));
						if ($parse_section) {
							$retval[$section] = array();
						}
						continue;
					} elseif (eregi('=',$line)) {
						//echo 'main element';
						list ($key, $val) = explode(' = ', $line);
						if (!$parse_section) {
							$retval[trim($key)] = str_replace('"', '', $val);
						}
						else {
							$retval[$section][trim($key)] = str_replace('"', '', $val);
						}
					}
				}
			}

			if ($resave) {
				$fp = fopen($this->INIFile, 'w');
				reset($contents);
				fwrite($fp,'<'.'?'.'php die() ?'.">\n\n");
				foreach ($contents as $line) {
					fwrite($fp,"$line");
				}
				fclose($fp);
			}

			return $retval;
		}

		function SaveConfig()
		{
			$fp = fopen($this->INIFile, 'w');
			fwrite($fp,'<'.'?'.'php die() ?'.">\n\n");

			foreach ($this->systemConfig as $section_name => $section_data) {
				fwrite($fp, '['.$section_name."]\n");
				foreach ($section_data as $key => $value) {
					fwrite($fp, $key.' = "'.$value.'"'."\n");
				}
				fwrite($fp, "\n");
			}
			fclose($fp);
		}

		/**
		 * Installation error handler for sql errors
		 *
		 * @param int $code
		 * @param string $msg
		 * @param string $sql
		 * @return bool
		 * @access private
		 */
		function DBErrorHandler($code, $msg, $sql)
		{
			$this->errorMessage = 'Query: <br />'.htmlspecialchars($sql).'<br />execution result is error:<br />['.$code.'] '.$msg;
			return true;
		}

		/**
		 * Installation error handler
		 *
		 * @param int $errno
		 * @param string $errstr
		 * @param string $errfile
		 * @param int $errline
		 * @param Array $errcontext
		 */
		function ErrorHandler($errno, $errstr, $errfile = '', $errline = '', $errcontext = '')
		{
			if ($errno == E_USER_ERROR) {
				// only react on user fatal errors
				$this->Done($errstr);
			}
		}
	}

	/*function print_pre($s)
	{
		echo '<pre>', print_r($s, true). '</pre>';
	}*/


?>