<?php
class mcPUIX_PDO {

	public static function getConfigColumnKeys($param_Config) {
		$ConfigArray_keys = array_keys($param_Config);
		unset($ConfigArray_keys[array_search('TABLE', $ConfigArray_keys)]);
		unset($ConfigArray_keys[array_search(mcPUIX::FORM_DO_ROW, $ConfigArray_keys)]);		
		return $ConfigArray_keys;
	}
	
	public static function cleanDBRowData($param_) {
		
	}
	
	private static function checkArrayIfIsRequired(array $param_Config_TABLE, array &$param_Values) {
//		D::show($param_Values, '$param_Values');
		if(mcArray::checkKeyHasFullArray($param_Config_TABLE, 'TABLE')) {
			if(mcArray::checkKeyHasFullArray($param_Config_TABLE['TABLE'], mcPUIX::FORM_REQUIRED)) {
//				D::show(array( '$param_Config_TABLE' => $param_Config_TABLE['TABLE'][mcPUIX::FORM_REQUIRED], '$param_Values' => $param_Values), '####');
				foreach($param_Config_TABLE['TABLE'][mcPUIX::FORM_REQUIRED] as $RequiredKey) {
//					D::ulli($RequiredKey);
					if(!array_key_exists($RequiredKey, $param_Values)) {
						if(mcArray::checkKeyHasFullArray($param_Values, mcPUIX::PDO_OR) &&  array_key_exists($RequiredKey, $param_Values[mcPUIX::PDO_OR])) {
							$param_Values[$RequiredKey] = $param_Values[mcPUIX::PDO_OR][$RequiredKey];
							unset($param_Values[mcPUIX::PDO_OR]);
						} else if(mcArray::checkKeyHasFullArray($param_Values, mcPUIX::PDO_XOR) &&  array_key_exists($RequiredKey, $param_Values[mcPUIX::PDO_XOR])) {
							$param_Values[$RequiredKey] = $param_Values[mcPUIX::PDO_XOR][$RequiredKey];
							unset($param_Values[mcPUIX::PDO_XOR]);
						} else if(mcArray::checkKeyHasFullArray($param_Values, mcPUIX::PDO_AND) &&  array_key_exists($RequiredKey, $param_Values[mcPUIX::PDO_AND])) {
							$param_Values[$RequiredKey] = $param_Values[mcPUIX::PDO_AND][$RequiredKey];
							unset($param_Values[mcPUIX::PDO_AND]);
						} else {
							return false;
						}

					} 
					
					if(is_array($param_Values[$RequiredKey]) 
							&& array_key_exists(mcPUIX::FORM_DO_VAR, $param_Values[$RequiredKey])
							&& !$param_Values[$RequiredKey][mcPUIX::FORM_DO_VAR]
					) {
						return false;
						
					} else if(!$param_Values[$RequiredKey]) {
						return false;
					}
					
//					if(!array_key_exists($RequiredKey, $param_Values) || ( !$param_Values[$RequiredKey] && !$param_Values[$RequiredKey][mcPUIX::FORM_DO_VAR])) {
//						return false;
//					} 
				}				
			} 
			return true;
		} else {
			D::cf('ERROR Parameter falsch');
		}
	}
	
