<?php namespace ProcessWire;

/**
 * ProcessWire Repeater Fieldtype
 *
 * Maintains a collection of fields that are repeated for any number of times.
 *
 * For documentation about how Fieldtypes work, see: 
 * /wire/core/Fieldtype.php
 * /wire/core/FieldtypeMulti.php
 * 
 * ProcessWire 3.x, Copyright 2022 by Ryan Cramer
 * https://processwire.com
 *
 * @todo: automatic sorting.
 * 
 * @property int $repeatersRootPageID
 * @method saveConfigInputfields(Field $field, Template $template, Page $parent)
 * @method readyPageSaved(Page $readyPage, Page $ownerPage, Field $field) Hook called when ready page is saved
 * 
 * Page status notes for repeater items: 
 * - Unpublished & Hidden: Ready page, not yet used. Appears in unformatted repeater PageArray but user has not saved it.
 * - Unpublished & On: Publish requested and can be published as long as no input errors. 
 * - Unpublished & NOT On: Item has been unpublished.
 * 
 * Unpublished or hidden pages do not appear in formatted PageArray value, only in unformatted. 
 *
 */

class FieldtypeRepeater extends Fieldtype implements ConfigurableModule {

	public static function getModuleInfo() {
		return array(
			'title' => __('Repeater', __FILE__), // Module Title
			'summary' => __('Maintains a collection of fields that are repeated for any number of times.', __FILE__), // Module Summary
			'version' => 112,
			'autoload' => true,
			'installs' => 'InputfieldRepeater'
		);
	}
	
	const devMode = false; // display verbose TD messages

	const templateNamePrefix = 'repeater_';
	const fieldPageNamePrefix = 'for-field-';
	const repeaterPageNamePrefix = 'for-page-'; 
	const defaultRepeaterMaxItems = 0;
	const repeatersRootPageName = 'repeaters';

	const collapseExisting = 0;
	const collapseNone = 3;
	const collapseAll = 1;
	
	const loadingNew = 0;
	const loadingAll = 1;
	const loadingOff = 2;

	/**
	 * Field names used by repeaters in format [ PW_instanceID => [ 'field_name', 'field_name2' ] ];
	 * 
	 * @var array
	 * 
	 */
	static protected $fieldsUsedInRepeaters = array();

	/**
	 * Template IDs used by repeaters in format [ PW_instanceID => [ 123, 456, 789 ] ]
	 * 
	 * @var array
	 * 
	 */
	static protected $templatesUsedByRepeaters = array();
	
	/**
	 * Has ready method been called? [ PW_instanceID => true | false ]
	 *
	 * @var bool
	 *
	 */
	static protected $isReady = array();
	
	/**
	 * Fields that are initialized [ PW_instanceID => [ 'field_id' => true ] ]
	 *
	 * @var bool
	 *
	 */
	static protected $initFields = array();

	/**
	 * ProcessWire instance ID
	 *
	 * @var int
	 *
	 */
	protected $instanceID = 0;

	/**
	 * When non-zero, a deletePageField function call occurred and we shouldn't re-create any repeater parents
	 *
	 * The value it contains is the ID of the parent page used by the field for repeater items
	 *
	 */
	protected $deletePageField = 0;

	/**
	 * Page assigned by our ProcessPageEdit::ajaxSave hook, kept for comparison for editable() access
	 * 
	 * @var Page
	 *
	 */
	protected $ajaxPage;

	/**
	 * Name of field that appeared in HTTP_X_FIELDNAME, before it was modified
	 *
	 */
	protected $ajaxFieldName = '';

	/**
	 * Use lazy loading mode?
	 *
	 * @var null|bool
	 *
	 */
	protected $useLazy = null;

	/**
	 * Construct the Repeater Fieldtype
	 *
	 */
	public function __construct() {

		require_once(dirname(__FILE__) . '/RepeaterPage.php'); 
		require_once(dirname(__FILE__) . '/RepeaterPageArray.php'); 

		$this->set('repeatersRootPageID', 0); 	
		
		parent::__construct();
	}

	/**	
	 * Setup a hook to Pages::delete so that we can remove references when pages are deleted
	 *
	 */
	public function init() {
		$this->instanceID = $this->wire()->getProcessWireInstanceID();
		self::$initFields[$this->instanceID] = array();
		$this->wire()->pages->addHookAfter('deleteReady', $this, 'hookPagesDelete');
		$this->useLazy = $this->wire()->config->useLazyLoading;
		parent::init();
	}

	/**	
	 * Setup a hook so that we can keep ajax saves working with ProcessPageEdit
	 *
	 */
	public function ready() {
		parent::ready();
	
		if(!empty(self::$isReady[$this->instanceID])) return; // ensures everything below only runs only once (for extending types)
		self::$isReady[$this->instanceID] = true;

 		$page = $this->wire()->page;
 		$process = $page->process; /** @var Process|null $process */
		$user = $this->wire()->user;
		$config = $this->wire()->config;
		$input = $this->wire()->input;
		$modules = $this->wire()->modules;
		$inEditor = wireInstanceOf($process, 'ProcessPageEdit') || $process == 'ProcessProfile';
		$isSuperuser = $user->isSuperuser();
		
		// @todo would the following line be needed in some contexts (like ListerPro?)
		// if(!$inEditor && $process && wireInstanceOf($process, 'WirePageEditor')) $inEditor = true;
		
		// make sure that all templates used by repeater pages enforce a Page type of RepeaterPage
		// this was necessary when lazy loading option was disabled
		if(!$this->useLazy) $this->initAllFields();

		if($inEditor) {
			// ProcessPageEdit or ProcessProfile
			$this->addHookBefore('ProcessPageEdit::ajaxSave', $this, 'hookProcessPageEditAjaxSave', array('priority' => 99));
		}
		
		if($inEditor && $config->ajax) {
			// handle scenario of repeater within repeater field
			$fieldName = (string) $input->get('field');
			$pageID = (int) $input->get('id');
			if($pageID && strpos($fieldName, '_repeater') && preg_match('/^(.+)_repeater\d+($|\.)/', $fieldName, $matches)) {
				$this->initAllFields();
				$editPage = $this->wire()->pages->get($pageID);
				if($editPage->id && strpos($editPage->template->name, self::templateNamePrefix) === 0) {
					// update field name to exclude the _repeater1234 part at the end, so that PageEdit recognizes it
					$input->get->__set('field', $this->wire()->sanitizer->fieldName($matches[1]));
				}
			}
			// handle scenario of file upload or other ajax saved field
			if(isset($_SERVER['HTTP_X_FIELDNAME'])) {
				// initialize all repeater fields so RepeaterPage class names are active for access control
				if(strpos($_SERVER['HTTP_X_FIELDNAME'], '_repeater')) $this->initAllFields();
			}
		}
		
		if(!$inEditor && !$user->isGuest() && !$isSuperuser && $user->hasPermission('page-edit')) {
			// allow for front-end editor to also trigger an inEditor=true condition
			if(strpos($page->url, $config->urls->admin) === false && $page->editable()) {
				if($this->wire()->modules->isInstalled('PageFrontEdit')) $inEditor = true;
			}
		}
	
		if($inEditor && !$isSuperuser) {
			// need an extra hook to handle permissions
			$this->addHookAfter('PagePermissions::pageEditable', $this, 'hookPagePermissionsPageEditableAjax');
		}
		
		$this->addHookBefore('PageFinder::getQuery', $this, 'hookPageFinderGetQuery');
	
		$class = $this->className() . 'Matrix';
		if($this->useLazy && $modules->isInstalled($class)) $modules->get($class);

	}
	
	/**
	 * Called when field of this type is initialized at boot or after lazy loaded
	 *
	 * #pw-internal
	 *
	 * @param Field $field
	 * @since 3.0.194
	 *
	 */
	public function initField(Field $field) {
		if(!empty(self::$initFields[$this->instanceID][$field->id])) return;
		parent::initField($field);
		if(!$this->useLazy) return;
		self::$initFields[$this->instanceID][$field->id] = true;
		/** @var FieldtypeRepeater $fieldtype */
		$fieldtype = $field->type;
		if(!$fieldtype instanceof FieldtypeRepeater) return;
		$template = $fieldtype->getRepeaterTemplate($field);
		if(!$template) return;
		$class = $fieldtype->getPageClass();
		if(__NAMESPACE__ && $class) $class = wireClassName($class);
		$_class = $template->get('pageClass');
		if($class === $_class) return;
		$template->set('pageClass', $class);
		$template->save();
	}


	/**
	 * Force initialize of all repeater fields, confirming their configuration settings are correct
	 * 
	 * @since 3.0.199
	 * 
	 */
	public function initAllFields() {
		if(!empty(self::$initFields['*'])) return;
		self::$initFields['*'] = true;
		$repeaterFields = $this->wire()->fields->findByType('FieldtypeRepeater', array(
			'inherit' => true,
			'valueType' => 'field',
			'indexType' => '',
		));
		$useLazy = $this->useLazy;
		$this->useLazy = true;
		foreach($repeaterFields as $field) {
			$this->initField($field);
		}
		$this->useLazy = $useLazy;
	}

	/**
	 * Get class name to use Field objects of this type (must be class that extends Field class)
	 *
	 * Return blank if default class (Field) should be used.
	 *
	 * @param array $a Field data from DB (if needed)
	 * @return string Return class name or blank to use default Field class
	 * @since 3.0.146
	 *
	 */
	public function getFieldClass(array $a = array()) {
		require_once(dirname(__FILE__) . '/RepeaterField.php');
		return 'RepeaterField';
	}

	/**
	 * Get the class used for repeater Page objects
	 * 
	 * @return string
	 * 
	 */
	public function getPageClass() {
		return __NAMESPACE__ . "\\RepeaterPage";
	}

	/**
	 * Get the class used for repeater PageArray objects
	 *
	 * @return string
	 * 
	 */
	public function getPageArrayClass() {
		return __NAMESPACE__ . "\\RepeaterPageArray";
	}

