<?php
namespace Lib;

use PDO;
use Lib\Router;

class Abstract_model {
	
	const SAVE_TYPE_INSERT = 'insert';
	const SAVE_TYPE_UPDATE = 'update';
	
	protected static $id_field = 'id';	
	protected static $relationships = array ();	
	protected static $parents = array();
	
	/**
	 * Returns array of errors if errors happened, FALSE if no error occured.
	 * @param array $data
	 */
	public static function is_invalid(Array $data) {}
	public static function get_table() {}
	
	public static function get_grid_fields() {}
	
	public static function get_current_model_name() {
		return strtolower( 
			basename(
                            \str_replace('\\', '/', get_called_class())
			)
		);
	}
	
	public static function get_namespaced_model_path($model) {
		$model = Router::retrieve_class_name ( $model );
		$model_with_namespace = '\\Model\\' . $model;
		return $model_with_namespace;
	}
	
	public static function build_select_by_options(Array $options = array()) {

		$where = ' WHERE ';
		$and = '';
		$table = static::get_table ();
		if (	isset($options['filter_model_key']) && 
				$options['filter_model_key'] != null &&
				isset($options['filter_model_value']) &&
				$options['filter_model_value'] != null &&
				$options['filter_model_value'] != '' ) {

			$relationship = static::$relationships[$options['filter_model_key']];
			$sql = " FROM " . $table .
				   ' LEFT JOIN ' . $relationship['table'] .
				   ' ON '. $relationship['table'] . '.' . $relationship['id_field'] . 
				   ' = ' . $table . '.' . static::$id_field .
				   $where . $and . $relationship['table'] . '.' . $relationship['relation_field'];
			
			if ($options['filter_model_value'] == 'na') {
				$sql .= ' IS NULL ';
			} else {
				$sql .= ' = ' . $options['filter_model_value'];				
			}
			$where = '';
			$and = ' AND ';
		} else {
			$sql = " FROM " . static::get_table ();
		}
		if (isset ( $options ['where'] )) {
			$sql .= $where . $and . $options ['where'];
		}
		return $sql;
	}
	
	public static function count(Array $options = array()) {
		
		global $pdo;
		
		$sql = "SELECT COUNT(*) as count " . static::build_select_by_options($options);
		
		$stmt = $pdo->query ( $sql );
		$stmt->execute ();
		$row = $stmt->fetch ( PDO::FETCH_ASSOC );
		$count = $row ['count'];
		return $count;
	}
	
	public static function fetch(Array $options = array()) {
		
		global $pdo;
		
		$table = static::get_table ();
		$sql = "SELECT DISTINCT ${table}.* " .   static::build_select_by_options($options);
		
		if (isset ( $options ['order_by'] )) {
			$sql .= ' ORDER BY ' . $options ['order_by'];
		}
		
		if (isset ( $options ['limit'] )) {
			$sql .= ' LIMIT ' . $options ['limit'];
		}
		
		if (isset ( $options ['offset'] )) {
			$sql .= ' OFFSET ' . $options ['offset'];
		}

		$stmt = $pdo->query ( $sql );
		return $stmt;
	}
	
	public static function fetch_all(Array $options = array()) {
		$stmt = static::fetch ( $options );
		$data = $stmt->fetchAll ( PDO::FETCH_ASSOC );
		return $data;
	}
	
	public static function save(Array $data) {
		
		$response = array ('validation' => true );
		
		$errors = static::is_invalid ( $data );
		if ($errors !== false) {
			$response ['validation'] = $errors;
			return $response;
		}
		
		$data ['updated_on'] = date ( DATETIME_FORMAT_PHP );
		if (! is_numeric ( $data [static::$id_field] )) {
			$data = static::insert ( $data );
			$response ['save_type'] = static::SAVE_TYPE_INSERT;
		} else {
			static::update ( $data );
			$response ['save_type'] = static::SAVE_TYPE_UPDATE;
		}
		
		static::save_relationships($data);
		
		$response ['data'] = $data;
		
		return $response;
	}
	
	public static function save_relationship($model_key, $id, $related_ids) {
		
		global $pdo;
	
		$relationship = static::$relationships[$model_key];
		
		$save = function($pdo, $relationship, $id, $related_id) {
					
			$sql =  'INSERT INTO ' . $relationship['table'] . 
					'( '. $relationship['id_field'].' , '. $relationship['relation_field'] .' ) ' .
					'VALUES (' . $id . ' , ' . $related_id . ' )';
			$pdo->query($sql);		
			
		};
		
		if (is_array($related_ids)) {
			foreach($related_ids as $related_id) {			
				$save($pdo, $relationship, $id, $related_id);
			}			
		} else {
			$save($pdo, $relationship, $id, $related_ids);		
		}
	}
	
	public static function save_relationships(Array $data) {
         
		$id = $data[static::$id_field];
				
		foreach ( static::$relationships as $model_key => $relationship ) {
			if ($relationship['always_save'] == true) {
				static::delete_relationship($model_key, $id);
				if (isset($data[$model_key]) ) {
					static::save_relationship($model_key, $id, $data[$model_key]);
				}
			} 
		}
	}
	