	/**
	 * @param string $param_tablename
	 * @param array $param_ConfigArray[mcPUIX::PUIXArray][mcPUIX::DBUIConfig][$param_tablename]
	 * @param array $param_NewArray => $param_NewArray[mcPUIX::PUIXArray][mcPUIX::FORM_POST_VALUES] = array()
	 * @return array 
	 */
	public static function prepareArrayForDBOperation($param_tablename, array $param_ConfigArray, array $param_NewArray=null /*, array $param_OriginalArray=null*/) {

		if(mcArray::checkKeyHasFullArray($param_ConfigArray, mcPUIX::PUIXArray, mcPUIX::DBUIConfig, $param_tablename)
			&& mcArray::checkKeyHasFullArray($param_NewArray, mcPUIX::PUIXArray, mcPUIX::FORM_POST_VALUES) ) {
//D::show($param_NewArray, '$param_NewArray[mcPUIX::PUIXArray][mcPUIX::FORM_POST_VALUES]');					
//			D::show(array($param_NewArray[mcPUIX::PUIXArray][mcPUIX::FORM_POST_VALUES], $param_ConfigArray[mcPUIX::PUIXArray][mcPUIX::DBUIConfig][$param_tablename]), $param_tablename. ' for ');
			
			$ConfigArray = $param_ConfigArray[mcPUIX::PUIXArray][mcPUIX::DBUIConfig][$param_tablename];

//			$ConfigArray_keys = mcPUIX_PDO::getConfigColumnKeys($ConfigArray);
			
			$result = array(mcPUIX::PUIXArray => array(mcPUIX::PDOToSaveValues => array()));
			
			
			$DeleteRows = $NewRows = $UpdateRows = $ErrorRows = array();

			if(array_key_exists('TABLE', $ConfigArray)) {
				$BoolRequired = $BoolPrimary = $BoolActiveRow = $BoolDeleted = false;

				if(mcArray::checkKeyHasFullArray($ConfigArray, mcPUIX::FORM_DO_ROW)) {
					$BoolActiveRow = true;
				}				

				if(array_key_exists(mcPUIX::FORM_REQUIRED, $ConfigArray['TABLE']) && is_array($ConfigArray['TABLE'][mcPUIX::FORM_REQUIRED])) {
					$BoolRequired = true;
				}
				if(array_key_exists('PRIMARY', $ConfigArray['TABLE']) && is_array($ConfigArray['TABLE']['PRIMARY'])) {
					$BoolPrimary = true;
				}

				foreach($param_NewArray[mcPUIX::PUIXArray][mcPUIX::FORM_POST_VALUES] as $NewKey =>  &$NewData) {
				
					$BoolDeleted = false;
					
					
					if($NewKey===mcPUIX::FORM_NEW_ROW) {
//						D::show($NewData, '$NewData '.$NewKey);
						foreach($NewData as $NewFormRowKey => &$NewFormRow) {
							if(is_array($NewFormRow)) {
								
//								D::show($NewFormRow, $NewKey.' $NewFormRow '.$NewFormRowKey);
								$BoolDeleted = $BoolErrorRow = false;
								if(!mcPUIX_PDO::checkArrayIfIsRequired($ConfigArray, $NewFormRow)) {
									$param_NewArray[mcPUIX::PUIXArray][mcPUIX::FORM_POST_VALUES][$NewKey][$NewFormRowKey][mcPUIX::ERRORMESSAGE] = 'deleted after checkArrayIfIsRequired';
									$ErrorRows[] = $param_NewArray[mcPUIX::PUIXArray][mcPUIX::FORM_POST_VALUES][$NewKey][$NewFormRowKey];
									unset($param_NewArray[mcPUIX::PUIXArray][mcPUIX::FORM_POST_VALUES][$NewKey][$NewFormRowKey]);
									$BoolDeleted = true;						
									$BoolErrorRow = true;
								}
//								D::show($NewFormRow, '$NewFormRow after checkArrayIfIsRequired');
										

								if($NewFormRow[mcPUIX::FORM_DO_ROW][mcPUIX::FORM_DO_VAR] === mcPUIX::FORM_DO_NEW
										|| $NewFormRow[mcPUIX::FORM_DO_ROW] === mcPUIX::FORM_DO_NEW) {
	//								$BoolErrorRow = false;
									foreach($ConfigArray['TABLE']['LISTID'] as $LISTID) {
										if(!array_key_exists($LISTID, $NewFormRow)) {
											$param_NewArray[mcPUIX::PUIXArray][mcPUIX::FORM_POST_VALUES][$NewKey][$NewFormRowKey][mcPUIX::ERRORMESSAGE] = 'deleted after LISTID';
											$ErrorRows[] = $param_NewArray[mcPUIX::PUIXArray][mcPUIX::FORM_POST_VALUES][$NewKey][$NewFormRowKey];
											$BoolErrorRow = true;
											break;
										}
									}
									if($BoolErrorRow === false) {
//										D::show($param_NewArray[mcPUIX::PUIXArray][mcPUIX::FORM_POST_VALUES][$NewKey][$NewFormRowKey], "teaasdf[$NewFormRowKey]",1,1);
//										D::show($param_NewArray[mcPUIX::PUIXArray][mcPUIX::FORM_POST_VALUES][$NewKey], "[$NewFormRowKey]",1,1);
										$NewRows[] = $param_NewArray[mcPUIX::PUIXArray][mcPUIX::FORM_POST_VALUES][$NewKey][$NewFormRowKey];
//										$NewRows[] = $NewFormRow;

									}						
								} else {
									$param_NewArray[mcPUIX::PUIXArray][mcPUIX::FORM_POST_VALUES][$NewKey][$NewFormRowKey][mcPUIX::ERRORMESSAGE] ='deleted because not FORM_DO_NEW marked';
									$ErrorRows[] = $param_NewArray[mcPUIX::PUIXArray][mcPUIX::FORM_POST_VALUES][$NewKey][$NewFormRowKey];
								}
							} else {
								D::show($NewFormRow, '$NewFormRowKey ='.$NewFormRowKey,1,1);
							}

							
						}
//						D::show($ErrorRows, '$ErrorRows');
					} else {
//						D::show($NewData, '$NewKey: '. $NewKey);
						if(!mcPUIX_PDO::checkArrayIfIsRequired($ConfigArray, $NewData)) {
							$ErrorRows[] = $param_NewArray[mcPUIX::PUIXArray][mcPUIX::FORM_POST_VALUES][$NewKey];
							unset($param_NewArray[mcPUIX::PUIXArray][mcPUIX::FORM_POST_VALUES][$NewKey]);
							$BoolDeleted = true;						
//							D::show($ErrorRows, '$ErrorRows');
						}
//						D::show($NewData, '$NewFormRow after checkArrayIfIsRequired');

	//					if($BoolRequired === true) {
	//						foreach($ConfigArray['TABLE'][mcPUIX::FORM_REQUIRED] as $RequiredKey) {
	////							D::ulli($RequiredKey.' : ');
	//							if(!array_key_exists($RequiredKey, $NewData) || !$NewData[$RequiredKey][mcPUIX::FORM_DO_VAR]) {
	//								$ErrorRows[] = $param_NewArray[mcPUIX::PUIXArray][mcPUIX::FORM_POST_VALUES][$NewKey];
	//								unset($param_NewArray[mcPUIX::PUIXArray][mcPUIX::FORM_POST_VALUES][$NewKey]);
	//								$BoolDeleted = true;
	//								break;
	//							} 
	//						}
	//					}

						if(!$BoolDeleted) {
//							if($NewData[mcPUIX::FORM_DO_ROW][mcPUIX::FORM_DO_VAR] === mcPUIX::FORM_DO_NEW) {
//								$BoolErrorRow = false;
//								foreach($ConfigArray['TABLE']['LISTID'] as $LISTID) {
//									if(!array_key_exists($LISTID, $NewData)) {
//										$ErrorRows[] = $param_NewArray[mcPUIX::PUIXArray][mcPUIX::FORM_POST_VALUES][$NewKey];
//										$BoolErrorRow = true;
//										break;
//									}
//								}
//								if($BoolErrorRow === false) {
//									$NewRows[] = $param_NewArray[mcPUIX::PUIXArray][mcPUIX::FORM_POST_VALUES][$NewKey];
//
//								}						
//							} else {
								if($BoolActiveRow === true) {

									if($NewData[mcPUIX::FORM_DO_ROW][mcPUIX::FORM_DO_VAR] === mcPUIX::FORM_DO_DELETE) {
										$DeleteRows[] = $param_NewArray[mcPUIX::PUIXArray][mcPUIX::FORM_POST_VALUES][$NewKey];
										unset($param_NewArray[mcPUIX::PUIXArray][mcPUIX::FORM_POST_VALUES][$NewKey]);

									} else if($NewData[mcPUIX::FORM_DO_ROW][mcPUIX::FORM_DO_VAR] === mcPUIX::FORM_DO_SAVE) {
										$BoolErrorRow = false;
										foreach($ConfigArray['TABLE']['PRIMARY'] as $PrimaryKey) {
											if(!array_key_exists($PrimaryKey, $NewData)) {
												$ErrorRows[] = $param_NewArray[mcPUIX::PUIXArray][mcPUIX::FORM_POST_VALUES][$NewKey];
												$BoolErrorRow = true;
												break;
											}
										}
										if($BoolErrorRow == false) {
											$UpdateRows[] = $param_NewArray[mcPUIX::PUIXArray][mcPUIX::FORM_POST_VALUES][$NewKey];
										}

										if(mcArray::checkKeyHasFullArray($NewData, mcPUIX::PUIX_SUB_REFERENCELIST, mcPUIX::PUIXArray)) {
											$Tablename_LIST = mcPUIX_CONFIG::getReferenceTableName($param_tablename);

											$ReferenceNewArray = array(
												mcPUIX::PUIXArray => array(
													mcPUIX::FORM_POST_VALUES => $NewData[mcPUIX::PUIX_SUB_REFERENCELIST][mcPUIX::PUIXArray]
												)
											);
											$result_List = mcPUIX_PDO::prepareArrayForDBOperation($Tablename_LIST, $param_ConfigArray, $ReferenceNewArray);
											$result = array_merge_recursive ($result, $result_List);
										}
									}
								} else if($NewData[mcPUIX::FORM_DO_ROW][mcPUIX::FORM_DO_VAR] === mcPUIX::FORM_DO_SAVE) {
									$UpdateRows[] = $param_NewArray[mcPUIX::PUIXArray][mcPUIX::FORM_POST_VALUES][$NewKey];
								}													
//							}
						}						
					}
				}
			}

			$result[mcPUIX::PUIXArray][mcPUIX::PDOToSaveValues][$param_tablename]['DeleteRows']	= $DeleteRows;
			$result[mcPUIX::PUIXArray][mcPUIX::PDOToSaveValues][$param_tablename]['UpdateRows']	= $UpdateRows;
			$result[mcPUIX::PUIXArray][mcPUIX::PDOToSaveValues][$param_tablename]['ErrorRows']	= $ErrorRows;
			$result[mcPUIX::PUIXArray][mcPUIX::PDOToSaveValues][$param_tablename]['NewRows']		= $NewRows;
//D::show($result, '$result');
			return $result;			
		} else {
			D::backtrace('prepareArrayForDBOperation');
			D::cf('ERROR wrong format
					if(mcArray::checkKeyHasFullArray($param_ConfigArray, mcPUIX::PUIXArray, mcPUIX::DBUIConfig, '.$param_tablename.') 
								=> '.mcArray::checkKeyHasFullArray($param_ConfigArray, mcPUIX::PUIXArray, mcPUIX::DBUIConfig, $param_tablename).'
						&& mcArray::checkKeyHasFullArray($param_NewArray, mcPUIX::PUIXArray, mcPUIX::FORM_POST_VALUES) 
								=> '.mcArray::checkKeyHasFullArray($param_NewArray, mcPUIX::PUIXArray, mcPUIX::FORM_POST_VALUES).'
					) {				
			');
			D::show($param_NewArray, $param_tablename);
			
		}
	}	
	
	
	/**
	 *
	 * @param string $param_SQLWhere
	 * @param array $param_SearchAttributes -- array (
	 *		mcPUIX::PDO_AND => array(x1, x2, x3 ), 
	 *		mcPUIX::PDO_OR => array(),
	 *		mcPUIX::PDO_XOR => array(), 
	 *		
	 * )
	 */
	private static function generateWhereFromSearchAttributes(&$param_SQLWhere, array &$param_bindValueArray, array $param_SearchAttributes, $param_Operator=mcPUIX::PDO_AND) {

		$return = array();
		
		$Operator_SQL_Array = array();
		
		if(array_key_exists(mcPUIX::PDO_AND, $param_SearchAttributes)) {
			$AND_operator = mcPUIX::PDO_AND;
			$AND_Operands = $param_SearchAttributes[mcPUIX::PDO_AND];
			$AND_SQL = '';
			unset($param_SearchAttributes[mcPUIX::PDO_AND]);
			$AND_Return = mcPUIX_PDO::generateWhereFromSearchAttributes($AND_SQL, $param_bindValueArray, $AND_Operands, $AND_operator);
			$return = array_merge_recursive($return, $AND_Return);
			$Operator_SQL_Array[] = $AND_SQL;
		} 
		if(array_key_exists(mcPUIX::PDO_OR, $param_SearchAttributes)) {
			$OR_operator = mcPUIX::PDO_OR;
			$OR_Operands = $param_SearchAttributes[mcPUIX::PDO_OR];
			$OR_SQL = '';
			unset($param_SearchAttributes[mcPUIX::PDO_OR]);
			$OR_Return = mcPUIX_PDO::generateWhereFromSearchAttributes($OR_SQL, $param_bindValueArray, $OR_Operands, $OR_operator);
			$return = array_merge_recursive($return, $OR_Return);
			$Operator_SQL_Array[] = $OR_SQL;
		}
		if(array_key_exists(mcPUIX::PDO_XOR, $param_SearchAttributes)) {
			$XOR_operator = mcPUIX::PDO_XOR;			
			$XOR_Operands = $param_SearchAttributes[mcPUIX::PDO_XOR];
			$XOR_SQL = '';
			unset($param_SearchAttributes[mcPUIX::PDO_XOR]);
			$XOR_Return = mcPUIX_PDO::generateWhereFromSearchAttributes($XOR_SQL, $param_bindValueArray, $XOR_Operands, $XOR_operator);
			$return = array_merge_recursive($return, $XOR_Return);
			$Operator_SQL_Array[] = $XOR_SQL;
		} 

		if(array_key_exists(mcPUIX::PUIX_SUB_REFERENCELIST, $param_SearchAttributes)) {
			unset($param_SearchAttributes[mcPUIX::PUIX_SUB_REFERENCELIST]);
		}		
		
		$bool_operator = false;
		
		if(!empty($param_SearchAttributes)) {
			foreach($param_SearchAttributes as $col => $val) {
				if($col===mcPUIX::PDO_NEW) {
//					D::show($val, '$param_SearchAttributes mcPUIX::PDO_NEW');
					if(!array_key_exists(mcPUIX::PDO_Special, $return)) {
						$return[mcPUIX::PDO_Special] = array();
					}
					$return[mcPUIX::PDO_Special][mcPUIX::PDO_NEW] = array(
						mcPUIX::PDO_Operator => $param_Operator,
						mcPUIX::PDO_Operand => $val,
					);
					
//					$col = key($val);
//					$val = 0;
				} else {
					if($bool_operator) {
						$param_SQLWhere .= ' '.$param_Operator.' ';
					} else {
						$bool_operator = true;
					}
					
					if(is_numeric($val)) {
						$bindKey = ':'.$col.'_'.$val;
					} else {
						$bindKey = ':'.$col;
					}
						
					if(array_key_exists($bindKey, $param_bindValueArray)) {
						$bindKey .= '_'.md5($bindKey);
						if(array_key_exists($bindKey, $param_bindValueArray)) {
							$bindKey .= '_'.mcString::generateAlphaNumericRandumString();
							if(array_key_exists($bindKey, $param_bindValueArray)) {
								D::li('@todo: och mensch .. schon echt unwahrscheinlich $bindKey('.$bindKey.')');
							}
						}
					}

					$param_SQLWhere .= ' '.$col.'='.$bindKey.' ';		
					$param_bindValueArray[$bindKey] = $val;
				}
			}					
		}

		if(!empty($Operator_SQL_Array)) {
			foreach($Operator_SQL_Array as $SQL_String) {
				if(trim($SQL_String)!=='') {
					if($bool_operator) {
						$param_SQLWhere .= ' '.$param_Operator.' ';
					} else {
						$bool_operator = true;
					}
					$param_SQLWhere .= ' ('.$SQL_String.') ';								
				}
			}					
		}
		return $return;
	}
	
	/**
	 *	return loaded PDO Table as PUIXArray
	 * 
	 * @param Account $param_HostAccount
	 * @param PDOLevel $param_iStorable
	 * @param string $param_tablename
	 * @param string $param_SQLWhere
	 * @param int $param_depth
	 * @return array(
	 *			mcPUIX::PUIXArray => array(
	 *					mcPUIX::PDOValues => array(0=>val1, 1=>val2)
	 *				)
	 *			)
	 */
	public static function getTableAsDBUIArray(Account &$param_HostAccount, PDOLevel &$param_iStorable, $param_tablename, array $param_SearchAttributes=null, $param_SQLWhere='', $param_depth=0) {
		$ConfigArray = mcPUIX_CONFIG::getTableConfig($param_tablename);
		$ConfigArray = $ConfigArray[mcPUIX::PUIXArray][mcPUIX::DBUIConfig][$param_tablename];
		$BOOL_Load=true;

		if($param_SQLWhere==='' && !is_null($param_SearchAttributes)) {
			
			if(array_key_exists(mcPUIX::PDOLoadDepth, $param_SearchAttributes)) {
				if($param_SearchAttributes[mcPUIX::PDOLoadDepth]===mcPUIX::PDOLoadDepth_OnlyNew) {
					$BOOL_Load=false;
				} else {
					$param_depth = $param_SearchAttributes[mcPUIX::PDOLoadDepth];
				}
				unset($param_SearchAttributes[mcPUIX::PDOLoadDepth]);
			}
			if($BOOL_Load) {
//				D::show($param_SearchAttributes, '$param_SearchAttributes');
				$var_bindValueArray = array();
				$returnFromSearchAttributes = mcPUIX_PDO::generateWhereFromSearchAttributes($param_SQLWhere, $var_bindValueArray, $param_SearchAttributes);
				$param_SQLWhere = ' where  '.$param_SQLWhere;				
			}

			
//			$param_SQLWhere = ' where  ';
//			$bool_AND = false;
//			foreach($param_SearchAttributes as $col => $val) {
//				if($col === mcPUIX::PDOLoadDepth) {
//					if($val===mcPUIX::PDOLoadDepth_OnlyNew) {
//						$BOOL_Load=false;
//					} else {
//						$param_depth = $val;
//					}
//					
//				} 
//				else if($col !== mcPUIX::PUIX_SUB_REFERENCELIST) {
//					if($bool_AND) {
//						$param_SQLWhere .= ' AND ';
//					} else {
//						$bool_AND = true;
//					}
//					$param_SQLWhere .= ' '.$col.'="'.$val.'" ';					
//				}
//			}
		}
		
//		D::show($param_SearchAttributes, "param_depth=$param_depth:   ".$param_SQLWhere);
		
		if($BOOL_Load) {
			if(mcArray::checkKeyHasFullArray($ConfigArray, 'TABLE')
				&& array_key_exists('TABLENAME', $ConfigArray['TABLE']) && $ConfigArray['TABLE']['TABLENAME']
			) {
				$var_query = 'select * from '.$ConfigArray['TABLE']['TABLENAME'].' '.$param_SQLWhere;
	//				where SNIfProfileID = 0 or SNIfProfileID = :SNIfProfileID ';
	//			$var_bindValueArray = array(':SNIfProfileID'	=>	$param_Object->getObjVar('Profile')->getObjVar('SNIfProfileID'),	);
//				D::show(array('$var_bindValueArray' => $var_bindValueArray, '$param_SearchAttributes' => $param_SearchAttributes, '$returnFromSearchAttributes'=> $returnFromSearchAttributes), $var_query); 
//				$var_bindValueArray=null;
				$stmt = $param_iStorable->PDO_query($var_query, $var_bindValueArray);

				if($stmt){
					$PDOTable = $param_iStorable->PDO_fetchAll($stmt);

					if($param_depth>0) {
						/**
						* is this a List_table and has a reference table
						*/
						if(mcArray::checkKeyHasFullArray($ConfigArray['TABLE'], mcPUIX::PUIX_SUB_REFERENCELIST)) {
							if($ConfigArray['TABLE'][mcPUIX::PUIX_SUB_REFERENCELIST]['TABLENAME'] && $ConfigArray['TABLE'][mcPUIX::PUIX_SUB_REFERENCELIST]['REFERENCE_KEY']) {

								foreach($PDOTable as &$PDORow) {
									if($PDORow[$ConfigArray['TABLE'][mcPUIX::PUIX_SUB_REFERENCELIST]['REFERENCE_KEY']]) {
		//								D::show($PDORow, '$PDORow');
				//						D::show($ConfigArray, '$ConfigArray');			
//										$SQLWhere = ' where '.$ConfigArray['TABLE'][mcPUIX::PUIX_SUB_REFERENCELIST]['REFERENCE_KEY'].'='.$PDORow[$ConfigArray['TABLE'][mcPUIX::PUIX_SUB_REFERENCELIST]['REFERENCE_KEY']];
										$SearchAttributes=array(
											$ConfigArray['TABLE'][mcPUIX::PUIX_SUB_REFERENCELIST]['REFERENCE_KEY'] => $PDORow[$ConfigArray['TABLE'][mcPUIX::PUIX_SUB_REFERENCELIST]['REFERENCE_KEY']],
											mcPUIX::PDOLoadDepth => $param_depth-1,
										);
										if(mcArray::checkKeyHasFullArray($param_SearchAttributes, mcPUIX::PUIX_SUB_REFERENCELIST)) {
//											$SearchAttributes = $param_SearchAttributes[mcPUIX::PUIX_SUB_REFERENCELIST];
											$SearchAttributes = array_merge($SearchAttributes, $param_SearchAttributes[mcPUIX::PUIX_SUB_REFERENCELIST]);
//											D::show(array('$param_SearchAttributes' => $param_SearchAttributes, '$SearchAttributes' => $SearchAttributes),'hier gehts dann morgen weiter ;) ;(');
											
										}

										$PDOTableList = mcPUIX_PDO::getTableAsDBUIArray($param_HostAccount, $param_iStorable, $ConfigArray['TABLE'][mcPUIX::PUIX_SUB_REFERENCELIST]['TABLENAME'], $SearchAttributes);
//D::show($PDOTableList, '$PDOTableList');										
//										if(mcArray::checkKeyHasFullArray($PDOTableList, mcPUIX::PUIXArray, mcPUIX::PDOValues)) {
										if(mcArray::checkKeyHasFullArray($PDOTableList, mcPUIX::PUIXArray)) {
											$PDORow[mcPUIX::PUIXArray] = $PDOTableList[mcPUIX::PUIXArray];
										} 
//										if(mcArray::checkKeyHasFullArray($PDOTableList, mcPUIX::PDO_Special)) {
//											if(mcArray::checkKeyHasFullArray($PDORow, mcPUIX::PUIXArray)) {
//												
//											}
//											$PDORow[mcPUIX::PDO_Special] = $PDOTableList[mcPUIX::PDO_Special];
//										}

		//								D::show($PDOTableList, '$PDOTableList: '.$SQLWhere);								
									}
								}


							}
						} 
						/**
						* is this a element reference table from a list table
						*/
						ELSE IF(mcPUIX_CONFIG::getReferenceListTableName($param_tablename))	{

							if(mcArray::checkKeyHasFullArray($ConfigArray['TABLE'], 'LISTID')) {

								$ReferenceListTableName = mcPUIX_CONFIG::getReferenceListTableName($param_tablename); 

								foreach($PDOTable as &$PDORow) {
	//								D::show($ConfigArray['TABLE']['LISTID'], '$ReferenceListTableName = '.$ReferenceListTableName.'     '.$ConfigArray['TABLE']['LISTID'].'  ---- '.$SQLWhere);
									$SearchAttributes=array();
									$SQLWhere = ' where ';
									$bool_AND = false;
//									mcPUIX::PDO_OR
									foreach($ConfigArray['TABLE']['LISTID'] as $ListIDKey) {
										if($bool_AND) {
											$SQLWhere .= ' AND ';
										} else {
											$bool_AND = true;
										}
										$SQLWhere .= ' '.$ListIDKey.'='.$PDORow[$ListIDKey];
										$SearchAttributes[$ListIDKey] = $PDORow[$ListIDKey];
									}
									$SearchAttributes[mcPUIX::PDOLoadDepth] = $param_depth-1;

									$PDOTableList = mcPUIX_PDO::getTableAsDBUIArray($param_HostAccount, $param_iStorable, $ReferenceListTableName, $SearchAttributes);
									if(mcArray::checkKeyHasFullArray($PDOTableList, mcPUIX::PUIXArray, mcPUIX::PDOValues)) {
										$PDORow[mcPUIX::PUIXArray] = $PDOTableList[mcPUIX::PUIXArray];
									}									

								}
							}
						}
					}




					$result = array(
						mcPUIX::PUIXArray => array(
							mcPUIX::PDOValues => $PDOTable
						)
					);

					if(mcArray::checkKeyHasFullArray($returnFromSearchAttributes, mcPUIX::PDO_Special)) {
						$result[mcPUIX::PUIXArray][mcPUIX::PDO_Special] = $returnFromSearchAttributes[mcPUIX::PDO_Special];
					}
//					D::show($result, $var_query);
					return $result;
				} else {
					return false;
				}			
			}
			
		}
	}
	
	private static function getDatabaseTable_where($param_PrimaryKeys, $param_PrimaryValues, &$param_query, array &$param_bindValueArray) {
		$param_query .= ' where ';
		foreach($param_PrimaryKeys as $Pkey =>  $PrimaryKey ) {
			if(array_key_exists($PrimaryKey, $param_PrimaryValues)){
				if($Pkey>0) {
					$param_query .= ' and ';
				}
				if(array_key_exists(mcPUIX::FORM_DO_VAR, $param_PrimaryValues[$PrimaryKey])) {
					$PValue = $param_PrimaryValues[$PrimaryKey][mcPUIX::FORM_DO_VAR];
				} else {
					$PValue = $param_PrimaryValues[$PrimaryKey];
				}

//D::show($param_PrimaryValues[$PrimaryKey], $PrimaryKey.' = '.$PValue. ' -- '.$param_PrimaryValues[$PrimaryKey][mcPUIX::FORM_DO_VAR]);
				
				$param_query .= ' '.$PrimaryKey.'=:'.$PrimaryKey.'_'.$PValue;
				$param_bindValueArray[':'.$PrimaryKey.'_'.$PValue] = $PValue;											
				
//				$param_query .= ' '.$PrimaryKey.'=:'.$PrimaryKey.'_'.$param_PrimaryValues[$PrimaryKey];
//				$param_bindValueArray[':'.$PrimaryKey.'_'.$param_PrimaryValues[$PrimaryKey]] = $param_PrimaryValues[$PrimaryKey];							
			} else {
				return Error::newError('DevError',"not enough primary values for keys ",$param_query);
			}
		}		
		return true;
	}
	
	/**
	 *
	 * @param Account $param_HostAccount
	 * @param PDOLevel $param_iStorable
	 * @param array $param_ConfigArray -- array(
	 *		mcPUIX::PUIXArray => array(
	 *			mcPUIX::DBUIConfig => array(
	 *				tablename => array()
	 *			)
	 *		)
	 * )
	 * @param array $param_PreparedArray -- return from mcPUIX_PDO::prepareArrayForDBOperation()
	 *	array(
	 *		mcPUIX::PUIXArray => array(
	 *			mcPUIX::PDOToSaveValues => array(
	 *				tablename => array(
	 *					'DeleteRows' => array(),
	 *					'UpdateRows' => array(),
	 *					'NewRows'	=> array(),
	 *				)
	 *			)
	 *		)
	 * )
	 * @return type 
	 */
	public static function updateDatabaseTable(Account &$param_HostAccount, PDOLevel &$param_iStorable, array $param_ConfigArray, array $param_PreparedArray=null ) {
//		[mcPUIX::PUIXArray][mcPUIX::PDOToSaveValues][$param_tablename]
//		[mcPUIX::PUIXArray][mcPUIX::DBUIConfig][$param_tablename]
//		D::show($param_PreparedArray,'##########updateDatabaseTable:  $param_PreparedArray');		
//		D::show($param_ConfigArray, '$param_ConfigArray');
//		D::show($param_PreparedArray, '$param_PreparedArray: ');
		if(mcArray::checkKeyHasFullArray($param_PreparedArray, mcPUIX::PUIXArray, mcPUIX::PDOToSaveValues)) {
//			D::ulli($tablename.'   before');
			foreach($param_PreparedArray[mcPUIX::PUIXArray][mcPUIX::PDOToSaveValues] as $tablename => $preparedArray) {
//D::show($preparedArray, '$tablename: '.$tablename);

				if(mcArray::checkKeyHasFullArray($param_ConfigArray, mcPUIX::PUIXArray, mcPUIX::DBUIConfig, $tablename)) {
					
					$ConfigArray = $param_ConfigArray[mcPUIX::PUIXArray][mcPUIX::DBUIConfig][$tablename];
//					D::show(array($ConfigArray, $preparedArray), $i++.' updateDatabaseTable: '.$tablename);
				
				
				
					$TableConfig = null;
					$BoolActiveRow = false;


					if(array_key_exists(mcPUIX::FORM_DO_ROW, $ConfigArray) && is_array($ConfigArray[mcPUIX::FORM_DO_ROW])) {
						$BoolActiveRow = true;
					}

					if(array_key_exists('TABLE', $ConfigArray)
							&& array_key_exists('TABLENAME', $ConfigArray['TABLE']) && $ConfigArray['TABLE']['TABLENAME']
							&& array_key_exists('PRIMARY', $ConfigArray['TABLE']) && is_array($ConfigArray['TABLE']['PRIMARY'])
					) {
//D::cf($tablename.'  ');
						$TableConfig  = $ConfigArray['TABLE'];
//D::ulli($tablename. '   config');
						unset($TableConfig['TABLENAME']);

						/**
						 * ErrorRows
						 */
						if(mcArray::checkKeyHasFullArray($preparedArray, 'ErrorRows')) {
//							D::show($preparedArray['ErrorRows'], 'ErrorRows');
						}						
						/**
						 * delete the rows
						 */
						if(mcArray::checkKeyHasFullArray($preparedArray, 'DeleteRows')) {

							foreach($preparedArray['DeleteRows'] as $DeleteRow) {
								$DeleteRow = mcPUIX_PDO::formatForUpdateRowArray($DeleteRow);
								$var_bindValueArray = array();
								$var_query = 'delete from '.$ConfigArray['TABLE']['TABLENAME'].' ' ;

								if(mcPUIX_PDO::getDatabaseTable_where($TableConfig['PRIMARY'], $DeleteRow, $var_query, $var_bindValueArray)) {
//D::show($var_bindValueArray, '$var_query: '.$var_query);
									$stmt = $param_iStorable->PDO_query($var_query, $var_bindValueArray);
									if($stmt) {
									} else  {
										return Error::newError('DevUser','delete Dataset Error from Table '.$ConfigArray['TABLE']['TABLENAME'].' ',$query);
									}						
								} 					
							}
						}

						/**
						 * update the rows
						 */
						if(mcArray::checkKeyHasFullArray($preparedArray, 'UpdateRows')) {

							foreach($preparedArray['UpdateRows'] as $UpdateRow) {
								$UpdateRow = mcPUIX_PDO::formatForUpdateRowArray($UpdateRow);
//D::show(array($TableConfig,$UpdateRow),'UpdateRows UpdateRows');								
								$var_bindValueArray = array();
								$var_query = 'update '.$ConfigArray['TABLE']['TABLENAME'].' set ';
								$i=0;
								$bool_doUpdate = false;
								foreach($UpdateRow as $row_key => $row_value) {
									if($row_key!==mcPUIX::FORM_DO_ROW 
											&& $row_key!==mcPUIX::PUIXArray
											&& false===array_search($row_key, $TableConfig['PRIMARY'])) {
										if($i>0) {
											$var_query .= ', ';
										}
										$var_query .= ' '.$row_key.'=:'.$row_key.'_'.$i.'';
										$var_bindValueArray[':'.$row_key.'_'.$i] = $row_value;
										$i++;
										
										$bool_doUpdate = true;
									}
								}

								if($bool_doUpdate && mcPUIX_PDO::getDatabaseTable_where($TableConfig['PRIMARY'], $UpdateRow, $var_query, $var_bindValueArray)) {

									$stmt = $param_iStorable->PDO_query($var_query, $var_bindValueArray);
									if($stmt) {

									} else  {
										return Error::newError('UserError',"Fehler beim speichern von SocialNetInterfaceAddon ",$query);
									}						
								} else {
//									return Error::newError('DevError',"not enough primary values for keys ",$query);
								}
							}
						}
//D::show($preparedArray['NewRows'], 'NewRows1');
						/**
						 * insert the new rows
						 */
						if(mcArray::checkKeyHasFullArray($preparedArray, 'NewRows')) {

							foreach($preparedArray['NewRows'] as $NewRow) {
//D::show($NewRow, '$NewRow');								
								$NewRowSet = mcPUIX_PDO::formatForUpdateRowArray($NewRow);
								unset($NewRowSet[mcPUIX::FORM_DO_ROW]);
								if($TableConfig['KINDOF'] === 'LIST')  {
									if($NewRowSet) {

										$newID = $param_iStorable->PDO_insertRow($ConfigArray['TABLE']['TABLENAME'], $ConfigArray['TABLE']['LISTID'], $ConfigArray['TABLE']['ELEMENTID'], $NewRowSet, true); 
//D::show($NewRow, '$newID = '.$newID);
//										D::cf($ConfigArray['TABLE']['ELEMENTID'].' ===== '.$newID);
		
										if(mcArray::checkKeyHasFullArray($NewRow, mcPUIX::PUIX_SUB_REFERENCELIST, mcPUIX::PUIXArray, mcPUIX::FORM_NEW_ROW)
												&& mcArray::checkKeyHasFullArray($TableConfig, mcPUIX::PUIX_SUB_REFERENCELIST)
												&& $TableConfig[mcPUIX::PUIX_SUB_REFERENCELIST]['TABLENAME']
										) {
//											D::show($NewRow[mcPUIX::PUIX_SUB_REFERENCELIST][mcPUIX::PUIXArray][mcPUIX::FORM_NEW_ROW],'NewRows '.$ConfigArray['TABLE']['ELEMENTID'].' => '.$newID);											
											
//											D::show($NewRow[mcPUIX::PUIX_SUB_REFERENCELIST][mcPUIX::PUIXArray], '$NewRow[mcPUIX::PUIX_SUB_REFERENCELIST][mcPUIX::PUIXArray]');
											
											foreach($NewRow[mcPUIX::PUIX_SUB_REFERENCELIST][mcPUIX::PUIXArray][mcPUIX::FORM_NEW_ROW] as $NewSubRowKey => &$NewSubRow) {
												$NewSubRow[$ConfigArray['TABLE']['ELEMENTID']] = $newID;
											}
//											$NewRow[mcPUIX::PUIX_SUB_REFERENCELIST][mcPUIX::PUIXArray][mcPUIX::FORM_NEW_ROW][$ConfigArray['TABLE']['ELEMENTID']] = $newID;
											$NewSubArray =  array(mcPUIX::PUIXArray => array(mcPUIX::FORM_POST_VALUES => $NewRow[mcPUIX::PUIX_SUB_REFERENCELIST][mcPUIX::PUIXArray]));
//											D::show($NewSubArray, '$NewSubArray');
											$preparedNewSubRow = mcPUIX_PDO::prepareArrayForDBOperation($TableConfig[mcPUIX::PUIX_SUB_REFERENCELIST]['TABLENAME'], $param_ConfigArray, $NewSubArray);
//											D::Show($preparedNewSubRow, '$preparedNewSubRow');
											mcPUIX_PDO::updateDatabaseTable($param_HostAccount, $param_iStorable, $param_ConfigArray, $preparedNewSubRow);
											
											
//											$NewSubRowSet = mcPUIX_PDO::formatForUpdateRowArray($NewRow[mcPUIX::PUIX_SUB_REFERENCELIST][mcPUIX::PUIXArray][mcPUIX::FORM_NEW_ROW]);
//											$NewSubRowSet[$ConfigArray['TABLE']['ELEMENTID']] = $newID;
//											if(array_key_exists(mcPUIX::FORM_DO_ROW, $NewSubRowSet) && $NewSubRowSet[mcPUIX::FORM_DO_ROW]===mcPUIX::FORM_DO_NEW) {
//												unset($NewSubRowSet[mcPUIX::FORM_DO_ROW]);
//												D::show($NewSubRowSet, '$NewSubRowSet');
//												D::show($param_ConfigArray[mcPUIX::PUIXArray][mcPUIX::DBUIConfig][$TableConfig[mcPUIX::PUIX_SUB_REFERENCELIST]['TABLENAME']], '$TableConfig');
//											}
											
										}
									}

								} else if($TableConfig['KINDOF'] === 'DATASET') {
									D::show($preparedArray['NewRows'], 'FOR DATASET INSERT NOT IMPLEMENTED');
									
								} else if($TableConfig['KINDOF'] === 'RELATION') {
//									D::show($preparedArray['NewRows'], 'FOR RELATION INSERT NOT IMPLEMENTED');
									if($NewRow) {
//										D::show($NewRow,'NewRows');
										$NewRowSet = mcPUIX_PDO::formatForUpdateRowArray($NewRow);
										unset($NewRowSet[mcPUIX::FORM_DO_ROW]);
										$param_iStorable->PDO_insertRow($ConfigArray['TABLE']['TABLENAME'], $ConfigArray['TABLE']['LISTID'], null, $NewRowSet, true); 
									}									
								}								
							}							
						}
//						$DataBaseArray = array_merge($preparedArray['NewRows'], $preparedArray['UpdateRows']);
			//			D::show($DataBaseArray);
//						return $DataBaseArray;
					} else {
						D::show($ConfigArray['TABLE']);
						return Error::newError('DevError','Table Config is wrong, missing data');
					}				
				}
			}
		}
	}
	
	public static function formatForUpdateRowArray(array $param_UpdateRow) {
		if(is_array($param_UpdateRow) && !empty ($param_UpdateRow)) {
			$return = array();
//			D::show($param_UpdateRow, '$param_UpdateRow');
			
			if(mcArray::checkKeyHasFullArray($param_UpdateRow, mcPUIX::PDO_AND)) {
				
			} else if(mcArray::checkKeyHasFullArray($param_UpdateRow, mcPUIX::PDO_OR)) {
				
			} else if(mcArray::checkKeyHasFullArray($param_UpdateRow, mcPUIX::PDO_XOR)) {
				
			}
			
			
			/**
			 * delete the mcPUIX::FORM_DO_VAR key
			 */
			foreach($param_UpdateRow as $colkey => $colvalue) {
				if(array_key_exists(mcPUIX::FORM_DO_VAR, $colvalue)) {
					$return[$colkey] = $colvalue[mcPUIX::FORM_DO_VAR];
				} else {
					$return[$colkey] = $colvalue;
				}									
			}
			
			/**
			 * delete the mcPUIX config entrys
			 */
			if(array_key_exists(mcPUIX::PUIX_SUB_REFERENCELIST, $return)) {
				unset($return[mcPUIX::PUIX_SUB_REFERENCELIST]);
			}
			return $return;
		} else {
			return false;
		}
			
	}
	
}
?>