	/**
	 * Hook called after PagePermissions::pageEditable() when Process is ProcessPageEdit and call is ajax
	 * 
	 * @param HookEvent $event
	 * 
	 */
	public function hookPagePermissionsPageEditableAjax(HookEvent $event) {
		
		if($event->return) return;
	
		/** @var Page|RepeaterPage $page */
		$page = $event->arguments(0);
		if(!$page instanceof RepeaterPage) {
			$t = $page->template;
			if(strpos("$t", "repeater_") === 0) {
				$this->bd("Page $page ($t) has wrong class ($page->className != $t->pageClass)", __FUNCTION__, true); 
			}
			return;
		}
		
		$forField = $page->getForField();
		$n = 0;
		
		while($page instanceof RepeaterPage) {
			$forField = $page->getForField();
			$page = $page->getForPage();
			if(++$n > 20) break;
		}
		
		if(!$page || !$page->id || $page instanceof RepeaterPage) {
			// no owning forPage found
			$event->return = false;
			return;
		}
		
		// found the original owning page (forPage)
		
		$editable = null;
		$user = $this->wire()->user;
		$input = $this->wire()->input;
		$fieldName = $input->get('field');
		
		if($fieldName) {
			$_fieldName = $fieldName;
			$fieldName = $this->wire()->sanitizer->fieldName($fieldName);
			if($fieldName === $_fieldName) {
				$field = $this->wire()->fields->get($fieldName);
			} else {
				$field = null;
				$editable = false;
			}
		} else {
			$field = $forField;
		}
		
		if($page instanceof User && $field && $field->type instanceof FieldtypeRepeater) {
			// editing a repeater field in a User
			if($user->hasPermission('user-admin')) {
				$editable = true;
			} else if($page->id === $user->id) {
				// user editing themself, repeater field
				/** @var PagePermissions $pagePermissions */
				$pagePermissions = $this->wire()->modules->get('PagePermissions');
				$editable = $pagePermissions->userFieldEditable($field);
			}
		}
		
		if($editable === null) $editable = $page->editable();
		
		$event->return = $editable;
	}

	/**
	 * Hook into PageFinder::getQuery
	 *
	 * Determines if the query is attempting to directly search a field used by a repeater. 
	 * If it is, then it specifically excludes them. This is so that one could use a 'title' field
	 * in both a repeater and elsewhere, and not worry about repeaters themselves appearing in 
	 * search results for an admin.
	 * 
	 * @param HookEvent $event
	 *
	 */
	public function hookPageFinderGetQuery(HookEvent $event) {

		/** @var Selectors $selectors */
		$selectors = $event->arguments[0]; 
		/** @var PageFinder $pageFinder */
		$pageFinder = $event->object; 
		$pageFinderOptions = $pageFinder->getOptions();

		// determine which fields are used in repeaters
		if(!isset(self::$fieldsUsedInRepeaters[$this->instanceID])) {
			$fieldNames = array('title' => 'title'); // title used by admin template (repeater parents)
			$templates = $this->wire()->templates;
			$templateIds = array();
			$allTemplateNames = $templates->getAllValues('name', 'id');
			$fieldgroups = $this->wire()->fieldgroups;
			foreach($allTemplateNames as $templateId => $templateName) {
				if(strpos($templateName, self::templateNamePrefix) !== 0) continue;
				$templateIds[$templateName] = $templateId;
				foreach($fieldgroups->getFieldNames($templateName) as /* $fieldId => */ $fieldName) {
					$fieldNames[$fieldName] = $fieldName;
				}
			}
			self::$fieldsUsedInRepeaters[$this->instanceID] = array_values($fieldNames);
			self::$templatesUsedByRepeaters[$this->instanceID] = array_values($templateIds);
		}
		
		$fieldsUsedInRepeaters = self::$fieldsUsedInRepeaters[$this->instanceID];
		$templatesUsedByRepeaters = self::$templatesUsedByRepeaters[$this->instanceID];

		// did we find a field used by a repeater in the selector?
		$found = false;

		// was include=all specified?
		$includeAll = !empty($pageFinderOptions['findAll']);

		// if user is guest, then repeater pages will already be excluded (since they don't have view access to them) so no need for extra filter
		if(!$includeAll && $this->wire()->user->isGuest()) $includeAll = true; 

		// determine if any of the fields used in the selector are also used in a repeater
		// and set $found and $includeAll as appropriate
		if(!$includeAll) foreach($selectors as $selector) {

			$fields = $selector->field; 
			if(!is_array($fields)) $fields = array($fields);

			foreach($fields as $name) {

				if(strpos($name, '.')) {
					/** @noinspection PhpUnusedLocalVariableInspection */
					list($name, $unused) = explode('.', $name); // field.subfield
				}

				// is field name one used by a repeater?
				if(in_array($name, $fieldsUsedInRepeaters)) $found = true;

				if($name == 'status' && $selector->operator == '<' && $selector->value == Page::statusMax) {
					// include=all is the same as status<Page::statusMax, so we look for that here
					$includeAll = true;
				} else if(in_array($name, array('parent', 'parent_id', 'template', 'templates_id')) && $selector->operator == '=') {
					// optimization: if parent, parent_id, template, or templates_id is given, and an equals '=' operator is used, 
					// there's no need to explicitly exclude repeaters since the parent and/or template is specific
					$includeAll = true;
				} else if($name == 'templates_id' && $selector->operator == '=' && in_array($selector->value, $templatesUsedByRepeaters)) {
					// ensure that the repeaters own queries work since they specify a templates_id
					// note: this is now redundent given the code added directly above this, but kept for clarification
					$includeAll = true;
				} else if($name == 'has_parent' && $selector->value != 1 && $selector->operator == '=' && $selector->value != '/') {
					// if has_parent is specified and is not homepage, no need to exclude results
					$includeAll = true;
				}

				if($includeAll) break;
			}
			
			if($includeAll) break;
		}

		// if field is one used by a repeater, and there was no include=all, 
		// then exclude repeaters from appearing in these PageFinder search results
		if($found && !$includeAll) {
			// for reference: $selectors->add(new SelectorNotEqual('has_parent', $this->repeatersRootPageID)); 
			$selectors->add(new SelectorNotEqual('templates_id', $templatesUsedByRepeaters)); // more efficient than has_parent
		}
	}

	/**
	 * This hook is called before ProcessPageEdit::ajaxSave
	 *
	 * We modify the HTTP_X_FIELDNAME var to remove the "_repeater123" portion of the variable, 
	 * since ProcessPageEdit doesn't know about repeaters. 
	 * 
	 * @param HookEvent $event
	 *
 	 */
	public function hookProcessPageEditAjaxSave(HookEvent $event) {

		// if this isn't a repeater field we're dealing with, then abort
		if(!isset($_SERVER['HTTP_X_FIELDNAME'])) return; 
		if(strpos($_SERVER['HTTP_X_FIELDNAME'], '_repeater') === false) return;
		if(!preg_match('/^(.+)(_repeater(\d+))(?:$|\.)/', $_SERVER['HTTP_X_FIELDNAME'], $matches)) return;
		
		$sanitizer = $this->wire()->sanitizer;
		$fieldName = $sanitizer->fieldName($matches[1]); 
		$repeaterPageID = (int) $matches[3]; 
		if($repeaterPageID < 1) return;

		// make sure the owning page is editable since we'll be replacing the $page param that goes to ajaxSave
		/** @var Page $ownerPage */
		$ownerPage = $event->arguments[0]; 
		if(!$ownerPage->editable()) return;

		// make sure it's a valid repeaterPage
		$repeaterPage = $this->wire()->pages->get($repeaterPageID); 
		if(!$repeaterPage->id) return; 

		// check that the given repeaterPage is actually a repeater component of the ownerPage
		if($repeaterPage->id != $ownerPage->id && !$this->isRepeaterItemValidOnPage($repeaterPage, $ownerPage)) {
			$this->error("Repeater item $repeaterPage not valid for owner page $ownerPage");
			return;
		}
		
		// repopulate the ProcessPageEdit::ajaxSave function's argument to be the repeaterPage rather than the ownerPage
		$args = $event->arguments; 
		$args[0] = $repeaterPage; 
		$event->arguments = $args; 

		$ajaxFieldName = $_SERVER['HTTP_X_FIELDNAME'];
		if(strpos($ajaxFieldName, '.')) {
			// field.subfield combination, i.e. FieldtypeCombo ajax subfield
			list($ajaxFieldName, $ajaxSubfieldName) = explode('.', $ajaxFieldName, 2);
			$ajaxFieldName = $sanitizer->fieldName($ajaxFieldName);
			$ajaxSubfieldName = $sanitizer->name($ajaxSubfieldName);
			$this->ajaxFieldName = $ajaxFieldName;
			// repopulate the server header to be the fieldName (sans _repeater\d+)
			$_SERVER['HTTP_X_FIELDNAME'] = "$fieldName.$ajaxSubfieldName";
		} else {
			$this->ajaxFieldName = $sanitizer->fieldName($_SERVER['HTTP_X_FIELDNAME']);
			// repopulate the server header to be the fieldName (sans _repeater\d+)
			$_SERVER['HTTP_X_FIELDNAME'] = $fieldName;
		}

		// save a copy for comparison in our hookPageEditable function 
		$this->ajaxPage = $repeaterPage;

		// add a hook to allow edit access because some users may not have access
		// to the repeater pages themselves, and ProcessPageEdit's editable check
		// prevents them from completing the ajax save. this hook fixes that.
		$this->addHookAfter('ProcessPageEdit::ajaxEditable', $this, 'hookProcessPageEditAjaxEditable'); 

		// ensures that InputfieldFile outputs markup with the proper fieldname, including the repeater_ part
		$this->addHookBefore('InputfieldFile::renderItem', $this, 'hookInputfieldFileRenderItem'); 
	}