	public static function insert(Array $data) {
		global $pdo;
		$sql = 'INSERT INTO ' . static::get_table () . ' ';

		$sql_data = array ();
		$sql_fields = '(';
		$sql_values = '(';
		$comma = '';
		
		foreach ( $data as $field => $value ) {
			if ($field != static::$id_field && !isset(static::$relationships[$field])) {
				$sql_data [':' . $field] = $value;
				$sql_fields .= $comma . $field;
				$sql_values .= $comma . ':' . $field;
				$comma = ', ';
			}
		}
		$sql_fields .= ')';
		$sql_values .= ')';
		
		$sql .= $sql_fields . ' VALUES ' . $sql_values;
		
		$stmt = $pdo->prepare ( $sql );
		$stmt->execute ( $sql_data );
		$data [static::$id_field] = $pdo->lastInsertId ();
		return $data;
	}
	
	public static function update(Array $data) {
		global $pdo;
		$sql = 'UPDATE ' . static::get_table () . ' SET ';
		
		$sql_data = array ();
		$sql_fields = '(';
		$sql_values = '(';
		$comma = '';
		
		foreach ( $data as $field => $value ) {
			if ($field != static::$id_field && !isset(static::$relationships[$field])) {
				$sql_data [':' . $field] = $value;
				$sql .= $comma . $field . ' = :' . $field;
				$comma = ', ';
			}
		}
		$sql .= ' WHERE ' . static::$id_field . ' = ' . $data [static::$id_field];
		
		$stmt = $pdo->prepare ( $sql );
		$stmt->execute ( $sql_data );		
	}
	
	public static function load($id) {
		global $pdo;
		
		$sql = 'SELECT * FROM ' . static::get_table () . ' WHERE ' . static::$id_field . ' = ' . $id;
		$stmt = $pdo->query ( $sql );
		$response = array ();
		$response ['data'] = $stmt->fetch ( PDO::FETCH_ASSOC );
		
		$response['relationships'] = static::load_relationships($id);
		
		return $response;
	}
	
	public static function load_relationship($model_key, $id) {
		global $pdo;
		
		$relationship = static::$relationships[$model_key];
		
		$sql =  'SELECT  ' . $relationship['relation_field'] .
				' FROM ' . $relationship['table'] .
				' WHERE ' . $relationship['id_field'] . ' = ' . $id;
		$stmt = $pdo->query($sql);
		return $stmt->fetchAll(PDO::FETCH_COLUMN);		
	}
	
	public static function load_relationships($id) {
		$relationships = array();
		foreach ( static::$relationships as $model_key => $relationship ) {
			if ($relationship['always_load'] == true) {
				$relationships[$model_key] = static::load_relationship($model_key, $id);
			} 
		}		
		return $relationships;
	}
	
	public static function delete($id) {
		global $pdo;
		
		static::delete_parent_relationships($id);
		static::delete_relationships ( $id );
		$sql = 'DELETE FROM ' . static::get_table () . ' WHERE ' . static::$id_field . ' = ' . $id;
		$stmt = $pdo->query ( $sql );
	}
	
	public static function jqgrid($page, $limit, $sidx, $sord, $filter_model_key = null, $filter_model_value = null) {
		if (! $sidx) {
			$sidx = 1;
		}
		
		$offset = max ( 0, $limit * $page - $limit ); // do not put $limit*($page - 1)
		$order_by = "$sidx $sord";
		
		$options = array (
			'offset' => $offset, 
			'limit' => $limit, 
			'order_by' => $order_by, 
			'filter_model_key' => $filter_model_key,
			'filter_model_value' => $filter_model_value 
		);
		
		$count = static::count ($options);
		
		if ($count > 0) {
			$total_pages = ceil ( $count / $limit );
		} else {
			$total_pages = 0;
		}
		if ($page > $total_pages) {
			$page = $total_pages;
		}
				
		$response = array ();
		$response ['page'] = $page;
		$response ['total'] = $total_pages;
		$response ['records'] = $count;
		
		$stmt = static::fetch ( $options );
		
		$grid_fields = static::get_grid_fields ();
		$i = 0;
		
		while ( ($row = $stmt->fetch ( PDO::FETCH_ASSOC )) !== false ) {
			$response ['rows'] [$i] [static::$id_field] = $row [static::$id_field];
			
			$cell = array ();
			foreach ( $grid_fields as $field ) {
				$cell [] = $row [$field];
			}
			
			$response ['rows'] [$i] ['cell'] = $cell;
			$i ++;
		}
		return $response;
	}
	
	public static function delete_relationship($model_key, $id) {
		global $pdo;
		$relationship = static::$relationships [$model_key];
		$sql = 'DELETE FROM ' . $relationship ['table'] . ' WHERE ' . $relationship ['id_field'] . ' = ' . $id;
		$stmt = $pdo->query ( $sql );
	}
	
	public static function delete_relationships($id) {
		foreach ( static::$relationships as $model_key => $relationship ) {
			static::delete_relationship($model_key, $id);
		}	
	}
	
	public static function delete_parent_relationship($parent_model, $id) {
		global $pdo;
		$parent_model = static::get_namespaced_model_path($parent_model);
		$current_model = static::get_current_model_name();
		$relationship = $parent_model::$relationships[$current_model];
		$sql = 'DELETE FROM ' . $relationship ['table'] . ' WHERE ' . $relationship ['relation_field'] . ' = ' . $id;
		$stmt = $pdo->query ( $sql );
	}
	
	public static function delete_parent_relationships($id) {
		foreach(static::$parents as $parent_model) {
			static::delete_parent_relationship( $parent_model, $id);		
		}
	}
}