<?php namespace ProcessWire;

/**
 * ProcessWire WireSaveableItemsLookup
 *
 * Provides same functionality as WireSaveableItems except that this class includes joining/modification of a related lookup table
 * 
 * ProcessWire 3.x, Copyright 2022 by Ryan Cramer
 * https://processwire.com
 *
 */

abstract class WireSaveableItemsLookup extends WireSaveableItems {

	/**
	 * If a lookup table should be left joined, this method should return the table name
	 *
	 */
	abstract public function getLookupTable();

	/**
	 * Cache of value returned from getLookupField() method
	 * 
	 * @var string|null
	 * 
	 */
	protected $lookupField = null;

	/**
	 * If a lookup table should be left joined, this method returns the name of the array field in $data that contains multiple values
	 * 
	 * i.e. roles_permissions becomes permissions_id if getTable() returns roles
	 * Does not need to be overridden unless the table naming structure doesn't follow existing logic.
	 *
	 */
	public function getLookupField() { 
		if($this->lookupField) return $this->lookupField;
		$lookupTable = $this->getLookupTable();
		if(!$lookupTable) return ''; 
		$this->lookupField = preg_replace('/_?' . $this->getTable() . '_?/', '', $lookupTable) . '_id';
		return $this->lookupField;
	}

	/**
	 * Get the DatabaseQuerySelect to perform the load operation of items
	 *
	 * @param Selectors|string|null $selectors Selectors or a selector string to find, or NULL to load all. 
	 * @return DatabaseQuerySelect
	 *
	 */
	protected function getLoadQuery($selectors = null) {
		$query = parent::getLoadQuery($selectors); 
		$database = $this->wire()->database;
		$table = $database->escapeTable($this->getTable());
		$lookupTable = $database->escapeTable($this->getLookupTable());	
		$lookupField = $database->escapeCol($this->getLookupField()); 
		$query->select("$lookupTable.$lookupField"); // QA 
		$query->leftjoin("$lookupTable ON $lookupTable.{$table}_id=$table.id ")->orderby("sort");
		// $query->leftjoin("$lookupTable ON $lookupTable.{$table}_id=$table.id ")->orderby("$table.id, $lookupTable.sort");
		return $query; 
	}

	/**
	 * Load items from the database table and return them in the same type class that getAll() returns
	 *
	 * A selector string or Selectors may be provided so that this can be used as a find() by descending classes that don't load all items at once.
	 *
	 * @param WireArray $items
	 * @param Selectors|string|null $selectors Selectors or a selector string to find, or NULL to load all.
	 * @return WireArray Returns the same type as specified in the getAll() method.
	 *
	 */
	protected function ___load(WireArray $items, $selectors = null) {

		$useLazy = $this->useLazy();
		$database = $this->wire()->database;
		$query = $this->getLoadQuery($selectors);
		$sql = $query->getQuery();
		
		$this->getLookupField(); // preload
		
		$stmt = $database->prepare($sql);
		$stmt->execute();
		$rows = $stmt->fetchAll(\PDO::FETCH_ASSOC);
		
		// note: non-use of lazyNameIndex/lazyIdIndex is intentional
	
		foreach($rows as $row) {
			if($useLazy) {
				$this->lazyItems[] = $row;
			} else {
				/** @var HasLookupItems $item */
				$this->initItem($row, $items);
			}
		}

		$stmt->closeCursor();
		$items->setTrackChanges(true);
		
		return $items; 
	}