	/**
	 * Is the given repeater item valid on the given owner page?
	 * 
	 * @param Page $repeaterItem
	 * @param Page $ownerPage
	 * @return null|Field Returns the repeater Field object that is valid, or null if not valid
	 * 
	 */
	protected function isRepeaterItemValidOnPage(Page $repeaterItem, Page $ownerPage) {
		
		$hasField = null;
		$repeaters = array();
		
		foreach($ownerPage->fieldgroup as $f) {
			/** @var Field $f */
			if(!$f->type instanceof FieldtypeRepeater) continue;
			$repeaters[$f->name] = $f->name;
			$grandparent = $this->getRepeaterParent($f);
			$name = self::repeaterPageNamePrefix . $ownerPage->id; 
			$parent = $grandparent->child("name=$name, include=all");
			if(!$parent->id) continue;
			$child = $parent->child("include=all, id=$repeaterItem->id");
			if($child->id) {
				// found it, it's valid
				$hasField = $f;
				break;
			}
		}
		
		if($hasField) return $hasField;
		
		// check for nested repeater
		foreach($repeaters as $name) {
			$repeaterItems = $ownerPage->get($name);	
			if(!$repeaterItems) continue;
			if($repeaterItems instanceof PageArray) {
				foreach($repeaterItems as $nestedOwnerPage) {
					// perform recursive check
					$hasField = $this->isRepeaterItemValidOnPage($repeaterItem, $nestedOwnerPage);
					if($hasField) break;
				}
			} else if($repeaterItems instanceof RepeaterPage) {
				// for single item value (i.e. FieldtypeFieldsetPage)
				$hasField = $this->isRepeaterItemValidOnPage($repeaterItem, $repeaterItems);
			} else {
				// continue;
			}
		}
		
		return $hasField;
	}

	/**
	 * Temporary hook into Page::editable to capture the editable check for the page we swapped into the ajaxSave
	 *
	 * Prevents the 'no access' error when non-superuser attempts to perform an ajax save
	 * 
	 * @param HookEvent $event
	 *
	 */
	public function hookProcessPageEditAjaxEditable(HookEvent $event) {
		/** @var Page $page */
		$page = $event->arguments[0]; 
		$fieldName = isset($event->arguments[1]) ? $this->wire()->sanitizer->fieldName($event->arguments[1]) : '';
		if($page->id && $this->ajaxPage && $this->ajaxPage->id == $page->id) {
			$event->return = true; 
		}

		// if a fieldName was specified, double check that it's a valid field in a repeater
		if($event->return && $fieldName) {
			if(!$this->ajaxPage->hasField($fieldName)) $event->return = false;
		}
	}

	/**
	 * Ensure that InputfieldFile outputs markup with the proper fieldname (including the repeater_ part)
	 * 
	 * @param HookEvent $event
	 *
	 */
	public function hookInputfieldFileRenderItem(HookEvent $event) {
		$arguments = $event->arguments; 
		$id = $arguments[1]; 
		$id = str_replace($_SERVER['HTTP_X_FIELDNAME'], $this->ajaxFieldName, $id); 
		$arguments[1] = $id; 
		$event->arguments = $arguments; 
	
		// update id attribute of the Inputfield itself
		// so that anything in InputfieldFile referring to it's overall id attribute
		// reflects the actual id attribute of the Inputfield
		/** @var Inputfield $inputfield */
		$inputfield = $event->object; 
		$id = $inputfield->attr('id');
		$id = str_replace($_SERVER['HTTP_X_FIELDNAME'], $this->ajaxFieldName, $id); 
		$inputfield->attr('id', $id); 
	}

	/**
	 * Delete any repeater pages that are owned by a page that was deleted
	 * 
	 * @param HookEvent $event
	 *
	 */
	public function hookPagesDelete(HookEvent $event) {

		$page = $event->arguments[0];
		$pages = $this->wire()->pages;

		foreach($page->template->fieldgroup as $field) {
			if(!$field->type instanceof FieldtypeRepeater) continue; 
			$fieldParent = $pages->get($field->parent_id); 	
			if(!$fieldParent->id) continue; 
			$p = $fieldParent->child('include=all, name=' . self::repeaterPageNamePrefix . $page->id); 	
			if($p->id && $this->deleteRepeaterPage($p, $field, true)) {
				$this->bd("Deleted page $p->path for page $page->path", __FUNCTION__);
			}
		}
	}

	/**
	 * FieldtypeRepeater instances are only compatible with other FieldtypeRepeater derived classes. 
	 *
	 * @param Field $field 
	 * @return WireArray
	 *
	 */
	public function ___getCompatibleFieldtypes(Field $field) {
		$fieldtypes = parent::___getCompatibleFieldtypes($field); 
		foreach($fieldtypes as $type) if(!$type instanceof FieldtypeRepeater) $fieldtypes->remove($type); 
		return $fieldtypes; 
	}

	/**
	 * Get a blank value of this type, i.e. return a blank PageArray
	 *
	 * @param Page $page
	 * @param Field $field
	 * @return PageArray|RepeaterPageArray
	 *
	 */
	public function getBlankValue(Page $page, Field $field) {
		$class = $this->getPageArrayClass();
		$pageArray = $this->wire(new $class($page, $field));
		$pageArray->setTrackChanges(true);
		return $pageArray;
	}

	/**
	 * Returns a unique name for a repeater page
	 *
	 * @return string
	 *
	 */
	public function getUniqueRepeaterPageName() {
		static $cnt = 0;
		return str_replace('.', '-', microtime(true)) . '-' . (++$cnt);
	}

	/**
	 * Get the class for the Inputfield (template method)
	 * 
	 * @return string
	 * 
	 */
	protected function getInputfieldClass() {
		return 'InputfieldRepeater';
	}

	/**
	 * Return an InputfieldRepeater, ready to be used
	 *
	 * @param Page $page Page being edited
	 * @param Field $field Field that needs an Inputfield
	 * @return Inputfield
	 *
	 */
	public function getInputfield(Page $page, Field $field) {

		/** @var InputfieldRepeater $inputfield */
		$inputfield = $this->wire()->modules->get($this->getInputfieldClass()); 
		$inputfield->set('page', $page); 
		$inputfield->set('field', $field);
		$inputfield->set('repeaterMaxItems', (int) $field->get('repeaterMaxItems'));
		$inputfield->set('repeaterMinItems', (int) $field->get('repeaterMinItems')); 
		$inputfield->set('repeaterDepth', (int) $field->get('repeaterDepth'));
		$inputfield->set('repeaterReadyItems', 0);  // ready items deprecated

		$pageArray = $page->getUnformatted($field->name); 
		if(!$pageArray instanceof PageArray) $pageArray = $this->getBlankValue($page, $field); 
		
		// we want to check that this page actually has the field before creating ready pages
		// this is just since PW may call getInputfield with a dummyPage (usually homepage) for tests
		// and we don't want to go on creating readyPages or setting up parent/template where not used
		if($page->hasField($field)) {
			if(!count($pageArray)) {
				// force the wakeup function to be called since it wouldn't have been for a field that doesn't yet exist
				$pageArray = $this->wakeupValue($page, $field, null);
			}
		}
		$page->set($field->name, $pageArray); 
		$inputfield->attr('value', $pageArray); 

		return $inputfield; 
	}

	/**
	 * Get next page ready to be used as a new repeater item, creating it if it doesn't already exist
	 * 
	 * @param Page $page
	 * @param Field $field
	 * @param PageArray|Page $value
	 * @param array $notIDs Optional Page IDs that should be excluded from the next ready page
	 * @return Page
	 * 
	 */
	public function getNextReadyPage(Page $page, Field $field, $value = null, array $notIDs = array()) {
		$database = $this->wire()->database;
		$readyPage = null;
		if($value) {
			if($value instanceof Page) $value = array($value); 
			foreach($value as $item) {
				/** @var Page $item */
				if($item->hasStatus(Page::statusUnpublished) 
					&& $item->hasStatus(Page::statusHidden) 
					&& $item->id
					&& substr($item->name, -1) !== 'c' // cloned item
					&& !in_array($item->id, $notIDs)) {
					// existing/unused ready item that we will reuse	
					$readyPage = $item;
					// touch the modified date for existing page to identify it as still current
					$query = $database->prepare('UPDATE pages SET modified=NOW(), modified_users_id=:user_id WHERE id=:id');
					$query->bindValue(':id', $readyPage->id, \PDO::PARAM_INT);
					$query->bindValue(':user_id', $this->wire('user')->id, \PDO::PARAM_INT);
					$query->execute();
					break;
				}
			}
		}
		if(!$readyPage) {
			$readyPage = $this->getBlankRepeaterPage($page, $field);
			$readyPage->sort = count($value);
			$readyPage->save();
		}
		$readyPage->setQuietly('_repeater_new', 1);
		$this->readyPageSaved($readyPage, $page, $field); 
		return $readyPage;
	}

	/**
	 * Hook called when a ready page is saved
	 * 
	 * @param Page $readyPage
	 * @param Page $ownerPage
	 * @param Field $field
	 * 
	 */
	protected function ___readyPageSaved(Page $readyPage, Page $ownerPage, Field $field) {
		// for hooks only
	}

	/**
	 * Returns a blank page ready for use as a repeater
	 *
	 * Also ensures that the parent repeater page exists.
	 * This is public so that the Inputfield can pull from it too.
	 *
	 * @param Page $page The page that the repeater field lives on
	 * @param Field $field
	 * @return Page
	 *
	 */
	public function getBlankRepeaterPage(Page $page, Field $field) {
		if($this->deletePageField === $field->get('parent_id')) $this->deletePageField = 0;
		$parent = $this->getRepeaterPageParent($page, $field); 
		$class = $this->getPageClass();
		/** @var RepeaterPage $readyPage */
		$readyPage = $this->wire(new $class());
		$readyPage->template = $this->getRepeaterTemplate($field);
		if($parent->id) $readyPage->parent = $parent; 
		$readyPage->addStatus(Page::statusOn); // request publish for new items by defalt
		$readyPage->addStatus(Page::statusHidden); // ready page
		$readyPage->addStatus(Page::statusUnpublished); // ready page
		$readyPage->name = $this->getUniqueRepeaterPageName();
		$readyPage->setForPage($page);
		$readyPage->setForField($field);
		return $readyPage; 
	}

