<?php
/**
 * Copyright 2017 Wim van Ravesteijn
 *
 * This file is part of AEGEE-Europe Statutory Event Applications.
 *
 * AEGEE-Europe Statutory Event Applications is free software: you can
 * redistribute it and/or modify it under the terms of the GNU General
 * Public License as published by the Free Software Foundation, either
 * version 3 of the License, or (at your option) any later version.
 *
 * AEGEE-Europe Statutory Event Applications is distributed in the hope
 * that it will be useful, but WITHOUT ANY WARRANTY; without even the
 * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 * PURPOSE.  See the GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with AEGEE-Europe Statutory Event Applications.  If not, see
 * <http://www.gnu.org/licenses/>.
 */

require_once dirname(__FILE__) . "/IDB.php";
require_once dirname(__FILE__) . "/DBMethod.php";
require_once dirname(__FILE__) . "/DBWhere.php";

class QueryBuilder {
	private $db;

	private $table;
	
	private $alias;

	private $fields = array();

	private $joins = array();

	private $where = array();

	private $group = array();
	
	private $having = array();

	private $order = array();

	private $limit = -1;

	private $offset = -1;

	public function __construct(IDB $db, $table, $alias = NULL) {
		$this->db = $db;
		$this->table = $table;
		$this->alias = $alias;
	}

	public function addField($field, $as = NULL) {
		if( is_array($field) ) {
			foreach( $field as $singleField ) {
				$this->fields[] = $this->db->escapeField($singleField);
			}
		}else {
			$this->fields[] = $this->db->escapeField($field) . ($as == NULL ? "" : " AS " . $this->db->escapeField($as));
		}
	}
	
	public function addLeftJoin($table, $field, $joinOn, $as = NULL) {
		$this->addJoin($table, $field, $joinOn, "LEFT", $as);
	}

	public function addInnerJoin($table, $field, $joinOn, $as = NULL) {
		$this->addJoin($table, $field, $joinOn, "INNER", $as);
	}

	private function addJoin($table, $field, $joinOn, $joinMethod, $as = NULL) {
		$join = $joinMethod . " JOIN " . $this->db->escapeField($table);
		if( $as == NULL ) {
			$baseTablename = $table;
		}else {
			$join .= " " . $this->db->escapeField($as);
			$baseTablename = $as;
		}
		$join .= " ON ";
		if( is_array($field) && is_array($joinOn) ) {
			$joinParts = array();
			for( $i = 0; $i < count($field); $i++ ) {
				if( $field[$i] instanceof DBMethod ) {
					$joinParts[] = $this->db->escapeField($field[$i]) . " = " . $this->db->escapeField($joinOn[$i]);
				}else {
					$joinParts[] = $this->db->escapeField($baseTablename . "." . $field[$i]) . " = " . $this->db->escapeField($joinOn[$i]);
				}
			}
			$join .= implode(" AND ", $joinParts);
		}elseif( $field instanceof DBMethod ) {
			$join .= $this->db->escapeField($field) . " = " . $this->db->escapeField($joinOn);
		}else {
			$join .= $this->db->escapeField($baseTablename . "." . $field) . " = " . $this->db->escapeField($joinOn);
		}
		$this->joins[] = $join;
	}

	public function addWhere(DBWhere $where) {
		$this->where[] = $where->toQuery($this->db);
	}

	public function addWhereEquals($field, $value) {
		$this->addWhere(new DBWhereEquals($field, $value));
	}

	public function addWhereEqualsField($field1, $field2) {
		$this->addWhere(new DBWhereEqualsField($field1, $field2));
	}

	public function addWhereNotEquals($field, $value) {
		$this->addWhere(new DBWhereNotEquals($field, $value));
	}

	public function addWhereGreaterEquals($field, $value) {
		$this->addWhere(new DBWhereGreaterEquals($field, $value));
	}

	public function addWhereSmallerEquals($field, $value) {
		$this->addWhere(new DBWhereSmallerEquals($field, $value));
	}

	public function addWhereGreater($field, $value) {
		$this->addWhere(new DBWhereGreater($field, $value));
	}

	public function addWhereSmaller($field, $value) {
		$this->addWhere(new DBWhereSmaller($field, $value));
	}

	public function addWhereIn($field, array $values) {
		$this->addWhere(new DBWhereIn($field, $values));
	}

	public function addWhereIsNull($field) {
		$this->addWhere(new DBWhereIsNull($field));
	}

	public function addWhereIsNotNull($field) {
		$this->addWhere(new DBWhereIsNotNull($field));
	}

	public function addGroup($field) {
		$this->group[] = $this->db->escapeField($field);
	}
	
	public function addHaving(DBWhere $having) {
		$this->having[] = $having->toQuery($this->db);
	}

	public function addHavingEquals($field, $value) {
		$this->addHaving(new DBWhereEquals($field, $value));
	}
	
	public function addHavingEqualsField($field1, $field2) {
		$this->addHaving(new DBWhereEqualsField($field1, $field2));
	}
	
	public function addHavingNotEquals($field, $value) {
		$this->addHaving(new DBWhereNotEquals($field, $value));
	}
	
	public function addHavingGreaterEquals($field, $value) {
		$this->addHaving(new DBWhereGreaterEquals($field, $value));
	}
	
	public function addHavingSmallerEquals($field, $value) {
		$this->addHaving(new DBWhereSmallerEquals($field, $value));
	}
	
	public function addHavingGreater($field, $value) {
		$this->addHaving(new DBWhereGreater($field, $value));
	}
	
	public function addHavingSmaller($field, $value) {
		$this->addHaving(new DBWhereSmaller($field, $value));
	}
	
	public function addHavingIn($field, array $values) {
		$this->addHaving(new DBWhereIn($field, $values));
	}
	
	public function addHavingIsNull($field) {
		$this->addHaving(new DBWhereIsNull($field));
	}
	
	public function addHavingIsNotNull($field) {
		$this->addHaving(new DBWhereIsNotNull($field));
	}
	
	public function addOrderAsc($field) {
		$this->order[] = $this->db->escapeField($field) . " ASC";
	}

	public function addOrderDesc($field) {
		$this->order[] = $this->db->escapeField($field) . " DESC";
	}
	
	public function addOrderRandom() {
		$this->order[] = "RAND()";
	}

	public function setLimit($limit) {
		$this->limit = $limit;
	}

	public function setOffset($offset) {
		$this->offset = $offset;
	}

	public function toQuery() {
		$query = "SELECT ";
		if( count($this->fields) > 0 ) {
			$query .= implode(", ", $this->fields);
		}else {
			$query .= "*";
		}
		$query .= " FROM " . $this->db->escapeField($this->table);
		if( $this->alias != NULL ) {
			$query .= " AS " . $this->db->escapeField($this->alias);
		}
		if( count($this->joins) > 0 ) {
			$query .= " " . implode(" ", $this->joins);
		}
		if( count($this->where) > 0 ) {
			$query .= " WHERE " . implode(" AND ", $this->where);
		}
		if( count($this->group) > 0 ) {
			$query .= " GROUP BY " . implode(", ", $this->group);
		}
		if( count($this->having) > 0 ) {
			$query .= " HAVING " . implode(", ", $this->having);
		}
		if( count($this->order) > 0 ) {
			$query .= " ORDER BY " . implode(", ", $this->order);
		}
		if( $this->limit >= 0 ) {
			$query .= " LIMIT " . $this->db->escapeValue($this->limit);
			if( $this->offset >= 0 ) {
				$query .= " OFFSET " . $this->db->escapeValue($this->offset);
			}
		}
		return $query;
	}
}
?>