	/**
	 * Create a new Saveable/Lookup item from a raw array ($row) and add it to $items
	 *
	 * @param array $row
	 * @param WireArray|null $items
	 * @return Saveable|HasLookupItems|WireData|Wire
	 * @since 3.0.194
	 *
	 */
	protected function initItem(array &$row, WireArray $items = null) {
		
		$lookupField = $this->getLookupField();
		$lookupValue = $row[$lookupField];
		$item = $this->makeBlankItem(); /** @var HasLookupItems $item */
		
		if($items === null) $items = $this->getWireArray();
		
		unset($row[$lookupField]);
		
		$item->addLookupItem($lookupValue, $row);

		foreach($row as $key => $value) {
			$item->$key = $value;
		}
		
		if($this->useLazy) {
			$items->add($item);
			foreach($this->lazyItems as $key => $a) {
				if($a['id'] != $row['id']) continue;
				if(!isset($a[$lookupField])) continue;
				$lookupValue = $a[$lookupField];
				unset($a[$lookupField]); 
				$item->addLookupItem($lookupValue, $a);
				unset($this->lazyItems[$key]);
			}

		} else if($items->has($item)) {
			// LEFT JOIN is adding more elements of the same item, i.e. from lookup table
			// if the item is already present in $items, then use the existing one rather 
			// and throw out the one we just created
			$item = $items->get($item);
			$item->addLookupItem($lookupValue, $row);
		} else {
			// add a new item
			$items->add($item);
		}

		return $item;
	}

	/**
	 * Should the given item key/field be saved in the database?
	 *
	 * Template method used by ___save()
	 * 
	 * @param string $key
	 * @return bool
	 *
	 */
	protected function saveItemKey($key) {
		if($key == $this->getLookupField()) return false; 
		return parent::saveItemKey($key); 
	}

	/**
	 * Save the provided item to database
	 * 
	 * @param Saveable $item
	 * @return bool
	 * @throws WireException
	 *
	 */
	public function ___save(Saveable $item) {

		if(!$item instanceof HasLookupItems) {
			$class = $this->className();
			throw new WireException("$class::save() requires an item that implements HasLookupItems interface");
		}
	
		$database = $this->wire()->database; 	
		$lookupTable = $database->escapeTable($this->getLookupTable());
		$lookupField = $database->escapeCol($this->getLookupField());
		$table = $database->escapeTable($this->getTable());
		$item_id = (int) $item->id; 

		if($item_id) {
			$query = $database->prepare("DELETE FROM $lookupTable WHERE {$table}_id=:item_id");
			$query->bindValue(":item_id", $item_id, \PDO::PARAM_INT);
			$query->execute();
		}
			
		$result = parent::___save($item); 
		$item_id = (int) $item->id; // reload, in case it was 0 before

		$sort = 0; 
		if($item_id) {
			$sql = "INSERT INTO $lookupTable SET {$table}_id=:item_id, $lookupField=:value_id, sort=:sort";
			$query = $database->prepare($sql);
			foreach($item->getLookupItems() as $key => $value) {
				$value_id = (int) $value->id;
				$query->bindValue(":item_id", $item_id, \PDO::PARAM_INT);
				$query->bindValue(":value_id", $value_id, \PDO::PARAM_INT);
				$query->bindValue(":sort", $sort, \PDO::PARAM_INT);
				$query->execute();
				$sort++;
			}
			$this->resetTrackChanges();
		}

		return $result;	
	}

	/** 
	 * Delete the provided item from the database
	 *
	 * @param Saveable $item
	 * @return bool
	 * 
	 */
	public function ___delete(Saveable $item) {
		$database = $this->wire()->database;
		$lookupTable = $database->escapeTable($this->getLookupTable()); 
		$table = $database->escapeTable($this->getTable()); 
		$item_id = (int) $item->id; 
		$query = $database->prepare("DELETE FROM $lookupTable WHERE {$table}_id=:item_id"); // QA
		$query->bindValue(":item_id", $item_id, \PDO::PARAM_INT);
		$query->execute();
		return parent::___delete($item); 
	}
	
	/**
	 * debugInfo PHP 5.6+ magic method
	 *
	 * This is used when you print_r() an object instance.
	 *
	 * @return array
	 *
	 */
	public function __debugInfo() {
		$info = parent::__debugInfo();
		$info['loaded'] = array_unique($info['loaded']);
		$info['notLoaded'] = array_unique($info['notLoaded']);
		return $info;
	}

}