	/**
	 * Given a raw value (value as stored in DB), return the value as it would appear in a Page object
	 *
	 * Something to note is that this wakeup function is different than most in that the $value it is given 
	 * is just an array like array('data' => 123, 'parent_id' => 456) -- it doesn't actually contain any of the
	 * repeater page data other than saying how many there are and the parent where they are stored. So this 
	 * wakeup function can technically do it's job without even having the $value, unlike most other fieldtypes.
	 *
	 * @param Page $page
	 * @param Field $field
	 * @param array $value
	 * @return PageArray $value
	 *
	 */
	public function ___wakeupValue(Page $page, Field $field, $value) {

		$field_parent_id = $field->get('parent_id'); 
		$template_id = $field->get('template_id'); 
		// $outputFormatting = $page->outputFormatting();

		// if it's already in the target format, leave it
		if(!is_array($value) && $value instanceof PageArray) return $value; 

		// if this field has no parent set, just return a blank pageArray
		if(!$field_parent_id) return $this->getBlankValue($page, $field); 

		if(is_array($value) && !empty($value['parent_id'])) {
			// this is what we get if there was a record in the DB and the parent has been setup
			$parent_id = (int) $value['parent_id'];

		} else if(empty($value['data']) && empty($value['parent_id']) && $this->useLazyParents($field)) {
			// no record in the DB yet and parent will not be created till needed
			$parent = $this->getRepeaterPageParent($page, $field, false); 
			$parent_id = $parent->id;

		} else {
			// no record in the DB yet, so setup the parent if it isn't already
			$parent = $this->getRepeaterPageParent($page, $field); 
			$parent_id = $parent->id; 
		}

		// get the template_id used by the repeater pages
		if(!$template_id) $template_id = $this->getRepeaterTemplate($field)->id; 

		// if we were unable to determine a parent for some reason, then just return a blank pageArray
		if(!$parent_id || !$template_id) {
			$pageArray = $this->getBlankValue($page, $field);
			return $pageArray;
		}

		// build the selector: find pages with our parent
		// $selector = "parent_id=$parent_id, templates_id=$template_id, sort=sort, check_access=0";
		$selector = "parent_id=$parent_id, templates_id=$template_id, sort=sort, include=all";

		/*
		if($outputFormatting) { 
			// if an unpublished page is being previewed, let unpublished items be shown (ready items will be removed afterwards)
			if($page->hasStatus(Page::statusUnpublished) && $page->editable($field->name)) $selector .= ", include=all"; 
		} else {
			// if the page is an edit state, then make it include the hidden/unpublished ready pages
			if($page->editable($field->name)) $selector .= ", include=all";
		}
		*/
		
		$template = $this->wire()->templates->get((int) $template_id);
		$pageArrayClass = $this->getPageArrayClass();
		/** @var RepeaterPageArray $pageArray */
		$pageArray = $this->wire(new $pageArrayClass($page, $field)); 

		// load the repeater pages
		$options = array(
			'cache' => false, 
			'caller' => $this->className() . '::wakeupValue',
			'loadOptions' => array(
				'cache' => false, 
				'parent_id' => $parent_id, 
				'template' => $template,
				'pageClass' => $this->getPageClass(),
				'pageArray' => $pageArray, 
			)
		);
		
		$pageArray = $this->wire()->pages->find($selector, $options);
		$pageArray->resetTrackChanges(true);

		return $pageArray; 

	}

	/**
	 * Given an 'awake' value, as set by wakeupValue, convert the value back to a basic type for storage in DB. 
	 *
	 * In this case, the sleepValue doesn't represent the actual value as they are stored in pages. 
	 *              
	 * @param Page $page
	 * @param Field $field
	 * @param string|int|array|object $value
	 * @return array
	 *
	 */
	public function ___sleepValue(Page $page, Field $field, $value) {

		$sleepValue = array();

		// if value is already an array, then just return it
		if(is_array($value)) return $sleepValue; 
	
		// if $value isn't a PageArray, then abort	
		if(!$value instanceof PageArray) return array();
		
		/** @var RepeaterPageArray $value */

		$numPublished = 0; 
		$numTotal = 0;
		$ids = array();

		// iterate through the array and count how many published we have
		foreach($value as $p) {
			$numTotal++;
			if(!$p->id || $p->isHidden() || $p->isUnpublished()) continue; 
			$ids[] = $p->id;
			$numPublished++;
		}
		
		if(!$numTotal && $this->useLazyParents($field)) {
			$parent = $this->getRepeaterPageParent($page, $field, false);
			$sleepValue = array(
				'data' => '',
				'count' => 0,
				'parent_id' => $parent->id
			);	
			
		} else {
			// our sleepValue is simply just the total number of repeater pages
			// a cache of page IDs in 'data' (for export portability)
			// and a quick reference to the parent where they are contained
			$parent = $this->getRepeaterPageParent($page, $field);
			$sleepValue = array(
				'data' => implode(',', $ids),
				'count' => $numPublished,
				'parent_id' => $parent->id
			);
		}
		
		return $sleepValue;
	}

	/**
	 * Export repeater value
	 * 
	 * @param Page $page
	 * @param Field $field
	 * @param RepeaterPageArray $value
	 * @param array $options
	 *  - `minimal` (bool): Export a minimal array of just fields and values indexed by repeater page name (default=false)
	 * @return array
	 * 
	 */
	public function ___exportValue(Page $page, Field $field, $value, array $options = array()) {
		
		$a = array();
		if(!WireArray::iterable($value)) return $a;
	
		if(!empty($options['minimal']) || !empty($options['FieldtypeRepeater']['minimal'])) {
			// minimal export option includes only fields data
			
			foreach($value as $p) {
				/** @var Page $p */
				if($p->isUnpublished()) continue;
				$v = array(); 
				foreach($p->template->fieldgroup as $f) {
					/** @var Field $f */
					if(!$p->hasField($f)) continue;
					$fieldtype = $f->type; /** @var Fieldtype $fieldtype */
					$v[$f->name] = $fieldtype->exportValue($p, $f, $p->getUnformatted($f->name), $options);
				}
				$a[$p->name] = $v;
			}
			
		} else {
			// regular export
			/** @var PagesExportImport $exporter */
			$exporter = $this->wire(new PagesExportImport());
			$a = $exporter->pagesToArray($value, $options);
		}
		
		return $a;
	}

	/**
	 * Import repeater value previously exported by exportValue()
	 * 
	 * @param Page $page
	 * @param Field $field
	 * @param array $value
	 * @param array $options
	 * @return bool|PageArray
	 * @throws WireException
	 * 
	 */
	public function ___importValue(Page $page, Field $field, $value, array $options = array()) {
		
		if(empty($value['type']) || $value['type'] != 'ProcessWire:PageArray') {
			throw new WireException("$field->name: Invalid repeater importValue() \$value argument"); 
		}
		
		if(!$page->id) {
			$page->trackChange($field->name); 
			throw new WireException("$field->name: Repeater will import after page is created");
		}
		
		$repeaterParent = $this->getRepeaterPageParent($page, $field);
		$repeaterTemplate = $this->getRepeaterTemplate($field);
		$repeaterPageClass = $this->getPageClass();
		$repeaterPageArrayClass = $this->getPageArrayClass();
		$parentPath = $repeaterParent->path();
		$commit = isset($options['commit']) ? (bool) $options['commit'] : true;
		$messages = array();
		$numAdded = 0;
		$changesByField = array();
		$numUpdated = 0;
		$numDeleted = 0;
		$itemsAdded = array();
		$itemsDeleted = array();
		$importItemNames = array();
		$existingValue = $page->get($field->name); 
		
		if(!$existingValue instanceof PageArray) { // i.e. FieldsetPage
			$existingValue = $existingValue->id ? array($existingValue) : array();
		}
		
		$pages = $this->wire()->pages;
		
		// update paths for local
		foreach($value['pages'] as $key => $item) {
			$name = $item['settings']['name'];
			if(strpos($name, self::repeaterPageNamePrefix) === 0 && count($value['pages']) == 1) {
				$name = self::repeaterPageNamePrefix . $page->id;  // i.e. FieldsetPage	
				$value['pages'][$key]['settings']['name'] = $name;
			}
			$path = $parentPath . $name . '/';
			$importItemNames[$name] = $name;
			$value['pages'][$key]['path'] = $path;
			$p = $pages->get($path); 
			if($p->id) continue; // already exists
			
			// from this point forward, it is assumed we are creating a new repeater item
			$numAdded++;
			$page->trackChange($field->name); 
			
			if($commit) {
				// create new repeater item, ready to be populated
				/** @var RepeaterPage $p */
				$p = $this->wire(new $repeaterPageClass());
				if($repeaterParent->id) $p->parent = $repeaterParent;
				$p->template = $repeaterTemplate;
				$p->name = $name;
				$p->setForPage($page);
				$p->setForField($field);
				$p->save();
				$itemsAdded[$p->id] = $p;
				if($p->name != $name) $importItemNames[$p->name] = $p->name;
			}
		}

		if($page->get('_importType') == 'update') {
			foreach($existingValue as $p) {
				if(!isset($importItemNames[$p->name])) {
					$itemsDeleted[] = $p;
					$numDeleted++;
				}
			}
		}
	
		/** @var RepeaterPageArray $pageArray */
		$pageArray = $this->wire(new $repeaterPageArrayClass($page, $field));
		
		$importOptions = array(
			'commit' => $commit, 
			'create' => true, 
			'update' => true, 
			'delete' => true, // @todo 
			'pageArray' => $pageArray
		);
		
		/** @var PagesExportImport $importer */
		$importer = $this->wire(new PagesExportImport()); 
		$pageArray = $importer->arrayToPages($value, $importOptions); 	
		
		foreach($pageArray as $p) {
			$changes = $p->get('_importChanges'); 
			if(!count($changes)) continue;
			if(isset($itemsAdded[$p->id]) || !$p->id) continue;
			$numUpdated++;
			foreach($changes as $fieldName) {
				if(!isset($changesByField[$fieldName])) $changesByField[$fieldName] = 0;
				$changesByField[$fieldName]++;
			}
			$this->wire()->notices->move($p, $pageArray, array('prefix' => "$field->name (id=$p->id): ")); 
		}
		
		if($numDeleted && $commit) {
			foreach($itemsDeleted as $p) {
				$pages->delete($p); 
			}
		}
		
		if($numUpdated) {
			$updateCounts = array();
			foreach($changesByField as $fieldName => $count) {
				$updateCounts[] = "$fieldName ($count)";	
			}
			$messages[] = "$numUpdated page(s) updated – " . implode(', ', $updateCounts);
		}
		
		if($numAdded) $messages[] = "$numAdded new page(s) added";
		if($numDeleted) $messages[] = "$numDeleted page(s) DELETED";
		
		foreach($messages as $message) {
			$pageArray->message("$field->name: $message");
		}
		
		$pageArray->resetTrackChanges();
		
		$totalChanges = $numUpdated + $numAdded + $numDeleted;
		if(!$totalChanges) {
			// prevent it from being counted as a change when import code sets the value back to the page
			$page->setQuietly($field->name, $pageArray);
		}
	
		return $pageArray;
	}

	/**
	 * Get associative array of options (name => default) that Fieldtype supports for importValue
	 * 
	 * #pw-internal
	 *
	 * @param Field $field
	 * @return array
	 *
	 */
	public function getImportValueOptions(Field $field) {
		$options = parent::getImportValueOptions($field);
		$options['test'] = true; 
		return $options; 
	}

	/**
	 * Get information used by selectors for querying this field
	 *
	 * @param Field $field
	 * @param array $data
	 * @return array
	 *
	 */
	public function ___getSelectorInfo(Field $field, array $data = array()) {
		/** @var FieldtypePage $fieldtype */
		$fieldtype = $this->wire()->modules->get('FieldtypePage');
		$info = $fieldtype->getSelectorInfo($field, $data);
		$info['operators'] = array(); // force it to be non selectable, subfields only
		return $info;
	}

	/**
	 * Get repeaters root page
	 * 
	 * @return Page
	 * @since 3.0.188
	 * 
	 */
	public function getRepeatersRootPage() {
		$pages = $this->wire()->pages;
		$page = $pages->get((int) $this->repeatersRootPageID); 
		if($page->id && $page->name === self::repeatersRootPageName) return $page;
		$page = $pages->get($this->wire()->config->adminRootPageID)->child('name=repeaters, include=all');
		return $page;
	}

	/**
	 * Return the parent used by the repeater pages for the given Page and Field
	 *
	 * i.e. /processwire/repeaters/for-field-12/for-page-123/
	 *
	 * @param Page $page
	 * @param Field $field
	 * @param bool $create Create if not exists? (default=true) 3.0.188+
	 * @return Page|NullPage
	 *
	 */
	public function getRepeaterPageParent(Page $page, Field $field, $create = true) {

		$repeaterParent = $this->getRepeaterParent($field);
		$parentName = self::repeaterPageNamePrefix . $page->id; // for-page-123
		$parent = $repeaterParent->child("name=$parentName, include=all");
		
		if($parent->id || !$create) return $parent;

		$parent = $this->wire()->pages->newPage($repeaterParent->template);
		$parent->parent = $repeaterParent; 
		$parent->name = $parentName;
		$parent->title = $page->name;
		$parent->addStatus(Page::statusSystem);

		// exit early if a field is in the process of being deleted
		// so that a repeater page parent doesn't get automatically re-created
		if($this->deletePageField === $field->get('parent_id')) return $parent; 

		$parent->save();
		
		$this->bd("Created '$field' page parent: $parent->path", __FUNCTION__);

		return $parent; 
	}

	/**
	 * Return the repeater parent used by $field, i.e. /processwire/repeaters/for-field-123/
	 * 
	 * Auto generate a repeater parent page named 'for-field-[id]', if it doesn't already exist
	 *
	 * @param Field $field
	 * @return Page
	 * @throws WireException
	 *
	 */
	public function getRepeaterParent(Field $field) {
		
		$pages = $this->wire()->pages;
		$parentID = (int) $field->get('parent_id');
		
		if($parentID) {
			$parent = $pages->get($parentID); 
			if($parent->id) {
				if($parent->title != $field->name) $parent->setAndSave('title', $field->name);
				return $parent;
			}
		}

		$repeatersRootPage = $this->getRepeatersRootPage();
		$parentName = self::fieldPageNamePrefix . $field->id; // for-field-123

		// we call this just to ensure it exists, so template is created if it doesn't exist yet
		if(!$field->get('template_id')) $this->getRepeaterTemplate($field); 

		$parent = $repeatersRootPage->child("name=$parentName, include=all"); 

		if(!$parent->id) {
			$parent = $pages->newPage($repeatersRootPage->template);
			$parent->parent = $repeatersRootPage; 
			$parent->name = $parentName;
			$parent->title = $field->name; 
			$parent->addStatus(Page::statusSystem);
			$parent->save();
			$this->bd("Created '$field' parent: $parent->path", __FUNCTION__);
		}

		if($parent->id) {
			if(!$field->get('parent_id')) {
				// parent_id setting not yet in field
				$field->set('parent_id', $parent->id); 
				$field->save();
			}
		} else {
			throw new WireException("Unable to create parent {$repeatersRootPage->path}$parentName"); 
		}

		return $parent; 
	}

	/**
	 * Update repeater template and fieldgroup to have same name as field
	 * 
	 * @param Template $template Template having old name
	 * @param string $name New name for template
	 * 
	 */
	protected function updateRepeaterTemplateName(Template $template, $name) {
	
		if($template->name != $name && !$this->wire()->templates->get($name)) {
			$this->bd("Renamed repeater template from '$template->name' to '$name'", __FUNCTION__);
			$flags = $template->flags;
			$template->flags = Template::flagSystemOverride; // required before flags=0
			$template->flags = 0;
			$template->save();
			$template->name = $name;
			$template->flags = $flags;
			$template->save();
		}
	
		if($template->fieldgroup && $template->fieldgroup->name != $name && !$this->wire()->fieldgroups->get($name)) {
			$template->fieldgroup->name = $name;
			$template->fieldgroup->save();
		}
	}	

	/**
	 * Return the repeater template used by Field, i.e. repeater_name
	 * 
	 * Auto generate a repeater template, if it doesn't already exist.
	 *
	 * @param Field $field
	 * @return Template
	 * @throws WireException
	 *
	 */
	protected function getRepeaterTemplate(Field $field) {

		$templates = $this->wire()->templates;
		$fieldgroups = $this->wire()->fieldgroups;
		
		$template = null;
		$templateID = (int) $field->get('template_id');
		$templateName = self::templateNamePrefix . $field->name; 
		
		if($templateID) {
			$template = $templates->get($templateID);
			if($template && $template->name !== $templateName) {
				// repeater has been renamed, update the template and fieldgroup names
				$this->updateRepeaterTemplateName($template, $templateName);
			}
		}

		// if template already exists, return it now
		if($template) return $template;

		// make sure the template name isn't already in use, make a unique one if it is
		$n = 0; 
		while($templates->get($templateName) || $fieldgroups->get($templateName)) {
			$templateName = self::templateNamePrefix . $field->name . (++$n); 
		}

		// create the fieldgroup
		$fieldgroup = $this->wire(new Fieldgroup()); /** @var Fieldgroup $fieldgroup */
		$fieldgroup->name = $templateName;
		$fieldgroup->save();	

		if(!$fieldgroup->id) throw new WireException("Unable to create repeater fieldgroup: $templateName"); 

		// create the template
		$template = $this->wire(new Template()); /** @var Template $template */
		$template->name = $templateName; 
		$template->fieldgroup = $fieldgroup; 
		$this->populateRepeaterTemplateSettings($template); 
		$template->save();

		if(!$template->id) throw new WireException("Unable to create template: $templateName"); 

		// save the template_id setting to the field
		$field->set('template_id', $template->id); 	
		$field->save();

		$this->bd("Created '$field' template: $template", __FUNCTION__);

		return $template; 
	}

	/**
	 * Populate the settings for a newly created repeater template
	 * 
	 * @param Template $template
	 * 
	 */
	protected function populateRepeaterTemplateSettings(Template $template) {
		$template->flags = Template::flagSystem;
		$template->noChildren = 1;
		$template->noParents = 1; // prevents users from creating pages with this template, but not us
		$template->noGlobal = 1; 
	}

	/**
	 * Handles the sanitization and convertion to PageArray value
	 *
	 * @param Page $page
	 * @param Field $field
	 * @param mixed $value
	 * @return PageArray|RepeaterPageArray
	 *
	 */
	public function sanitizeValue(Page $page, Field $field, $value) {

		// if they are setting it to a PageArray, then we'll take it
		if($value instanceof PageArray) return $value; 

		// otherwise, lets get the current value so we can add to it or return it
		$pageArray = $page->get($field->name); /** @var RepeaterPageArray $pageArray */

		// if no value was provided, then return the existing value already in the page
		if(!$value) return $pageArray; 

		// if it's a string, see if we can convert it to a Page or PageArray
		if(is_string($value)) $value = $this->sanitizeValueString($page, $field, $value); 

		// if it's a Page, and not  NullPage, add it to the existing PageArray
		if($value instanceof Page) {
			$pageArray->add($value); 
			return $pageArray; 
		}

		// if it's a new PageArray, combine it with the existing PageArray
		if($value instanceof PageArray) {
			foreach($value as $pg) {
				if(!$pg->id) continue; 
				$pageArray->add($pg); 
			}
			return $pageArray; 
		}

		if(!is_array($value)) $value = array($value); 
		
		foreach($value as $p) $pageArray->add($p); 

		return $pageArray; 
	}

	/**
	 * Given a string value return a Page or PageArray
	 *	
	 * @param Page $page
	 * @param Field $field
	 * @param string $value
	 * @return Page|PageArray
	 *
	 */
	public function sanitizeValueString(Page $page, Field $field, $value) {
		
		$pages = $this->wire()->pages;
		$result = false;

		if(ctype_digit("$value")) {
			// single page ID
			$result = $pages->get((int) $value); 

		} else if(strpos($value, ',')) {
			// csv string of page IDs
			$value = explode(',', $value); 	
			$result = array();
			foreach($value as $v) {
				$v = (int) $v; 
				if($v) $result[] = $v; 
			}
			// @todo confirm this is the parent_id we want (field parent_id vs page parent_id)
			$result = $pages->getById($result, $this->getRepeaterTemplate($field), $field->get('parent_id'));  

		} else if(Selectors::stringHasOperator($value)) {
			// selector
			// @todo confirm this is the parent_id we want (field parent_id vs page parent_id)
			$parentID = $field->get('parent_id');
			$templateID = $field->get('template_id');
			$result = $pages->find("parent_id=$parentID, templates_id=$templateID, $value");

		} else if(strlen($value) && $value[0] == '/') {
			// path
			$result = $pages->get($value); 
		}

		return $result; 
	}

	/**
	 * Perform output formatting on the value delivered to the API
	 *
	 * This method is only used when $page->outputFormatting is true. 
	 * 
	 * @param Page $page
	 * @param Field $field
	 * @param PageArray $value
	 * @return PageArray
	 *
	 */
	public function ___formatValue(Page $page, Field $field, $value) {
		
		$maxItems = (int) $field->get('repeaterMaxItems');

		if(!$value instanceof PageArray) $value = $this->getBlankValue($page, $field);

		// used as a clone if a formatted version of $value is different from non-formatted
		$formatted = null;
		$cnt = 0;

		// remove unpublished and ready items that shouldn't be here
		foreach($value as $p) {
			$cnt++;
			if($p->isHidden() || $p->isUnpublished() || ($maxItems && $cnt > $maxItems)) {
				if(is_null($formatted)) $formatted = clone $value;
				/** @var Page $formatted */
				$trackChanges = $formatted->trackChanges();
				$formatted->setTrackChanges(false); 
				$formatted->remove($p); 
				$formatted->setTrackChanges($trackChanges); 
				$cnt--;
			}
		}

		return is_null($formatted) ? $value : $formatted;
	}

	/**
	 * Update a DatabaseQuerySelect object to match a Page
	 *
	 * @param PageFinderDatabaseQuerySelect $query
	 * @param string $table
	 * @param string $subfield
	 * @param string $operator
	 * @param string $value
	 * @return PageFinderDatabaseQuerySelect
	 * @throws WireException
	 *
	 */
	public function getMatchQuery($query, $table, $subfield, $operator, $value) {

		$field = $query->field;

		if($subfield == 'count') { 
			$value = (int) $value; 

			if(	($operator == '=' && $value == 0) || 
				(in_array($operator, array('<', '<=')) && $value > -1) ||
				($operator == '!=' && $value) || ($operator === '>=' && $value == 0)) {
				
				$templateIds = array();
				foreach($field->getTemplates() as $t) {
					/** @var Template $t */
					$templateIds[] = (int) $t->id;
				}

				if(count($templateIds)) {
					$templateIds = implode(',', $templateIds);
					$fieldTable = $field->getTable();
					$joinTable = "cnt_repeater_$table";
					$parentQuery = $query->parentQuery;
					$parentQuery->leftjoin(
						"$fieldTable AS $joinTable " . 
						"ON pages.templates_id IN($templateIds) " . 
						"AND $joinTable.pages_id=pages.id " 
					);
					$parentQuery->where(
						"(($joinTable.count{$operator}$value OR $joinTable.pages_id IS NULL) " .
						"AND pages.templates_id IN($templateIds))"
					);
				} else {
					$query->where('1>2');
				}

			} else {
				$query->where("($table.count{$operator}$value)"); 
			}

		} else if($subfield == 'parent_id' || $subfield == 'parent') {  

			$subfield = 'parent_id';
			if(is_object($value)) $value = (string) $value; 
			$value = (int) $value;
			$query->where("($table.$subfield{$operator}$value)"); 

		} else if($subfield == 'data' || $subfield == 'id' || !$subfield) {
			
			// support matching of IDs via word matching fulltext index
			if(ctype_digit("$value") && !empty($value)) {
				if($subfield === 'id') $subfield = 'data';
				if($operator === '=') { 
					$operator = '~=';
				} else if($operator === '!=') {
					// @todo specify NOT
					$operator = '~=';
				}
			}

			if(in_array($operator, array('*=', '~=', '^=', '$=', '%='))) {
				/** @var DatabaseQuerySelectFulltext $ft */
				$ft = $this->wire(new DatabaseQuerySelectFulltext($query));
				$ft->match($table, $subfield, $operator, $value);

			} else if(empty($value)) {
				// empty/0 value
				if($operator === '=' && $subfield === 'id') {
					$query->where('1>2'); // force non-match
				} else {
					// match where count is 0
					$query->where("$table.count{$operator}0");
				}

			} else {
				// match /path/to/page or other, not implemented
			}
			
		} else {
			$f = $this->wire()->fields->get($subfield);
			if(!$f) return $query; // unknown subfield
			
			// match fields from the repeater template
			// perform a separate find() operation for the subfield
			
			/** @var PageFinder $pageFinder */
			$pageFinder = $this->wire(new PageFinder()); 
			$value = $this->wire()->sanitizer->selectorValue($value);
			$templateID = $field->get('template_id');
			/** @var Selectors $selectors */
			$selectors = $this->wire(new Selectors("templates_id=$templateID, check_access=0, $f->name$operator$value"));
			$matches = $pageFinder->find($selectors);

			// use the IDs found from the separate find() as our getMatchQuery
			if(count($matches)) {
				$ids = array();
				foreach($matches as $match) {
					$parentID = (int) $match['parent_id'];
					$ids[$parentID] = $parentID;
				}
				$query->where("$table.parent_id IN(" . implode(',', $ids) . ")");
			} else {
				$query->where("1>2");  // force a non-match
			}
		}

		return $query; 
	}

	/**
	 * Return the database schema in predefined format 
	 * 
	 * @param Field $field
	 * @return array
	 *
	 */
	public function getDatabaseSchema(Field $field) {

		$schema = parent::getDatabaseSchema($field); 

		// fields
		$schema['data'] = 'text NOT NULL';
		$schema['count'] = 'int NOT NULL';
		$schema['parent_id'] = 'int NOT NULL';

		// indexes
		$schema['keys']['data'] = 'FULLTEXT KEY `data` (`data`)'; // just a cache of CSV page IDs for portability
		$schema['keys']['data_exact'] = 'KEY `data_exact` (`data`(1))'; // just for checking if the field has a value
		$schema['keys']['count'] = 'KEY `count` (`count`, `pages_id`)'; 
		$schema['keys']['parent_id'] = 'KEY parent_id (`parent_id`, `pages_id`)';
	
		// indicate that this schema does not hold all data managed by this fieldtype
		$schema['xtra']['all'] = false; 

		return $schema;
	}

	/**
	 * Save the given field from page 
	 *
	 * @param Page $page Page object to save. 
	 * @param Field $field Field to retrieve from the page. 
	 * @return bool True on success, false on DB save failure.
	 *
	 */
	public function ___savePageField(Page $page, Field $field) {

		if(!$page->id || !$field->id) return false;
	
		$pages = $this->wire()->pages;
		$value = $page->get($field->name); 
		
		if($value instanceof RepeaterPage) {
			// for FieldsetPage compatibility
			$pageArrayClass = $this->getPageArrayClass();
			/** @var RepeaterPageArray $pageArray */
			$pageArray = $this->wire(new $pageArrayClass($page, $field));
			$pageArray->add($value);
			$pageArray->resetTrackChanges();
			$value = $pageArray;
		}

		// pages that will be saved
		$savePages = array();

		// options to pass to save() or clone()
		$saveOptions = array('uncacheAll' => false); 

		// pages that will be deleted
		$deletePages = $value->getItemsRemoved();

		$repeaterParent = null;
		$parent_id = 0;
		$template_id = $field->get('template_id'); 
		$numTotal = count($value);

		// iterate through each page in the pageArray value
		// and determine which need to be saved 
		foreach($value as $p) {
			/** @var Page|RepeaterPage $p */
			if($p->template->id != $template_id) {
				$value->remove($p);
				$this->bd("Removed invalid template ({$p->template->name}) page {$p->path} from field $field", __FUNCTION__); 
				continue; 
			}
		
			if(!$repeaterParent) $repeaterParent = $this->getRepeaterPageParent($page, $field);
			if(!$parent_id) $parent_id = $repeaterParent->id;
			
			if($p->parent->id != $parent_id) {
				// clone the individual repeater pages
				$value->remove($p); 
				$p = $pages->clone($p, $repeaterParent, false, $saveOptions);
				$value->add($p);
				$this->bd("Cloned to {$p->path} from field $field", __FUNCTION__); 
				continue; 
			}

			if($p->isNew() && !$p->name && !$p->title) {
				// if we've got a new repeater page without a name or title
				// then it's not going to save because it has no way of generating a name
				// so we will generate one for it
				$p->name = $this->getUniqueRepeaterPageName();
			}

			if($p->isChanged() || $p->isNew()) {
				// if the page has changed or is new, then we will queue it to be saved
				$savePages[] = $p; 

			} else if($p->id && $p->isUnpublished() && !$p->isHidden()) {
				// if the page has an ID, but is still unpublished, though not hidden, then we queue it to be saved (and published)
				$savePages[] = $p; 
			}
		}

		// iterate the pages that had changes and need to be saved
		foreach($savePages as $p) {
			/** @var Page|RepeaterPage $p */
			if($p->id) {
				// existing page
				$isHidden = $p->isHidden();
				$isUnpublished = $p->isUnpublished();
				$isOn = $p->hasStatus(Page::statusOn);
				$isProcessed = $p->get('_repeater_processed') === true;
				$hasErrors = $p->get('_repeater_errors') ? true : false;
				
				if($isHidden && $isUnpublished) continue; // this is a 'ready' page, we can ignore
				
				$changes = implode(', ', $p->getChanges());
				$this->bd("Saved '$field' page: {$p->path} " . ($changes ? "($changes)" : ''), __FUNCTION__); 

				if($isUnpublished && $isOn && $isProcessed && !$hasErrors) {
					// publish requested and allowed
					$p->removeStatus(Page::statusUnpublished);
				}

			} else {
				$this->bd("Added new '$field' page", __FUNCTION__); 
			}

			// save the repeater page
			$pages->save($p, $saveOptions);				
		}

		// iterate through the pages that were removed
		foreach($deletePages as $p) {
			/** @var Page|RepeaterPage $p */
			// if the deleted value is still present in the pageArray, then don't delete it
			if($value->has($p)) continue; 
			// $this->message("Deleted Repeater", Notice::debug); 
			// delete the repeater page
			$pages->delete($p, $saveOptions);
		}

		$result = parent::___savePageField($page, $field);
		
		// ensure that any of our cloned page replacements (removes) don't get recorded any follow-up saves
		$value->resetTrackChanges();

		if(!$numTotal && $this->useLazyParents($field)) {
			// delete repeater page parent if it has no items below it
			if(!$repeaterParent) $repeaterParent = $this->getRepeaterPageParent($page, $field, false);
			if($repeaterParent && $repeaterParent->id) {
				$numChildren = $pages->count("parent_id=$repeaterParent->id, include=all");
				if(!$numChildren) {
					$this->bd("Deleted 0-children repeater parent $repeaterParent->path", __FUNCTION__);
					$this->deleteRepeaterPage($repeaterParent, $field, true);
				}
			}
		}
		
		return $result;
	}

	/**
	 * Delete the given field, which implies: drop the table $field->table
	 *
	 * This should only be called by the Fields class since fieldgroups_fields lookup entries must be deleted before this method is called. 
	 *
	 * With the repeater, we must delete the associated fieldgroup, template and parent as well
	 *
	 * @param Field $field Field object
	 * @return bool True on success, false on DB delete failure.
	 *
	 */
	public function ___deleteField(Field $field) {
		$pages = $this->wire()->pages;
		$templates = $this->wire()->templates;

		$template = $templates->get((int) $field->get('template_id')); 
		$parent = $pages->get((int) $field->get('parent_id')); 

		// delete the pages used by this field
		// check that the parent really is still in our repeaters structure before deleting anything
		if($parent->id && $parent->parent_id == $this->repeatersRootPageID) {

			$parentPath = $parent->path;

			// remove system status from repeater field parent
			$parent->addStatus(Page::statusSystemOverride); 
			$parent->removeStatus(Page::statusSystem); 

			// remove system status from repeater page parents
			foreach($parent->children as $child) {
				$child->addStatus(Page::statusSystemOverride);
				$child->removeStatus(Page::statusSystem); 
			}

			// resursively delete the field parent and everything below it 
			$pages->delete($parent, true); 

			$this->bd("Deleted '$field' parent: $parentPath", __FUNCTION__); 
		}

		// delete the template used by this field
		// check that the template still has system flag before deleting it
		if($template && ($template->flags & Template::flagSystem)) {

			$templateName = $template->name; 

			// remove system flag from the template
			$template->flags = Template::flagSystemOverride; // required before flags=0
			$template->flags = 0;

			// delete the template
			$templates->delete($template); 	

			// delete the fieldgroup
			$fieldgroups = $this->wire()->fieldgroups;
			$fieldgroup = $fieldgroups->get($templateName); 
			if($fieldgroup) $fieldgroups->delete($fieldgroup); 

			$this->bd("Deleted '$field' template: $templateName", __FUNCTION__); 
		}

		return parent::___deleteField($field); 
	}

	/**
	 * Delete the given Field from the given Page
	 *
	 * @param Page $page 
	 * @param Field $field Field object
	 * @return bool True on success, false on DB delete failure.
	 *
	 */
	public function ___deletePageField(Page $page, Field $field) {

		$pages = $this->wire()->pages;
		
		$result = parent::___deletePageField($page, $field); 
		$this->deletePageField = $field->get('parent_id');
		$fieldParent = $pages->get((int) $field->get('parent_id'));

		// confirm that this field parent page is still part of the pages we manage
		if($fieldParent->parent_id == $this->repeatersRootPageID) {
			// locate the repeater page parent
			$parentName = self::repeaterPageNamePrefix . $page->id; 
			$parent = $fieldParent->child("name=$parentName, include=all"); 
			if($parent->id) { 
				// remove system status from repeater page parent
				$parent->addStatus(Page::statusSystemOverride);
				$parent->removeStatus(Page::statusSystem);
				$this->bd("Deleted $parent->path", __FUNCTION__); 
				// delete the repeater page parent and all the repeater pages in it
				$pages->delete($parent, true); 
			}
		}

		return $result;
	}

	/**
	 * Move this field’s data from one page to another.
	 *
	 * #pw-group-saving
	 *
	 * @param Page $src Source Page
	 * @param Page $dst Destination Page
	 * @param Field $field
	 * @return bool
	 *
	 */
	public function ___replacePageField(Page $src, Page $dst, Field $field) {
		
		$pages = $this->wire()->pages;
		$srcParentName = self::repeaterPageNamePrefix . $src->id;
		$dstParentName = self::repeaterPageNamePrefix . $dst->id;
		$parentId = (int) $field->get('parent_id');
		
		if(!parent::___replacePageField($src, $dst, $field)) return false;
		
		$srcParent = $pages->get("parent_id=$parentId, name=$srcParentName");
		$dstParent = $pages->get("parent_id=$parentId, name=$dstParentName");
		
		if($dstParent->id) $pages->delete($dstParent, true);
		
		$srcParent->name = $dstParentName;
		$srcParent->save();
	
		return true;
	}
	
	/**
	 * Create a cloned copy of Field
	 *
	 * @param Field $field
	 * @throws WireException
	 *
	 */
	public function ___cloneField(Field $field) {
		throw new WireException($this->className() . " does not currently support field cloning.");
		/*	
		$field = parent::___cloneField($field); 
		$field->parent_id = null;
		$field->template_id = null;
		*/
	}
	
	/*** EXPORT AND IMPORT **********************************************************/

	/**
	 * Export configuration values for external consumption
	 *
	 * Use this method to externalize any config values when necessary.
	 * For example, internal IDs should be converted to GUIDs where possible.
	 * Most Fieldtype modules can use the default implementation already provided here.
	 *
	 * #pw-group-configuration
	 *
	 * @param Field $field
	 * @param array $data
	 * @return array
	 *
	 */
	public function ___exportConfigData(Field $field, array $data) {

		$data = parent::___exportConfigData($field, $data);

		$template = $this->wire()->templates->get((int) $data['template_id']);

		$data['template_id'] = 0;
		$data['parent_id'] = 0;
		$data['repeaterFields'] = array();
		$data['fieldContexts'] = array();

		$a = $field->get('repeaterFields');
		if(!is_array($a)) $a = array();

		foreach($a as $fid) {
			$f = $this->wire()->fields->get((int) $fid);
			if(!$f) continue;
			$data['repeaterFields'][] = $f->name;
			$data['fieldContexts'][$f->name] = $template->fieldgroup->getFieldContextArray($f->id);
		}

		return $data;
	}

	/**
	 * Convert an array of exported data to a format that will be understood internally
	 *
	 * This is the opposite of the exportConfigData() method.
	 * Most modules can use the default implementation provided here.
	 *
	 * #pw-group-configuration
	 *
	 * @param Field $field
	 * @param array $data
	 * @return array Data as given and modified as needed. Also included is $data[errors], an associative array
	 *	indexed by property name containing errors that occurred during import of config data.
	 *
	 */
	public function ___importConfigData(Field $field, array $data) {

		if(!$field->type instanceof FieldtypeRepeater) return $data;

		$fields = $this->wire()->fields;

		$errors = array();
		$repeaterFields = array();
		$saveFieldgroup = false;
		$saveFieldgroupContext = false;
		$template = $field->id ? $this->getRepeaterTemplate($field) : null;

		if(!empty($data['repeaterFields'])) {
			foreach($data['repeaterFields'] as $name) {
				$f = $fields->get($name);
				if(!$f instanceof Field) {
					$errors[] = "Unable to locate field to add to repeater: $name";
					continue;
				}
				$repeaterFields[] = $f->id;
			}
			$data['repeaterFields'] = $repeaterFields;
		}

		if($template && !empty($data['fieldContexts'])) {
			foreach($data['fieldContexts'] as $name => $contextData) {
				$f = $fields->get($name);
				if(!$f instanceof Field) continue;
				if($template->fieldgroup->hasField($f)) {
					$f = $template->fieldgroup->getFieldContext($f->name);
				}
				$template->fieldgroup->add($f);
				$saveFieldgroup = true;
				if(!empty($contextData)) {
					$template->fieldgroup->setFieldContextArray($f->id, $contextData);
					$saveFieldgroupContext = true;
				}
			}
		}

		if($template) {
			if($saveFieldgroupContext) {
				$template->fieldgroup->saveContext();
			}
			if($saveFieldgroup) {
				$template->fieldgroup->save();
			}
		}

		unset($data['fieldContexts']);

		$data = parent::___importConfigData($field, $data);

		if(count($errors)) {
			$data['errors'] = array_merge($data['errors'], array('repeaterFields' => $errors));
		}

		return $data;
	}

	
	/*** TOOLS ********************************************************************/

	/**
	 * Count or delete old ready pages that are just taking up space
	 * 
	 * @param Field $field
	 * @param bool $delete Specify true to delete the old ready pages
	 * @param int $secondsOld Number of seconds old that the page has to be to be considered "old" (default=259200 or 3 days)
	 * @return int Count of old ready pages, or if $delete===true, then number that was deleted
	 * 
	 */
	public function countOldReadyPages(Field $field, $delete = false, $secondsOld = 259200) {
		if(!$field->type instanceof FieldtypeRepeater) return 0;
		$cnt = 0;
		$template = $this->getRepeaterTemplate($field);
		$parent = $this->getRepeaterParent($field);
		if(!$template || !$parent) return 0;
		$status = Page::statusHidden + Page::statusUnpublished;
		$modified = time() - $secondsOld;
		$selector = "has_parent=$parent, template=$template, status>=$status, modified<=$modified, include=all";
		if($delete) {
			$items = $this->wire()->pages->find($selector);
			foreach($items as $item) {
				try {
					if($this->deleteRepeaterPage($item, $field)) $cnt++;
				} catch(\Exception $e) {
					$this->error("Error deleting old repeater item $item->path - " . $e->getMessage());
				}
			}
		} else {
			$cnt = $this->wire()->pages->count($selector);
		}
		return $cnt;
	}

	/**
	 * Find unnecessary parent pages that may be deleted
	 * 
	 * @param Field $field
	 * @param array $options
	 * @return PageArray
	 * 
	 */
	public function findUnnecessaryParents(Field $field, array $options = array()) {
		
		$defaults = array(
			'useLazyParents' => $this->useLazyParents($field), 
			'limit' => 500,
		);
	
		$options = array_merge($defaults, $options);
		$database = $this->wire()->database;
		$forFieldParent = $this->getRepeaterParent($field); // for-field-123
		$unnecessaryParents = new PageArray();
		
		foreach($forFieldParent->children() as $forPageParent) { 
			$name = $forPageParent->name; // for-page-456
			if(strpos($name, self::repeaterPageNamePrefix) !== 0) continue;
			list(, $forPageId) = explode(self::repeaterPageNamePrefix, $name, 2);
			$query = $database->prepare('SELECT COUNT(*) FROM pages WHERE id=:id');
			$query->bindValue(':id', (int) $forPageId, \PDO::PARAM_INT);
			$query->execute();
			$exists = (int) $query->fetchColumn();
			$query->closeCursor();
			if(!$exists || ($options['useLazyParents'] && !$forPageParent->numChildren)) {
				$unnecessaryParents->add($forPageParent);
				if($options['limit'] && $unnecessaryParents->count() >= $options['limit']) break;
			}
		}
		
		return $unnecessaryParents;
	}

	/**
	 * Delete a repeater page, removing system statuses first 
	 * 
	 * This is able to delete the following types of pages:
	 * 
	 * - repeaters/for-field-123/
	 * - repeaters/for-field-123/for-page-456/
	 * - repeaters/for-field-123/for-page-456/repeater-item/
	 * - repeaters/for-field-123/for-page-456/repeater-item/something-else/
	 * 
	 * @param Page $page
	 * @param Field $field Optionally limit to given field or null if not appliable
	 * @param bool $recursive Descend to children?
	 * @return int Returns count of pages deleted, or 0 if delete not allowed
	 * @since 3.0.188
	 * 
	 */
	public function deleteRepeaterPage(Page $page, Field $field = null, $recursive = false) {
		
		static $level = 0;
		$numDeleted = 0;
		
		if(!$page->id) return 0;
		
		$fieldPageName = self::fieldPageNamePrefix . ($field ? $field->id : '');
		
		if(strpos($page->path, '/' . self::repeatersRootPageName . '/') === false) {
			$this->bd("Cannot delete $page->path because not in repeaters path", __FUNCTION__, true);
			return 0;
		}
		
		if($field && strpos($page->path, "/$fieldPageName/") === false) {
			$this->bd("Cannot delete $page->path because not within /$fieldPageName/", __FUNCTION__, true);
			return 0;
		}
		
		if(strpos($page->name, self::fieldPageNamePrefix) === 0) {
			// repeater for-field parent
			if($field && $page->name != $fieldPageName) return 0;
			
		} else if(strpos($page->name, self::repeaterPageNamePrefix) === 0) {
			// repeater for-page parent
			
		} else if(strpos($page->template->name, self::templateNamePrefix) === 0) {
			// repeater item
			
		} else if(strpos($page->path, '/' . self::repeaterPageNamePrefix)) {
			// something with /for-page-123 in the path
			// child of a repeater item (PageTable or something else?)
			
		} else {
			// some other page, not allowed to delete
			$this->bd("Not allowed to delete $page->path", __FUNCTION__, true); 
			return 0; 
		}
		
		$numChildren = $page->numChildren;
		
		if($numChildren && !$recursive) {
			$this->bd("Cannot delete $page->path because has children", __FUNCTION__, true); 
			return 0;
		}
		
		if($numChildren) {
			$level++;
			foreach($page->children('include=all') as $p) {
				$numDeleted += $this->deleteRepeaterPage($p, $field, $recursive);
			}
			$level--;
		}

		// remove system statuses
		if($page->hasStatus(Page::statusSystem) || $page->hasStatus(Page::statusSystemID)) {
			$page->addStatus(Page::statusSystemOverride);
			$page->removeStatus(Page::statusSystem);
			$page->removeStatus(Page::statusSystemID);
		}

		if($this->wire()->pages->delete($page, $recursive)) $numDeleted++;
			
		return $numDeleted;
	}
	
	/**
	 * @param mixed $msg
	 * @param string|bool $func
	 * @param bool $error
	 *
	 */
	protected function bd($msg, $func = '', $error = false) {
		if(!$this->wire()->config->debug || !class_exists('\\TD')) return;
		if(is_bool($func)) list($error, $func) = array($func, '');
		if(!self::devMode && !$error) return;
		call_user_func_array('\\TD::barDump', array($msg, $this->className() . "::$func"));
	}

	/*** CONFIG **************************************************************************/

	/**
	 * @var FieldtypeRepeaterConfigHelper|null
	 * 
	 */
	protected $repeaterConfigHelper = null;

	/**
	 * Use lazy parents mode?
	 * 
	 * @param RepeaterField|Field $field
	 * @return bool
	 * 
	 */
	public function useLazyParents(Field $field) {
		/** @var FieldtypeRepeater $fieldtype */
		if(strpos($this->className(), 'Fieldset')) return false; 
		return ((int) $field->get('lazyParents')) > 0;
	}

	/**
	 * @param Field $field
	 * @return FieldtypeRepeaterConfigHelper
	 * @since 3.0.188
	 * 
	 */
	public function getRepeaterConfigHelper(Field $field) {
		if($this->repeaterConfigHelper && $this->repeaterConfigHelper->getField()->id == $field->id) {
			return $this->repeaterConfigHelper;
		}
		require_once(__DIR__ . '/config.php');
		$this->repeaterConfigHelper = new FieldtypeRepeaterConfigHelper($field);
		$this->wire($this->repeaterConfigHelper);
		return $this->repeaterConfigHelper;
	}

	/**
	 * Return configuration fields definable for each FieldtypePage
	 * 
	 * @param Field $field
	 * @return InputfieldWrapper
	 *
	 */
	public function ___getConfigInputfields(Field $field) {

		$inputfields = parent::___getConfigInputfields($field);
		$template = $this->getRepeaterTemplate($field); 
		$parent = $this->getRepeaterParent($field); 

		if($this->wire()->input->post('repeaterFields')) {
			$this->saveConfigInputfields($field, $template, $parent);
		}
		
		$helper = $this->getRepeaterConfigHelper($field);
		$inputfields = $helper->getConfigInputfields($inputfields, $template, $parent);
		
		return $inputfields; 
	}

	/**
	 * Helper to getConfigInputfields, handles adding and removing of repeater fields
	 * 
	 * @param Field $field
	 * @param Template $template
	 * @param Page $parent
	 * 
	 */
	protected function ___saveConfigInputfields(Field $field, Template $template, Page $parent) {
		$this->initAllFields();
		$helper = $this->getRepeaterConfigHelper($field);
		$helper->saveConfigInputfields($template);
	}

	/**
	 * Just here to fulfill ConfigurableModule interface
	 * 
	 * @param array $data
	 * @return InputfieldWrapper
	 *
	 */
	public function getModuleConfigInputfields(array $data) {
		if($data) {} // ignore
		return $this->wire(new InputfieldWrapper());
	}

	/**
	 * Remove advanced options that aren't supposed with repeaters
	 * 
	 * @param Field $field
	 * @return InputfieldWrapper
	 *
	 */
	public function ___getConfigAdvancedInputfields(Field $field) {
		$inputfields = parent::___getConfigAdvancedInputfields($field);
		$this->getRepeaterConfigHelper($field)->getConfigAdvancedInputfields($inputfields);
		return $inputfields;
	}

	/**
	 * Install the module
	 *
	 */
	public function ___install() {
	
		$pages = $this->wire()->pages;
		$config = $this->wire()->config;
		$modules = $this->wire()->modules;

		$adminRoot = $pages->get($config->adminRootPageID); 
		$page = $adminRoot->child("name=repeaters, template=admin, include=all"); 
		
		if(!$page->id) {
			$page = $pages->newPage('admin');
			$page->parent = $adminRoot;
			$page->status = Page::statusHidden | Page::statusLocked | Page::statusSystemID;
			$page->name = self::repeatersRootPageName;
			$page->title = 'Repeaters';
			$page->sort = $adminRoot->numChildren;
			$page->save();
			$this->message("Added page {$page->path}", Notice::debug); 
		}

		$configData = array('repeatersRootPageID' => $page->id); 
		$modules->saveModuleConfigData($this, $configData);
	}

	/**
	 * Uninstall the module (delete the repeaters page)
	 *
	 */
	public function ___uninstall() {
		$pages = $this->wire()->pages;

		// don't delete repeaters page unless actually for FieldtypeRepeater
		if($this->className() != 'FieldtypeRepeater') return;
		
		$page = $this->getRepeatersRootPage();
		
		if($page->id && $page->name === self::repeatersRootPageName && $page->template->name === 'admin') { 
			$page->addStatus(Page::statusSystemOverride); 
			$page->removeStatus(Page::statusSystem); 
			$page->removeStatus(Page::statusSystemID); 
			$page->removeStatus(Page::statusSystemOverride);
			$page->removeStatus(Page::statusLocked); 
			$pages->delete($page); 
			$this->message("Removed page {$page->path}", Notice::debug); 
		}
	}

}