<?php

//function opensqlitedb ($filename="DB/all.sqlite3"){return new PDO("sqlite:".__DIR__."/".$filename);}

require_once('lib/logins.php');


$minutesbeforeclosetime = 15;

$lognow = true;
$cachenow = true;
$DB = DB();

settimezonetomanila();

$GLOBALS['CurrentUserUID'] = CurrentUserUID();


function SaveUploadedFile($fileInputIDName, $file_nameAndLocation = 'files/', $overwrite = false)
{
    if (!$fileInputIDName) {
        return false;
    }

    if (!$file_nameAndLocation) {
        $file_nameAndLocation = 'files/';
    }


    if ($_SERVER["REQUEST_METHOD"] == "POST" and isset($_FILES[$fileInputIDName])) {


        if (isset($_FILES[$fileInputIDName]) && $_FILES[$fileInputIDName]["error"] == UPLOAD_ERR_OK) {

            $file_name = $_FILES[$fileInputIDName]["name"];
            $file_tmp_name = $_FILES[$fileInputIDName]["tmp_name"];
            $file_size = $_FILES[$fileInputIDName]["size"];
            $file_type = $_FILES[$fileInputIDName]["type"];

            $target_dir = "uploads/";
            $target_file = $target_dir . basename($file_name);

            if (move_uploaded_file($file_tmp_name, $target_file)) {
                echo "The file " . htmlspecialchars($file_name) . " has been uploaded.";
            } else {
                echo "Sorry, there was an error uploading your file.";
            }

        } else {
            echo "Error: No file uploaded or an error occurred during upload.";
        }

    } else {
        // Redirect or handle invalid access
        return false;
    }

}


function getFileDataNowfromFileContent($uidorhashkey)
{
    if (!$uidorhashkey) {
        return false;
    }
    $details = getFileContentDetails($uidorhashkey);

    if (!$details) {
        return false;
    }
    if (!$details['content']) {
        //$filecheck = file

    }
}

function getFileDataNowfromFileList()
{

}


function getsqllitedata($query, $params = '', $sdb = null)
{
    if (!$sdb) {
        global $DB;
        $sdb = $DB;
    }

    try {
        if ($sdb instanceof PDO) {
            $statement = $sdb->prepare($query);

            if ($params && is_array($params)) {
                foreach ($params as $key => $values) {
                    $statement->bindParam(':' . $key, $values);
                }
            }

            $statement->execute();

            $result = [];
            while ($row = $statement->fetch(PDO::FETCH_ASSOC)) {
                $result[] = $row;
            }

            return $result;
        } else {
            echo "Invalid or missing database connection (PDO object).";
        }
    } catch (PDOException $e) {
        echo "Error: " . $e->getMessage();
    }
}

function sanitizeData($data)
{

    $data = preg_replace('/[^a-zA-Z0-9\s]/', '', $data);


    if (is_string($data)) {

        $data = htmlspecialchars($data, ENT_QUOTES);
    } elseif (is_int($data)) {
        // Layer 3: Validate integer range
        if ($data < 0 || $data > 100) {
            throw new Exception('Invalid integer range');
        }
    } else {
        throw new Exception('Invalid input type');
    }


    $data = strip_tags($data);


    $data = preg_replace('/(SELECT|INSERT|UPDATE|DELETE|DROP|CREATE|ALTER|TRUNCATE)/i', '', $data);

    return $data;
}

function opennewdb($dbname = "", $host = 'localhost', $user = 'root', $passwd = '')
{
    //if (!$dbname){return FALSE;}
    // if ($host==''){$host='localhost';}
    // if ($user==''){$user='root';}
    $dsn = "mysql:host=$host;dbname=$dbname";
    return new PDO($dsn, $user, $passwd);
}

function GetCurrenSelectedDatabaseName($DB)
{
    if (!$DB) {
        return false;
    }
    return selectfromsimple($DB, 'SELECT DATABASE();')[0]['DATABASE()'] ?? false;
}
function CheckifTableExistinCurrentDB($DBPDO, $tablename)
{
    if (!$DBPDO || !$tablename) {
        return false;
    }
    $CurrentDBName = GetCurrenSelectedDatabaseName($DBPDO);
    if (!$CurrentDBName) {
        return false;
    }
    $sqlquery = "SELECT * FROM information_schema.tables  
 WHERE table_schema = '" . $CurrentDBName . "'  
    AND table_name = '" . $tablename . "' 
  LIMIT 1;";


    $res = selectfromsimple($DBPDO, $sqlquery, $bindings = '$currentfieldbindablevalues', $noindex = 0);
    if (!$res) {
        return false;
    } else {
        return true;
    }
}

function selectfromsimple($db, $sqlquery, $bindings = '$currentfieldbindablevalues', $noindex = 0)
{
    //bindings = ['username'=>'john']
    if (!$db) {
        return FALSE;
    }

    $db->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);

    // if (file_exists('errsql.html')){
    // unlink("errsql.html");}

    // $dataerr =  printarrayorobject($sqlquery).printarrayorobject($bindings);

    // file_put_contents('errsql.html',$dataerr,FILE_APPEND);

    try {
        $arraybindings = [];

        $sth = $db->prepare($sqlquery);
        if ($bindings and is_array($bindings) and !empty($bindings)) {
            foreach ($bindings as $key => $value) {

                $currentcolumn = ':' . $key;
                if (is_array($value)) {
                    $value = json_encode($value);
                }
                if ($value === NULL) {
                    $value = '';
                }


                // $sth->bindValue($currentcolumn, $value);

                $arraybindings[$currentcolumn] = $value;
            }
        }
        // echo $sqlquery.printarrayorobject($arraybindings);
        // var_dump($sqlquery);
        global $lognow;
        if ($lognow) {
            file_put_contents('sqllogs.html', p($sqlquery) . p($arraybindings), FILE_APPEND);
        }

        if (!$arraybindings or empty($arraybindings) or $arraybindings == '$currentfieldbindablevalues') {
            $sth->execute();
        } else {
            $sth->execute($arraybindings);
        }

        // $sth->execute();

        // file_put_contents('errsql.html',pr(),FILE_APPEND);

        $nquery = fopen("php://memory", "w");

        fwrite($nquery, $sqlquery);

        fseek($nquery, 0);

        if (stripos(fread($nquery, "12"), "INSERT INTO ") !== FALSE) {

            $id = $db->lastInsertId();

            $res = $id;

            // file_put_contents('errsql.html',pr($sqlquery).'INSERT ID: '.printarrayorobject($res),FILE_APPEND);

        } elseif (stripos(substr($sqlquery, 0, 11), "SELECT ") !== FALSE) {

            if ($noindex) {
                $resultarr = $sth->fetchAll(PDO::FETCH_NUM);
            } else {
                $resultarr = $sth->fetchAll(PDO::FETCH_ASSOC);
            }

            global $cachenow;
            if ($cachenow) {
                $hashvalue = ArraytoHash($resultarr);
                if (!file_exists('DBCache/' . $hashvalue)) {
                    file_put_contents('DBCache/' . $hashvalue, json_encode($resultarr));
                }
            }

            $res = $resultarr;
        } elseif (stripos(substr($sqlquery, 0, 11), "UPDATE ") !== FALSE) {
        } elseif (stripos(substr($sqlquery, 0, 11), "Delete ") !== FALSE) {
        } else {

            if ($noindex) {
                $resultarr = $sth->fetchAll(PDO::FETCH_NUM);
            } else {
                $resultarr = $sth->fetchAll(PDO::FETCH_ASSOC);
            }

            $res = $resultarr;
        }
    } catch (PDOException $e) {

        // $sth->debugDumpParams();
        $db = NULL;
        global $lognow;
        if ($lognow) {
            file_put_contents('errlogs', $e . p($sqlquery) . p($bindings));
            file_put_contents('errsql.html', 'Error: ' . $e . p($sqlquery) . p($bindings), FILE_APPEND);
        }

        /*$statement->debugDumpParams();*/


        return FALSE;
    }

    fclose($nquery);


    $db = NULL;
    if (!isset($res))
        $res = TRUE;
    return $res;
}

function insertintodb($dbvar, $table, $data)
{

    $keystring = implode(',', array_keys($data));
    $placeholdersString = ':' . implode(',:', array_keys($data));
    $sql = 'INSERT INTO ' . $table . ' (' . $keystring . ') VALUES (' . $placeholdersString . '); ';
    return selectfromsimple($dbvar, $sql, $data);
}

function deletefromdb($table, $wheredata, $DB = false)
{
    if (!$table)
        return FALSE;
    if (!$wheredata or !is_array($wheredata)) {
        return FALSE;
    }
    if (!$DB) {
        $DB = DB();
    }
    foreach ($wheredata as $key => $value) {
        $wherefields[] = ' ' . $key . ' = :' . $key . ' ';
    }
    $wherestring = implode(" and ", $wherefields);
    $sql = 'DELETE FROM ' . $table . ' WHERE ' . $wherestring . ';';
    return selectfromsimple($DB, $sql, $wheredata);
}

function updatedbsimple($db, $table, $data, $wherearray)
{

    if (!$db) {
        $db = DB();
    }
    if (!$data) {
        return FALSE;
    }
    if (!$table) {
        return FALSE;
    }
    $updatefields = [];
    $wherefields = [];

    foreach ($data as $key => $value) {

        $updatefields[] = ' ' . $key . ' = :' . $key . ' ';
    }

    $updatefields = implode(' , ', $updatefields);

    foreach ($wherearray as $key => $value) {

        $wherefields[] = ' ' . $key . ' = :' . $key . ' ';
    }

    $wherefields = implode(' AND ', $wherefields);
    // file_put_contents('updatewhere',$wherefields);

    $query = "UPDATE  " . $table . ' SET ' . $updatefields . ' WHERE ' . $wherefields . ';';

    $finalarray = array_merge($data, $wherearray);

    global $lognow;
    if ($lognow) {
        file_put_contents('updatesql', $query);
    }

    $resultd = selectfromsimple($db, $query, $finalarray);
    if ($resultd) {
        return TRUE;
    }
}

function listselectsql($dbvariable, $tablename, $data = [], $likefields = [], $fieldstoselectarray = '', $orderby = '', $noindex = 0, $whereappend = ' and ', $dateonlyarray = '')
{

    if (!$noindex) {
        $noindex = 0;
    }
    if (!$data) {
        $data = [];
    }
    if (!$likefields) {
        $likefields = [];
    }
    if (!$whereappend) {
        $whereappend = ' and ';
    }

    $wherearray = [];
    $where = '';

    if ($likefields === '') {
        $likefields = [];
    }

    foreach ($data as $key => $value) {
        if ($value or $value === 0 or $value === '') {

            if (in_array($key, $likefields)) {
                if (is_array($dateonlyarray) and in_array($key, $dateonlyarray)) {
                    $wherearray[] = 'DATE(' . $key . ')' . ' LIKE :' . $key;
                } else {
                    $wherearray[] = $key . ' LIKE :' . $key;
                }
            } else {
                $wherearray[] = $key . '=:' . $key;
            }
        } else {
            unset($data[$key]);
        }
    }

    if (!empty($wherearray)) {
        $where = ' where ' . implode($whereappend, $wherearray) . ' ';
    }

    if ($fieldstoselectarray and !empty($fieldstoselectarray) and is_array($fieldstoselectarray)) {
        $fieldstoselect = implode(" , ", $fieldstoselectarray);
    } else {
        $fieldstoselect = '*';
    }
    if ($orderby) {
        $orderby = ' order by ' . $orderby . ' ';
    }

    $query = 'select ' . $fieldstoselect . ' from ' . $tablename . ' ' . $where . ' ' . $orderby . ' ;';


    return selectfromsimple($dbvariable, $query, $data, $noindex);
}
/**
 * Selects multiple values from a database table using the OR.
 *
 * @param PDO $dbvariable The database connection object.
 * @param string $table The name of the database table.
 * @param array $valuearray The array of values to select.
 * @param string $Columnname The name of the column to select from.
 * @param array $fieldstoselect The fields to select from the table. Defaults to *.
 * @param int|bool $noindex Whether to return the results with or without indexes. Defaults to 0.
 *
 * @return array|false The results of the query, or false if the query fails.
 */
function selectfromDBMultipleValuesSameField($dbvariable, $table, $valuearray, $Columnname, $fieldstoselect = '', $noindex = 0)
{
    if (!$dbvariable or !$table or !$valuearray or !$Columnname) {
        return false;
    }
    if ($fieldstoselect) {
        $fieldstoselect = '  ' . implode(',', $fieldstoselect) . '  ';
    } else {
        $fieldstoselect = " * ";
    }
    $wherearraystring = '';
    $wherearray = [];
    foreach ($valuearray as $key => $value) {
        $wherearray[] = $Columnname . '=:' . $key;
    }
    $wherearraystring = implode(' OR ', $wherearray);
    $query = 'select ' . $fieldstoselect . ' from ' . $table . ' where ' . $wherearraystring . ';';
    return selectfromsimple($dbvariable, $query, $valuearray, $noindex);
}

/**
 * Selects multiple values from a database table using the IN.
 *
 * @param PDO $dbvariable The database connection object.
 * @param string $table The name of the database table.
 * @param array $valuearray The array of values to select.
 * @param string $Columnname The name of the column to select from.
 * @param array $fieldstoselect The fields to select from the table. Defaults to *.
 * @param int|bool $noindex Whether to return the results with or without indexes. Defaults to 0.
 *
 * @return array|false The results of the query, or false if the query fails.
 */
function selectfromDBMultipleValuesSameFieldUSINGIN($dbvariable, $table, $valuearray, $Columnname, $fieldstoselect = '', $noindex = 0)
{

    if (!$dbvariable or !$table or !$valuearray or !$Columnname) {
        return false;
    }
    if ($fieldstoselect) {
        $fieldstoselect = '  ' . implode(',', $fieldstoselect) . '  ';
    } else {
        $fieldstoselect = " * ";
    }

    $placeholders = implode(',', array_fill(0, count($valuearray), '?'));
    $query = 'select ' . $fieldstoselect . ' from ' . $table . ' where ' . $Columnname . ' IN (' . $placeholders . ')';

    $dbvariable->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
    $sth = $dbvariable->prepare($query);
    $sth->execute($valuearray);

    if (stripos(substr($query, 0, 11), "SELECT ") !== FALSE) {
        if ($noindex) {
            $resultarr = $sth->fetchAll(PDO::FETCH_NUM);
        } else {
            $resultarr = $sth->fetchAll(PDO::FETCH_ASSOC);
        }
        return empty($resultarr) ? false : $resultarr;
    } else {
        return false;
    }
}


function checkifexists($table, $wherearray, $fieldstoselectarray = '', $orderby = '')
{
    return listselectsql(DB(), $table, $wherearray, $likefields = [], $fieldstoselectarray, $orderby, $noindex = 0)[0] ?? false;
}


function serverdatetimesql()
{
    return date("Y-m-d H:i:s", time());
}
function servedatename()
{
    return date("F j, Y h:i:s A", time());
}
function TimeConverttoMDY($timestring)
{
    return date("F j, Y h:i:s A", strtotime($timestring));
}
function settimezonetomanila()
{
    date_default_timezone_set('Asia/Manila');
}

function serverdateonlyforsql()
{
    return date("Y-m-d", time());
}
function isTargetDatePastToday($targetDate)
{
    $today = strtotime(date('Y-m-d'));
    $targetTimestamp = strtotime($targetDate);
    return $targetTimestamp < $today;
}
function isDateTimePastToday($targetdatetime)
{
    $today = strtotime(date('Y-m-d H:i:s'));  // Get current date and time
    $targetTimestamp = strtotime($targetdatetime); // Convert target datetime to timestamp

    return $targetTimestamp < $today;  // Check if target timestamp is before today
}

function isValidDate($str, $format = 'Y-m-d')
{

    try {
        $date = DateTime::createFromFormat($format, $str);
        return $date && $date->format($format) === $str;
    } catch (Exception $e) {
        return false;
    }
}

function convertTo24Hours_strtotime($timeStr)
{
    // Detect AM/PM using strpos
    $isPM = strpos($timeStr, "PM") !== false;

    // Remove AM/PM using str_replace
    $timeStr = str_replace(["AM", "PM"], "", $timeStr);

    // Convert hour to 24-hour format
    $hour = (int) $timeStr;
    if ($isPM && $hour !== 12) {
        $hour += 12;
    } else if (!$isPM && $hour === 12) {
        $hour = 0;
    }

    // Convert to timestamp using strtotime
    $timestamp = strtotime("$hour:00"); // Assume minutes are 00

    return $timestamp;
}

function convertsqltimetoPM($sqlTimeString)
{
    $timestamp = strtotime($sqlTimeString);

    return $formattedTime = date("H:i", $timestamp);
}

function convertMilitaryTimetoPMwithoutOClock($time24)
{ // sample 14:00 to 2PM
    $time12 = date('gA', strtotime($time24));
    return $time12;
}

function convertAMPMtosqltime($sqlTimeString)
{
    return convertsqltimetoPM($sqlTimeString);
}
function convertAMPMtosqltimeError($timeStr)
{
    if (strpos(strtolower($timeStr), "am") === false and strpos(strtolower($timeStr), "pm") === false) {
        return $timeStr;
    }
    $timeStr = convertTo24Hours_strtotime($timeStr);
    return date("H:i:s", time());
}

function isScheduleAllowed($date, $time, $schedule)
{
    $dayOfWeek = strtoupper(date('D', strtotime($date)));
    $inputTime = strtotime($time);

    foreach ($schedule as $allowedSchedule) {
        $allowedDay = strtoupper($allowedSchedule[0]);
        $allowedTime = strtotime($allowedSchedule[1]);

        if ($dayOfWeek === $allowedDay && $inputTime === $allowedTime) {
            return true;
        }
    }

    return false;
}


function isDayOfWeekMatch($date, $dayOfWeek)
{
    if (!$date or !$dayOfWeek) {
        return false;
    }
    // Ensure the input dayOfWeek is in a standard format (e.g., Mon, Tue)
    $dayOfWeek = strtoupper(substr($dayOfWeek, 0, 3));

    // Define the days of the week
    $daysOfWeek = ['SUN', 'MON', 'TUE', 'WED', 'THU', 'FRI', 'SAT'];

    // Parse the input date
    $inputDate = new DateTime($date);

    // Check if the day of the week matches
    return $daysOfWeek[$inputDate->format('w')] === $dayOfWeek;
}


function datetosqldatetime($datestring)
{
    return date("Y-m-d H:i:s", strtotime($datestring));
}

function isTargetTimepastMinutes($targettime, $numberofmins = '15', $currenttime = '')
{
    date_default_timezone_set('Asia/Manila');

    $targettime = strtotime('-' . $numberofmins . 'mins', strtotime($targettime));

    if (!$currenttime) {
        $currenttime = time();
    } else {
        $currenttime = strtotime($currenttime);
    }
    $currenttime = strtotime(date('H:i:s', $currenttime));

    if ($currenttime > $targettime) {
        return true;
    } else {
        return false;
    }
}


function istimepastDrawtime($time)
{
    global $minutesbeforeclosetime;
    if (!$minutesbeforeclosetime) {
        $minutesbeforeclosetime = 15;
    }
    $past = isTargetTimepastMinutes($time, $minutesbeforeclosetime);
    return $past;
}

function isCurrentTimeMinutesOrEarlierBeforeTargetTime($targetDateTime, $minutes)
{
    $targetDateTime = new DateTime($targetDateTime);
    $currentTime = new DateTime();
    $fifteenMinutesBeforeTarget = clone $targetDateTime;
    $fifteenMinutesBeforeTarget->sub(new DateInterval("PT" . $minutes . "M"));
    return $currentTime <= $fifteenMinutesBeforeTarget;
}

function mergeAndValidateDateTime($dateString, $timeString)
{
    try {

        $dateTimeString = "$dateString $timeString";

        $dateTime = DateTime::createFromFormat("Y-m-d H:i", $dateTimeString);


        if ($dateTime instanceof DateTime) {
            return $dateTimeString;
        } else {
            return false;
        }
    } catch (Exception $e) {
        return false;
    }
}


function DrawTimeAllowed($date, $time)
{
    $drawtime = mergeAndValidateDateTime($date, $time);
    if (!$drawtime) {
        return false;
    }
    global $minutesbeforeclosetime;
    if (!$minutesbeforeclosetime) {
        $minutesbeforeclosetime = 15;
    }
    return isCurrentTimeMinutesOrEarlierBeforeTargetTime($drawtime, $minutesbeforeclosetime);
}

function generatenewhash($table = 'users', $fieldname = 'hashkey')
{
    $hash = bin2hex(random_bytes(18) . random_bytes(18));
    $detect = selectfromsimple(DB(), 'select ' . $fieldname . ' from ' . $table . ' where ' . $fieldname . ' = "' . $hash . '";');
    if ($detect == '' or $detect == []) {
        return $hash;
    } else {
        return generatenewhash();
    }
}

function generate_sku($department, $category, $brand, $subcategory, $model, $datatable, $pdo)
{
    if (!$datatable or !$pdo) {
        return false;
    }
    $department = preg_replace('/[^a-zA-Z0-9\s-]/', '', $department);
    $category = preg_replace('/[^a-zA-Z0-9\s-]/', '', $category);
    $brand = preg_replace('/[^a-zA-Z0-9\s-]/', '', $brand);
    $subcategory = preg_replace('/[^a-zA-Z0-9\s-]/', '', $subcategory);
    $model = preg_replace('/[^a-zA-Z0-9\s-]/', '', $model);

    $sku_exists = true;
    while ($sku_exists) {
        $random_string = substr(str_shuffle(str_repeat("0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ", 10)), 0, 10);
        $sku = $department . '-' . $category . '-' . $brand . '-' . $subcategory . '-' . $model . '-' . $random_string;

        $stmt = $pdo->prepare("SELECT COUNT(*) as count FROM $datatable WHERE sku = :sku");
        $stmt->bindParam(':sku', $sku);
        $stmt->execute();
        $result = $stmt->fetch();

        if ($result['count'] == 0) {
            $sku_exists = false;
        }
    }
    return $sku;
}

function generateUniqueReferralCode($db = false, $fieldname = 'referral_code', $table = false)
{
    $charset = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789@!-+'; // Only numbers and capital letters
    $codeLength = 9; //for 20 billion users;
    if (!$db) {
        $db = DB();
    }
    if (!$table) {
        $table = 'referral_keys';
    }
    if (!$fieldname) {
        $fieldname = 'referral_code';
    }

    $query = "SHOW TABLES LIKE '$table'";
    $result = $db->query($query);
    if (!$result->rowCount()) {
        $query = "CREATE TABLE $table (uid INT PRIMARY KEY AUTO_INCREMENT, " . $fieldname . " VARCHAR($codeLength) NOT NULL UNIQUE)";
        $db->query($query);
    }

    $exists = true;
    do {
        $code = '';
        for ($i = 0; $i < $codeLength; $i++) {
            $code .= $charset[rand(0, strlen($charset) - 1)];
        }
        $exists = DB_REFERRAL_KEYS()->getDetailsbyReferral_Key($code);

    } while ($exists);

    return $code;
}

function checkifuserexists($mnumber = '', $hashkey = '', $nickname = '')
{
    $table = 'users';
    if (!$hashkey and !$mnumber and !$nickname) {
        return NULL;
    }

    if ($hashkey and checkifexists($table, ['hashkey' => $hashkey], ['uid'])) {
        return true;
    }

    if ($mnumber and checkifexists($table, ['mnumber' => $mnumber], ['uid'])) {
        return true;
    }
    if ($nickname and checkifexists($table, ['nickname' => $nickname], ['uid'])) {
        return true;
    }
}


// Generic DB function
function DB_QUERY($DB = false)
{

    $DBFUNC = new stdClass;
    $DBQueryclass = new DBQUERY($DB);
    $classmap = $DBQueryclass->classMap;

    foreach ($classmap as $key => $value) {
        $DBFUNC->$key = function ($DB) use ($value) {
            return new $value($DB);
        };
    }

    return $DBFUNC;
}

$classMap = [
    'USERS' => 'DB_USERS',
    'USERINFO' => 'DB_USERINFO',
    'FILE_LIST' => 'DB_FILE_LIST',
    'FILE_CONTENT' => 'DB_FILE_CONTENT'
];

/**
 * Class DBQUERY
 *
 * @method DB_USERS USERS($DB = null)
 * @method DB_USERINFO USERINFO($DB = null)
 * @method DB_PROPERTIES PROPERTIES($DB = null)
 * @method DB_REFERRALS REFERRALS($DB = null)
 * @method DB_REFERRAL_KEYS REFERRAL_KEYS($DB = null)
 * @method DB_FILE_CONTENT FILE_CONTENT($DB = null)
 * @method DB_FILE_LIST FILE_LIST($DB = null)
 * @method DB_STORES STORES($DB = null)
 * @method DB_PRODUCTS PRODUCTS($DB = null)
 * @method DB_PRODUCTS_TRANSACTIONS PRODUCTS_TRANSACTIONS($DB = null)
 * @method DB_POS_TRANSACTIONS POS_TRANSACTIONS($DB = null)
 * @method DB_PRODUCTS_TRANSACTIONS_SESSIONS PRODUCTS_TRANSACTIONS_SESSIONS($DB = null)
 * @method DB_CART CART($DB = null)
 * @method DB_PRODUCTSHISTORY PRODUCTS_HISTORY($DB=NULL)
 */
class DBQUERY
{
    public $DB;

    public $classMap = [];

    function __construct($DB = false)
    {
        if (!$DB) {
            $DB = DB();
        }
        $this->DB = $DB;
        global $classMap;
        $this->classMap = $classMap;

    }
    private function createInstance($methodName, $DB = false)
    {
        if (!$DB) {
            $DB = $this->DB ?: DB();
        }
        if (array_key_exists($methodName, $this->classMap)) {
            $className = $this->classMap[$methodName];
            return new $className($DB);
        }
        throw new Exception("Method $methodName not found in class map.");
    }

    public function __call($name, $arguments)
    {
        return $this->createInstance($name, $arguments[0] ?? false);
    }


}

function DBQUERY($DB = false)
{
    return new DBQUERY($DB);
}

function ModifySingleRowwithVerification($table, $newdata, $wherearray)
{
    if (!$wherearray || !$table || !$newdata) {
        return false;
    }

    $exists = checkifexists($table, $wherearray);

    if (!$exists or empty($exists)) {
        return false;
    }

    $db = DB();
    updatedbsimple($db, $table, $newdata, $wherearray);


    $newfetch = checkifexists($table, $wherearray);

    if (!$newfetch or empty($newfetch)) {
        return false;
    }


    foreach ($newdata as $key => $value) {
        $newfetchkey = tryjsondecode($newfetch[$key]);

        if (tryjsondecode($newdata[$key]) !== $newfetchkey) {//remove tryjson decodeif it causes problems

            return false;
        }
        return true;
    }

}

function ModifyDBfield($table, $newdata, $uidorhashkey)
{

    if (!$table) {
        return false;
    }

    //   if (!$newdata or empty($newdata)) {return false;}
    if (!$uidorhashkey or empty($uidorhashkey)) {
        return false;
    }
    if (is_numeric($uidorhashkey)) {
        $wherearray['uid'] = $uidorhashkey;
    } elseif (!is_numeric($uidorhashkey)) {
        $wherearray['hashkey'] = $uidorhashkey;
    }

    /* 
        $exists = checkifexists($table, $wherearray);

        if (!$exists or empty($exists)) {
            return false;
        }

        $db = DB();
        updatedbsimple($db, $table, $newdata, $wherearray);


        $newfetch = checkifexists($table, $wherearray);

        if (!$newfetch or empty($newfetch)) {
            return false;
        }


        foreach ($newdata as $key => $value) {
            $newfetchkey = tryjsondecode($newfetch[$key]);

            if (tryjsondecode($newdata[$key]) !== $newfetchkey) {//remove tryjson decodeif it causes problems

                return false;
            }
            return true;
        } */

    return ModifySingleRowwithVerification($table, $newdata, $wherearray);

}

function DeleteDBbyUIDorHashkey($table, $uidorhashkey)
{
    if (!$uidorhashkey or empty($uidorhashkey) or is_array($uidorhashkey)) {
        return false;
    }
    $wheredata = [];
    if (!is_numeric($uidorhashkey)) {
        $wheredata['hashkey'] = $uidorhashkey;
    } elseif (is_numeric($uidorhashkey)) {
        $wheredata['uid'] = $uidorhashkey;
    } else {
        return false;
    }
    if (!checkifexists($table, $wheredata)) {
        return NULL;
    }
    $delete = deletefromdb($table, $wheredata);
    if (!checkifexists($table, $wheredata)) {
        return true;
    } else {
        return true;
    }
}

function getDetailsbyUIDorHashkey($table, $uidorhashkey, $fieldstoselectarray = '')
{
    if (!$uidorhashkey) {
        return null;
    }
    if (is_numeric($uidorhashkey)) {
        $wherearray['uid'] = $uidorhashkey;
    } else {
        $wherearray['hashkey'] = $uidorhashkey;
    }
    $details = checkifexists($table, $wherearray, $fieldstoselectarray);
    return $details ?? false;
}


trait BASICDB
{
    public function GenerateNewHash($fieldname = 'hashkey')
    {
        return generatenewhash($this->tablename, $fieldname);
    }
    public function InsertIntoDB($data)
    {

        return insertintodb($this->DB, $this->tablename, $data);
    }

    public function InsertIntoDB_ExceptBlank($data)
    {
        foreach ($data as $key => $value) {
            if ($value === null || $value === '') {
                unset($data[$key]);
                continue;
            } elseif ($value === []) {
                $data[$key] = tryjsonencode($value);
                continue;
            }
        }
        return insertintodb($this->DB, $this->tablename, $data);
    }
    public function InsertIntoDBNewDatawithDefaults($data, $requiredfieldsarray = [])
    {
        if (!$data) {
            return false;
        }
        if (!isset($data['createdby']) || !$data['createdby']) {
            $data['createdby'] = CurrentUserUID();
        }

        if (!isset($data['photourl']) || !$data['photourl']) {
            $data['photourl'] = tryjsonencode($data['photourl']);
        }
        $userdata = DBQUERY()->USERS()->getDetailsbyUIDorHashkey($data['createdby']);
        if (!$userdata) {
            return false;
        }
        $datenow = serverdatetimesql();
        $data['created'] = $datenow;
        $data['modified'] = $datenow;
        $data['hashkey'] = $this->GenerateNewHash();
        if (!isset($data['logs']) || !$data['logs']) {
            $username = $userdata['username'] ?? '';
            $useruid = $userdata['uid'] ?? '';
            $data['logs'] = [[$datenow, 'Added by ' . $username . ' (' . $useruid . ')']];
            $data['logs'] = tryjsonencode($data['logs']);
        }
        if ($requiredfieldsarray && is_array($requiredfieldsarray)) {
            foreach ($requiredfieldsarray as $value) {
                if (!isset($data[$value])) {
                    return false;
                } elseif ($data[$value] === null || $data[$value] === '') {
                    return false;
                }
            }
        }
        return $this->InsertIntoDB_ExceptBlank($data);
    }
    function DefaultDBInsert($data, $requiredfieldsarray = [])
    {
        return $this->InsertIntoDBNewDatawithDefaults($data, $requiredfieldsarray);
    }
    function DefaultDBInsertwithHashResult($data, $requiredfieldsarray = [])
    {
        $key = $this->InsertIntoDBNewDatawithDefaults($data, $requiredfieldsarray);
        if (!$key) {
            return false;
        }
        $hash = $this->getHashkeyfromUID($key) ?? false;
        return $hash;
    }

    function DeleteFromDB($wheredata)
    {
        if (!$wheredata or empty($wheredata)) {
            return false;
        }
        return deletefromdb($this->tablename, $wheredata, $this->DB);
    }
    function DeleteDBbyUIDorHashkey($uidorhashkey)
    {
        return DeleteDBbyUIDorHashkey($this->tablename, $uidorhashkey);
    }
    function UpdateDB($data, $wherearray)
    {
        if (!$data or !$wherearray or empty($wherearray)) {
            return false;
        }
        return updatedbsimple($this->DB, $this->tablename, $data, $wherearray);
    }
    function ModifyDBfieldByUIDorHashkey($changeddata, $uidorhashkey)
    {

        if (!$uidorhashkey) {
            return false;
        }

        return ModifyDBfield($this->tablename, $changeddata, $uidorhashkey);
    }

    function ModifySingleRowwithVerification($newdata, $wherearray)
    {
        return ModifySingleRowwithVerification($this->tablename, $newdata, $wherearray);
    }

    function ListFromDB($data = [], $likefields = [], $fieldstoselectarray = '', $orderby = '', $noindex = 0, $whereappend = ' and ', $dateonlyarray = '', $DB = false, $tablename = false)
    {

        //$this->DB = $DB;
        //$this->tablename=$tablename;

        return listselectsql($this->DB, $this->tablename, $data, $likefields, $fieldstoselectarray, $orderby, $noindex, $whereappend, $dateonlyarray);
    }
    function ListFromDBMultipleValuesSameField($valuearray, $Columnname, $fieldstoselect = '', $noindex = 0)
    {
        //allows searching of database with OR in wherearray
        return selectfromDBMultipleValuesSameField($this->DB, $this->tablename, $valuearray, $Columnname, $fieldstoselect, $noindex);
    }
    function ListFromDBMultipleValuesSameFieldUSINGIN($valuearray, $Columnname, $fieldstoselect = '', $noindex = 0)
    {
        return selectfromDBMultipleValuesSameField($this->DB, $this->tablename, $valuearray, $Columnname, $fieldstoselect, $noindex);
    }
    function CheckifExists($wherearray, $fieldstoselectarray = '', $orderby = '')
    {
        if (!$wherearray) {
            return false;
        }
        return checkifexists($this->tablename, $wherearray, $fieldstoselectarray, $orderby);
    }
    function CheckifUIDorHashKeyExist($uidorhashkey, $fieldstoselectarray = '', $orderby = '')
    {
        if (!$uidorhashkey or is_array($uidorhashkey)) {
            return false;
        }
        $field = '';
        if (is_numeric($uidorhashkey)) {
            $field = 'uid';
        } elseif (is_string($uidorhashkey)) {
            $field = 'hashkey';
        } else {
            return false;
        }
        return checkifexists($this->tablename, [$field => $uidorhashkey], $fieldstoselectarray, $orderby);
    }
    function getDetailsbyUIDorHashkey($uidorhashkey, $fieldstoselectarray = '')
    {
        return getDetailsbyUIDorHashkey($this->tablename, $uidorhashkey, $fieldstoselectarray);
    }
    function getcurrentTableHash($fieldstoselectarray = ['uid,hashkey,created,modified'])
    {
        $data = $this->ListFromDB([], [], $fieldstoselectarray);
        return hash('sha256', json_encode($data));
    }
    function getcurrentTableHashSHORT()
    {
        //Not compatible with the original getcurrentTableHash function
        return $this->getcurrentTableHash(['uid', 'modified']);
    }
    function getUIDfromHashkey($hashkey)
    {
        if (!$hashkey) {
            return false;
        }
        if (is_numeric($hashkey)) {
            return $hashkey;
        }
        return $uid = $this->getDetailsbyUIDorHashkey($hashkey, ['uid'])['uid'] ?? false;
    }
    function getHashkeyfromUID($uid)
    {
        if (!$uid) {
            return false;
        }
        if (is_numeric($uid)) {
            return $this->getDetailsbyUIDorHashkey($uid, ['hashkey'])['hashkey'] ?? false;
        } elseif (is_string($uid)) {
            return $uid;
        }

    }

    function getSpecificFieldandTryJSONDecodebyUIDorHASHKEY($uidorhashkey, $fieldname)
    {
        if (!$uidorhashkey) {
            return false;
        }
        $details = $this->getDetailsbyUIDorHashkey($uidorhashkey, [$fieldname])[$fieldname] ?? false;
        if (!$details) {
            return false;
        }
        if (!is_array($details)) {
            $details = tryjsondecode($details);
        }
        return $details;
    }
    function setSpecificFieldbyUIDorHASHKEY($uidorhashkey, $fieldname, $dataorarray)
    {
        if (is_array($dataorarray)) {
            $data = tryjsonencode($dataorarray);
        } else {
            $data = $dataorarray;
        }
        return $this->ModifyDBfieldByUIDorHashkey([$fieldname => $fieldname], $uidorhashkey);
    }
    function AddtoSpecificFieldArraybyUIDorHASHKEY($uidorhashkey, $fieldname, $datatoadd)
    {
        $data = $this->getSpecificFieldandTryJSONDecodebyUIDorHASHKEY($uidorhashkey, $fieldname);
        if (!$data) {
            $data = [$datatoadd];
        } else {
            $data[] = $datatoadd;
        }
        $new = $this->setSpecificFieldbyUIDorHASHKEY($uidorhashkey, $fieldname, $data);
        if ($new) {
            return true;
        } else {
            return false;
        }
    }
    function ClearSpecificFieldbyUIDorHASHKEY($uidorhashkey, $fieldname)
    {
        return $this->setSpecificFieldbyUIDorHASHKEY($uidorhashkey, $fieldname, []);
    }
    function getLogsbyUIDorHASH($uidorhashkey)
    {
        return $this->getSpecificFieldandTryJSONDecodebyUIDorHASHKEY($uidorhashkey, 'logs');
    }
    function SetLogsbyUIDorHashkey($uidorhashkey, $logsarray)
    {
        return $this->setSpecificFieldbyUIDorHASHKEY($uidorhashkey, 'logs', $logsarray);
    }

    function AddLogbyUIDorHashkey($uidorhashkey, $newlog)
    {
        $logs = $this->getLogsbyUIDorHASH($uidorhashkey);
        if (!$logs) {
            $logs = [[serverdatetimesql(), $newlog]];
        } else {
            $logs[] = [serverdatetimesql(), $newlog];
        }
        $new = $this->SetLogsbyUIDorHashkey($uidorhashkey, $logs);
        if ($new) {
            return true;
        } else {
            return false;
        }
    }

    function ClearLogbyUIDorHashkey($uidorhashkey)
    {
        return $this->SetLogsbyUIDorHashkey($uidorhashkey, []);
    }

    function getFilesbyUIDorHASH($uidorhashkey)
    {
        return $this->getSpecificFieldandTryJSONDecodebyUIDorHASHKEY($uidorhashkey, 'files');
    }

    function setFilesbyUIDorHASH($uidorhashkey, $data)
    {
        return $this->setSpecificFieldbyUIDorHASHKEY($uidorhashkey, 'files', $data);
    }
    function addFilesbyUIDorHASH($uidorhashkey, $datatoadd)
    {
        return $this->AddtoSpecificFieldArraybyUIDorHASHKEY($uidorhashkey, 'files', $datatoadd);
    }
    function clearFilesbyUIDorHASH($uidorhashkey)
    {
        return $this->setFilesbyUIDorHASH($uidorhashkey, []);
    }

    function getphotoURLsbyUIDorHASH($uidorhashkey)
    {
        return $this->getSpecificFieldandTryJSONDecodebyUIDorHASHKEY($uidorhashkey, 'photourl');
    }

    function setphotoURLsbyUIDorHASH($uidorhashkey, $data)
    {
        return $this->setSpecificFieldbyUIDorHASHKEY($uidorhashkey, 'photourl', $data);
    }
    function addphotoURLsbyUIDorHASH($uidorhashkey, $data)
    {
        return $this->AddtoSpecificFieldArraybyUIDorHASHKEY($uidorhashkey, 'photourl', $data);
    }
    function cleaphotoURLsbyUIDorHASH($uidorhashkey)
    {
        return $this->ClearSpecificFieldbyUIDorHASHKEY($uidorhashkey, 'photourl');
    }


    function SetRemarksbyUIDorHASHKEY($uidorhashkey, $newremarks)
    {
        return $this->ModifyDBfieldByUIDorHashkey(['remarks' => $newremarks], $uidorhashkey);
    }
    function GetRemarksbyUIDorHASHKEY($uidorhashkey)
    {
        return $this->getDetailsbyUIDorHashkey($uidorhashkey, ['remarks'])['remarks'] ?? false;
    }
    function ClearRemarksbyUIDorHASHKEY($uidorhashkey)
    {
        return $this->SetRemarksbyUIDorHASHKEY($uidorhashkey, '');
    }

    function sqlqueryDB($query, $bindableValues, $noindex = 0)
    {
        return selectfromsimple($this->DB, $query, $bindableValues, $noindex);
    }

    function GetMaxValueofFieldTable($fieldname)
    {
        if (!$fieldname) {
            return false;
        }
        $query = "SELECT MAX(" . $fieldname . ") FROM " . $this->tablename . " AS greatest_value";
        return selectfromsimple($this->DB, $query)[0]['MAX(uid)'] ?? false;
    }
    function getIncrementedMaxValueofFieldTable($fieldname, $incrementby = 1)
    {
        if (!$fieldname) {
            return false;
        }
        if (!$incrementby) {
            $incrementby = 1;
        }
        return $this->GetMaxValueofFieldTable($fieldname) + $incrementby;
    }
    function GetLastUIDofTable()
    {
        return $this->GetMaxValueofFieldTable('uid');
    }
    function GetNewAvailableUIDofTable()
    {
        return $this->getIncrementedMaxValueofFieldTable('uid');
    }

    function ListbyFieldDateOnly($fieldname, $sqldateonlyformat, $fieldstoselect = '')
    {
        if (!$fieldname || !$sqldateonlyformat) {
            return false;
        }
        $array = $this->ListFromDB([], [], $fieldstoselect);
        $results = [];
        foreach ($array as $key => $value) {
            $currentDateFieldValue = $value[$fieldname];

            if (strpos($currentDateFieldValue, $sqldateonlyformat) !== false) {
                $results[] = $value;
            }

        }
        return $results;
    }

    function ListbyDateCreated($sqldateonlyformat, $fieldstoselect = '')
    {
        return $this->ListbyFieldDateOnly('created', $sqldateonlyformat, $fieldstoselect);
    }
    function ListbyDateModified($sqldateonlyformat, $fieldstoselect = '')
    {
        return $this->ListbyFieldDateOnly('modified', $sqldateonlyformat, $fieldstoselect);
    }
    function ModifyDBSinglefieldbyUID($uidorhashkey, $fieldname, $newfieldvalue)
    {
        if (!$uidorhashkey || !$fieldname || !$newfieldvalue) {
            return false;
        }
        return $this->ModifyDBfieldByUIDorHashkey([$fieldname => $newfieldvalue], $uidorhashkey);

    }
    function ListbyUniqueField_SingleField($fieldname, $data = [], $fieldstoselectarray = '', $likefields = [], $orderby = '', $noindex = 0, $whereappend = ' and ', $dateonlyarray = '')
    {
        if (!$fieldname) {
            return false;
        }
        $result = $this->ListFromDB($data, $likefields, $fieldstoselectarray, $orderby, $noindex, $whereappend, $dateonlyarray, $this->DB, $this->tablename);
        if (!$result) {
            return null;
        }

        $target_column = array_column($result, $fieldname) ?? false;
        if (!$target_column) {
            return false;
        }
        $unique = array_unique($target_column);
        return array_values($unique);
    }
    function InsertBasicDBHashCreatedModified($data)
    {
        if (!$data) {
            return false;
        }
        $data['hashkey'] = $this->GenerateHashKey();
        $date = serverdatetimesql();
        $data['created'] = $date;
        $data['modified'] = $date;

        $this->InsertIntoDB($data);

    }


}

class DBFunctions
{
    public $tablename;
    public $DB;
    use BASICDB;
    public function __construct($tablename, $DB = false)
    {

        if (!$tablename) {
            return false;
        }
        if (!isset($this->tablename)) {
            $this->tablename = '';
        }
        if ($tablename && !$this->tablename) {
            $this->tablename = $tablename;
        }
        if (!isset($this->DB)) {
            $this->DB = null;
        }
        if (!$DB) {
            $this->DB = DB();
        } else {
            $this->DB = $DB;
        }
        if (!$this->DB) {
            return false;
        }


    }


}

function DBFunctions($tablename, $DB = false)
{
    if (!$tablename) {
        return false;
    }

    return new DBFunctions($tablename, $DB);
}


trait STATUSDB
{

    public function UpdateStatus($uidorhashkey, $status)
    {
        if ($status === null || $status === false || !$uidorhashkey) {
            return false;
        }
        return $this->ModifyDBfieldByUIDorHashkey(['status' => $status], $uidorhashkey);
    }
    public function ViewStatus($uidorhashkey, $fieldstoselect = '')
    {
        return $this->getDetailsbyUIDorHashkey($uidorhashkey, $fieldstoselect);
    }

}

trait LOGSDB
{

    public function SetLogbyUID($uidorhashkey, $LogStringOrArray)
    {
        if (!$LogStringOrArray || !$uidorhashkey) {
            return false;
        }
        if (!is_array($LogStringOrArray)) {
            $LogStringOrArray = json_decode($LogStringOrArray, true) ?? false;
            if (!$LogStringOrArray) {

                return false;
            }
        }

        return $this->ModifyDBfieldByUIDorHashkey(['logs' => $LogStringOrArray], $uidorhashkey);
    }
    public function DeleteFullLogbyUID($uidorhashkey)
    {
        return $this->DeleteDBbyUIDorHashkey($uidorhashkey);
    }
    public function viewLogsbyUID($uidorhashkey)
    {
        if (!$uidorhashkey) {
            return false;
        }
        return json_decode($this->getDetailsbyUIDorHashkey($uidorhashkey, ['logs'])['logs'] ?? false, true) ?? false;
    }
    public function deleteLogbyArrayIndex($uidorhashkey, $LogArrayIndex)
    {
        if (!$uidorhashkey || !$LogArrayIndex || !is_numeric($LogArrayIndex)) {
            return false;
        }
        $logs = $this->logs->viewLogsbyUID($uidorhashkey);
        if (!$logs) {
            return false;
        }
        $LogsArray = json_decode($uidorhashkey, true) ?? false;
        if (!$LogsArray) {
            return false;
        }
        unset($LogsArray[$LogArrayIndex]);
        return $this->SetLogbyUID($uidorhashkey, json_encode(array_values($LogsArray)));
    }
    public function AddLog($uidorhashkey, $newlog)
    {

        if (!$uidorhashkey || !$newlog) {
            return false;
        }
        $exists = $this->getDetailsbyUIDorHashkey($uidorhashkey);

        if (!$exists) {
            return false;
        }
        $logs = $this->viewLogsbyUID($uidorhashkey);

        if (!$logs) {
            $logs = [];
            $logs[] = [serverdatetimesql(), $newlog];
        } elseif (is_array($logs)) {
            $logs[] = [serverdatetimesql(), $newlog];
        } else {
            return false;
        }

        return $this->SetLogbyUID($uidorhashkey, $logs);
    }


}


trait DBClassSearch
{

    function initialize($data = [], $likefields = [], $fieldstoselectarray = '', $orderby = '', $noindex = 0, $whereappend = ' and ', $dateonlyarray = '', $newdata = false, $DB = false)
    {
        if (is_array($fieldstoselectarray)) {
            foreach ($fieldstoselectarray as $key => $value) {
                $fieldstoselectarray[$key] = strtolower($value);
            }
        }

        if (!isset($this->DB) || !$this->DB) {
            $this->DB = $DB;
        }
        if (!$this->DB) {
            $this->DB = DB();
        }

        if ($newdata and is_array($newdata)) {
            $this->data = $newdata;
        } else {

            $this->data = DBFunctions($this->tablename, $this->DB)->ListFromDB($data, $likefields, $fieldstoselectarray, $orderby, $noindex, $whereappend, $dateonlyarray);
        }
    }

    function checkifUIDorHashKeyexist($uidorhashkey, $newdata = false)
    {
        if (!$uidorhashkey) {
            return false;
        }
        return !!$this->getDetailsbyUIDorHashkey($uidorhashkey, $exact = true, $newdata);
    }

    function currentTableHash($newdata = false)
    {
        if (!$newdata) {
            $newdata = $this->data;
        }
        return hash('sha256', json_encode($newdata));
    }

    function getUIDfromHASH($hash, $newdata = false)
    {
        if (!$hash) {
            return false;
        }

        if (!$newdata) {
            $newdata = $this->data;
        }

        return $this->List('hashkey', $hash, true, false, $newdata)[0]['uid'] ?? '';
    }

    function getHASHfromUID($uid, $newdata = false)
    {
        if (!$uid) {
            return false;
        }

        if (!$newdata) {
            $newdata = $this->data;
        }

        return $this->List('uid', $uid, true, false, $newdata)[0]['hashkey'] ?? '';
    }

    function List($fieldname, $contenttosearch, $exact = true, $caseinsensitive = false, $newdata = false, $usestrpos = false)
    {
        if (!$fieldname or !$contenttosearch) {
            return false;
        }
        if (is_array($newdata)) {
            return sqlarray_2dfilter($newdata, $fieldname, $contenttosearch, $exact, $caseinsensitive, $usestrpos);
        } else {
            if (!$this->data) {
                return false;
            }
            return sqlarray_2dfilter($this->data, $fieldname, $contenttosearch, $exact, $caseinsensitive, $usestrpos);
        }
    }

    function Find($fieldname, $contenttosearch, $exact = true, $caseinsensitive = false, $newdata = false)
    {
        return $this->List($fieldname, $contenttosearch, $exact, $caseinsensitive, $newdata)[0] ?? false;
    }

    function GetValue($fieldnametosearch, $contenttosearch, $fieldvaluetoget, $exact = true, $caseinsensitive = false, $newdata = false)
    {
        return $this->List($fieldnametosearch, $contenttosearch, $exact, $caseinsensitive, $newdata)[0][$fieldvaluetoget] ?? false;
    }

    function getDetailsbyUIDorHashkey($uidorhashkey, $exact = true, $newdata = false)
    {
        if (!$uidorhashkey) {
            return false;
        }
        if (!is_numeric($uidorhashkey)) {
            return $this->Find('hashkey', $uidorhashkey, $exact, false, $newdata);
        }
        return $this->Find('uid', $uidorhashkey, $exact, false, $newdata);
    }
    function getValueByUIDorHashkey($uidorhashkey, $fieldtoreturn, $newdata = false)
    {
        if (!$uidorhashkey || !$fieldtoreturn) {
            return false;
        }
        if (is_numeric($uidorhashkey)) {
            $field = 'uid';
        } else {
            $field = 'hashkey';
        }
        return $this->GetValue($field, $uidorhashkey, $fieldtoreturn, $exact = true, $caseinsensitive = false, $newdata);
    }

    function getCreatedDate($uidorhashkey, $newdata = false)
    {
        return $this->getValueByUIDorHashkey($uidorhashkey, 'created', $newdata);
    }

    function getModifiedDate($uidorhashkey, $newdata = false)
    {
        return $this->getValueByUIDorHashkey($uidorhashkey, 'modified', $newdata);
    }
}


//USER DB FUNCTIONS


function trylogin($mnumber, $password)
{
    //Logs Password

    if (!$mnumber or !$password) {
        return false;
    }
    $wherearray['mnumber'] = $mnumber;
    $wherearray['password'] = hash('sha256', $password);
    $wherearray['active'] = 1;
    $user = checkifexists('users', $wherearray, ['hashkey', 'uid']);
    if ($user and !empty($user)) {
        NewLog('system', 'login', 'Successful Login with Username' . $mnumber . '', $useruid = '-1');
        return $user;
    } else {
        NewLog('system', 'login', 'Failed Login with Username' . $mnumber . ' and password ' . $password, $useruid = '-1');
        return false;
    }
}


class UserSettingsDB
{
    function Get($uidorhashkey)
    {
        return GetUserSettings($uidorhashkey);
    }
    function Clear($uidorhashkey)
    {
        return ClearUserSettings($uidorhashkey);
    }
    function Update($uidorhashkey, $newsettingsvalue)
    {
        return UpdateUserSettings($uidorhashkey, $newsettingsvalue);
    }
}
class UserNotesDB
{
    function Get($uidorhashkey)
    {
        return GetUserNotes($uidorhashkey);
    }
    function Clear($uidorhashkey)
    {
        return ClearUserNotes($uidorhashkey);
    }
    function Update($uidorhashkey, $newnotevalue)
    {
        return UpdateUserNotes($uidorhashkey, $newnotevalue);
    }
}

class UserExecDB
{
    function Get($uidorhashkey)
    {
        return GetUserExec_Command($uidorhashkey);
    }
    function Clear($uidorhashkey)
    {
        return ClearUserExec_Command($uidorhashkey);
    }
    function Update($uidorhashkey, $exec_command_js)
    {
        return UpdateUserExec_Command($uidorhashkey, $exec_command_js);
    }
}
class UserBalanceDB
{
    function GetUserTotalBalancebyUID($uidorhashkey = '')
    {
        return GetUserTotalBalancebyUID($uidorhashkey);
    }
    function GetUserTotalCreditbyUID($uidorhashkey)
    {
        return GetUserTotalCreditbyUID($uidorhashkey);
    }
    public function UserTransferBalancetoAnotherUser($SenderuserUIDorHash, $RecipientUserUIDorHash, $amount)
    {
        return UserTransferBalancetoAnotherUser($SenderuserUIDorHash, $RecipientUserUIDorHash, $amount);
    }
    public function AddBalance($userUIDorHash, $amount)
    {
        return AddBalanceToUser($userUIDorHash, $amount);
    }
    public function checkAndDeductBalance($amount, $useruidorhashkey = '')
    {
        return checkAndDeductBalance($amount, $useruidorhashkey);
    }
    public function checkBalanceifEnough($amount, $useruidorhashkey = '')
    {
        return checkBalance($amount, $useruidorhashkey);
    }
    function deductBalance($amount, $useruidorhashkey = '')
    {
        return deductBalance($amount, $useruidorhashkey);
    }
}


enum UserType: string
{
    case ULTIMATE = 'ultimate';
    case SUPER_OPERATOR = 'super operator';
    case OPERATOR = 'operator';
    case COORDINATOR = 'coordinator';
    case USER = 'user';
    case RIDER = 'rider';
    case AUDIT = 'audit';
    case STORE_OWNER = 'store owner';
    case STORE_MANAGER = 'store manager';
    case SUPPLIER = 'supplier';
    case SUPPLIER_OVERSEER = 'supplier overseer';
    case WHOLESALE_BUYER = 'wholesale buyer';
}


class DB_USERS
{
    public $DB = false;
    public $tablename = 'users';
    use BASICDB;
    public function __construct($DB = false)
    {
        if (!$DB) {
            $DB = DB();
        }
        if (!$DB) {
            return false;
        }
        if ($DB) {
            $this->DB = $DB;
        }
        if (!$this->tablename) {
            return false;
        }
    }

    function isTargetUserActive($uidorhashkey)
    {
        return isTargetUserActive($uidorhashkey);
    }

    function NewUser($mnumber, $password, $nickname = '', $acct_type = '', $parentid = '', $active = 0, $target_uids = [], $notes = '', $exec_command = '', $settings = '', $multiple_logins = 0, $photourl = '')
    {
        return NewUser($mnumber, $password, $nickname, $acct_type, $parentid, $active, $target_uids, $notes, $exec_command, $settings, $multiple_logins, $photourl);
    }
    function ModifyUser($newdata, $uidorhashkey)
    {
        return ModifyUser($newdata, $uidorhashkey);
    }
    public function Settings()
    {
        return new UserSettingsDB;
    }
    public function Notes()
    {
        return new UserNotesDB;
    }
    public function Exec()
    {
        return new UserExecDB;
    }
    function DeleteUser($uidorhashkey)
    {
        return DeleteUser($uidorhashkey);
    }
    function GetUserDatabyUID($uidorhashkey, $fieldstoselect = '')
    {
        return GetUserDatabyUID($uidorhashkey, $fieldstoselect);
    }
    function getUserNumberbyHashkey($hashkey)
    {
        return getUserNumberbyHashkey($hashkey);
    }
    function GetUserUIDbyHashkey($hashkey)
    {
        return GetUserUIDbyHashkey($hashkey);
    }
    function GetUserTypeInDB($uidorhashkey = '')
    {
        return GetUserTypeInDB($uidorhashkey);
    }
    function Balance()
    {
        return new UserBalanceDB;
    }
    function GetParentUIDofUser($useruid = '')
    {
        return GetParentUIDofUser($useruid);
    }
    function GetUserCoordinatorNumber($uid = '')
    {
        return GetUserCoordinatorNumber($uid);
    }
    function setUserCoordinator($uidorhashkey, $coordinatoruid)
    {
        return setUserCoordinator($uidorhashkey, $coordinatoruid);
    }
    function ListALLUsers($wheredata = [], $fieldstoselect = '', $orderby = '')
    {
        return ListALLUsers($wheredata, $fieldstoselect, $orderby);
    }
    function ListUserIDsbyParent($parentuid, $fieldstoselect = '', $orderby = '')
    {
        return ListUserIDsbyParent($parentuid, $fieldstoselect, $orderby);
    }
    function ListUserIdsHashkey()
    {
        return ListUserIdsHashkey();
    }
    function searchUsersByParentUid($array, $parentUid, &$result)
    {
        return searchUsersByParentUid($array, $parentUid, $result);
    }
    function ListChildUsersofParent($parentuid, $fieldstoselect = '', $addself = false)
    {
        return ListChildUsersofParent($parentuid, $fieldstoselect, $addself);
    }
    function isTargetUserAChildofParent($target_useruidorhash, $parentuid = '', $fieldstoselect = '', $addself = false)
    {
        return isTargetUserAChildofParent($target_useruidorhash, $parentuid, $fieldstoselect, $addself);
    }
    function isTargetUserModificationAllowed($currentuseruidorhash, $targetuseruidorhash, $conditiontrue = true)
    {
        return isTargetUserModificationAllowed($currentuseruidorhash, $targetuseruidorhash, $conditiontrue);
    }
    function UserTransferBalancetoAnotherUser($SenderUID, $RecipientUID, $amount)
    {
        return UserTransferBalancetoAnotherUser($SenderUID, $RecipientUID, $amount);
    }


}

function DB_USERS($DB = false)
{
    return new DB_USERS($DB);
}


function NewUser($mnumber, $password, $nickname = '', $acct_type = '', $parentid = '', $active = 0, $target_uids = [], $notes = '', $exec_command = '', $settings = '', $multiple_logins = 0, $photourl = '', $referralcode = '')
{
    if (checkifuserexists($mnumber)) {
        return 'EXISTS';
    }
    $hash = generatenewhash();
    $datenow = serverdatetimesql();
    if ($multiple_logins) {
        $multiple_logins = 1;
    }

    $DB = DB();

    //   $referralcode = generateUniqueReferralCode($DB, 'users', 'referralcode');
    if ($photourl and is_array($photourl)) {
        $photourl = json_encode($photourl);
    }
    $photourl ??= '';
    $data = [
        'hashkey' => $hash,
        'mnumber' => $mnumber,
        'nickname' => $nickname,
        'acct_type' => $acct_type,
        'parentuid' => $parentid,
        'created' => $datenow,
        'modified' => $datenow,
        'active' => $active,
        'password' => hash('sha256', $password),
        'targetuids' => json_encode([]),
        'notes' => $notes,
        'settings' => $settings,
        'exec_command' => $exec_command,
        'multiple_logins' => $multiple_logins,
        'referralcode' => $referralcode,
        'photourl' => $photourl
    ];
    $key = insertintodb($DB, 'users', $data);
    if ($key) {
        return $key;
    } else {
        return false;
    }
}

function ModifyUser($newdata, $uidorhashkey)
{
    return ModifyDBfield('users', $newdata, $uidorhashkey);
}

function GetUserSettings($uidorhashkey)
{
    return tryjsondecode(GetUserDatabyUID($uidorhashkey)['settings']) ?? false;
}
function UpdateUserSettings($uidorhashkey, $newsettingsvalue)
{
    return ModifyUser(['settings' => $newsettingsvalue], $uidorhashkey);
}
function ClearUserSettings($uidorhashkey)
{
    return ModifyUser(['settings' => ''], $uidorhashkey);
}

function isTargetUserActive($uidorhashkey)
{
    if (!$uidorhashkey) {
        return null;
    }
    $getuser = GetUserDatabyUID($uidorhashkey, ['active'])['active'] ?? null;
    if (!$getuser or $getuser == 0 or $getuser === '0') {
        return false;
    }
    return $getuser;
}


function GetUserNotes($uidorhashkey)
{
    return GetUserDatabyUID($uidorhashkey)['notes'] ?? false;
}

function UpdateUserNotes($uidorhashkey, $newnotevalue)
{
    return ModifyUser(['notes' => $newnotevalue], $uidorhashkey);
}
function ClearUserNotes($uidorhashkey)
{
    return ModifyUser(['notes' => ''], $uidorhashkey);
}

function UpdateUserExec_Command($uidorhashkey, $exec_command_js)
{
    return ModifyUser(['exec_command' => $exec_command_js], $uidorhashkey);
}
function ClearUserExec_Command($uidorhashkey)
{
    return ModifyUser(['exec_command' => ''], $uidorhashkey);
}

function GetUserExec_Command($uidorhashkey)
{
    return GetUserDatabyUID($uidorhashkey)['exec_command'] ?? false;
}

function DeleteUser($uidorhashkey)
{
    return DeleteDBbyUIDorHashkey('users', $uidorhashkey);
}

function GetUserDatabyUID($uidorhashkey, $fieldstoselect = '')
{
    return getDetailsbyUIDorHashkey('users', $uidorhashkey, $fieldstoselect);
}

function checkifuserisActive($uidorhashkey)
{
    $user = GetUserDatabyUID($uidorhashkey, ['active']);
    if (!$user) {
        return NULL;
    }
    if ($user['active'] == 0) {
        return false;
    }
    if ($user['active'] == 1) {
        return true;
    }
    return NULL;
}

function getUserNumberbyHashkey($hashkey)
{
    if (is_numeric($hashkey)) {
        return false;
    }
    $user = GetUserDatabyUID($hashkey, ['mnumber']);
    if (!$user) {
        return false;
    }
    return $user['mnumber'];
}
function GetUserUIDbyHashkey($hashkey)
{
    if (!$hashkey or is_numeric($hashkey)) {
        return false;
    }
    $userdata = GetUserDatabyUID($hashkey, ['uid']);
    if (!$userdata or !$userdata['uid']) {
        return false;
    }
    return $userdata['uid'];
}

function GetUserTypeInDB($uidorhashkey = '')
{
    if (!$uidorhashkey) {
        return false;
    }
    return strtolower(GetUserDatabyUID($uidorhashkey, ['acct_type'])['acct_type']);
}


function GetUserTotalBalancebyUID($uidorhashkey = '')
{
    if (!$uidorhashkey) {
        global $CurrentUserUID;
        $uidorhashkey = $CurrentUserUID;
    }
    return getDetailsbyUIDorHashkey('users', $uidorhashkey, ['total_balance'])['total_balance'] ?? FALSE;
    // return checkifexists('users',['uid'=>$uid],['total_balance'])['total_balance'] ?? FALSE;
}

function GetUserTotalCreditbyUID($uidorhashkey)
{
    return getDetailsbyUIDorHashkey('users', $uidorhashkey, ['total_credit'])['total_credit'] ?? FALSE;
    //  return checkifexists('users',['uid'=>$uid],['total_credit'])['total_credit'] ?? FALSE;
}

function ChangeUserPassword($uidorhashkey, $password)
{
    if (!$uidorhashkey or !$password) {
        return false;
    }
    return ModifyUser(['password' => hash('sha256', $password)], $uidorhashkey);
}

function UserTransferBalancetoAnotherUser($SenderuserUIDorHash, $RecipientUserUIDorHash, $amount)
{
    global $IsUserOperator;
    global $IsUserSuperOperator;
    global $IsUserUltimate;
    $Senderbalance = GetUserTotalBalancebyUID($SenderuserUIDorHash);
    $Recipientbalance = GetUserTotalBalancebyUID($RecipientUserUIDorHash);
    if ($IsUserSuperOperator or $IsUserUltimate) { // ad $IsUserOperator to remove limit of operator
        $Senderbalance = 99999999999999999999999999;
    }

    if (!$Senderbalance or $Recipientbalance === false) {
        // echo 'recipienterror';
        return false;
    }
    if ($Senderbalance < $amount) {
        //echo 'amounterror';
        return false;
    }
    $SenderNewbalance = $Senderbalance - $amount;
    $RecipientNewbalance = $Recipientbalance + $amount;

    if (!$IsUserSuperOperator and !$IsUserUltimate) { // add !$IsUserOperator and  to remove limit of operator
        $deductbalance = checkAndDeductBalance($amount, $SenderuserUIDorHash);
    }


    $Senderbalance = GetUserTotalBalancebyUID($SenderuserUIDorHash);
    $Recipientbalance = GetUserTotalBalancebyUID($RecipientUserUIDorHash);


    if ($Senderbalance === $SenderNewbalance or ($IsUserSuperOperator or $IsUserUltimate)) { // add $IsUserOperator or to remove limit of operator
        $AddBalanceSuccessful = AddBalanceToUser($RecipientUserUIDorHash, $amount);
        $Recipientbalance = GetUserTotalBalancebyUID($RecipientUserUIDorHash);

        $creditrequest = DB_CREDIT_REQUESTS()->CreateCreditRequest($amount, $SenderuserUIDorHash, $RecipientUserUIDorHash, 0, null, serverdatetimesql());

        if (!$creditrequest) {
            return false;
        }

        if ($Recipientbalance === $RecipientNewbalance) {
            return true;
        }
    } else {
        return false;
    }
}

function checkBalance($amount, $useruidorhashkey = '')
{
    if (!$amount or !is_numeric($amount) or $amount < 0) {
        return false;
    }

    if (!$useruidorhashkey) {
        $useruidorhashkey = CurrentUserUID();
    }
    if (!$useruidorhashkey) {
        return false;
    }

    $user = GetUserDatabyUID($useruidorhashkey, ['total_balance']);
    if (!$user or empty($user) or $user['total_balance'] < $amount) {
        return false;
    }

    return true;
}

function deductBalance($amount, $useruidorhashkey = '')
{
    if (!checkBalance($amount, $useruidorhashkey)) {
        return false;
    }

    $user = GetUserDatabyUID($useruidorhashkey, ['total_balance']);
    $new_balance = $user['total_balance'] - $amount;
    $data['total_balance'] = $new_balance;

    ModifyUser($data, $useruidorhashkey);
    $user = GetUserDatabyUID($useruidorhashkey, ['total_balance']);

    return $user['total_balance'] === $new_balance;
}

function checkAndDeductBalance($amount, $useruidorhashkey = '')
{
    if (!$amount or !is_numeric($amount)) {
        return false;
    }
    if ($amount < 0) {
        return false;
    }

    if (!$useruidorhashkey) {
        $useruidorhashkey = CurrentUserUID();
    }
    if (!$useruidorhashkey) {
        return false;
    }
    $user = GetUserDatabyUID($useruidorhashkey, ['total_balance']);
    if (!$user or empty($user)) {
        return false;
    }
    if ($user['total_balance'] < $amount) {
        return false;
    }
    $new_balance = $user['total_balance'] - $amount;
    $data['total_balance'] = $new_balance;
    ModifyUser($data, $useruidorhashkey);
    $user = GetUserDatabyUID($useruidorhashkey, ['total_balance']);
    if ($user['total_balance'] === $new_balance) {
        return true;
    } else {
        return false;
    }
}

function AddBalanceToUser($userUIDorHash, $amount)
{
    if (!$amount) {
        return false;
    }
    $oldbalance = GetUserTotalBalancebyUID($userUIDorHash);
    $newbalance = $oldbalance + $amount;
    $data['total_balance'] = $newbalance;
    ModifyUser(['total_balance' => $newbalance], $userUIDorHash);
    if ($newbalance === GetUserTotalBalancebyUID()) {
        return true;
    } else {
        return false;
    }
}


function GetParentUIDofUser($useruid = '')
{
    if (!$useruid) {
        global $CurrentUserUID;
        $useruid = $CurrentUserUID;
    }
    if (!$useruid) {
        $useruid = CurrentUserUID();
    }
    if (!$useruid) {
        return false;
    }

    $ParentUID = GetUserDatabyUID($useruid, ['parentuid'])['parentuid'] ?? false;
    if ($ParentUID) {
        return $ParentUID;
    } else {
        return false;
    }
}


function GetUserCoordinatorNumber($uid = '')
{
    if (!$uid) {
        global $CurrentUserUID;
        $uid = $CurrentUserUID;
    }
    if (!$uid) {
        return false;
    }
    $ParentUID = GetParentUIDofUser($uid);
    if (!$ParentUID) {
        return false;
    }
    $ParentNumber = GetUserDatabyUID($ParentUID, ['mnumber'])['mnumber'] ?? false;
    return $ParentNumber;
}

function setUserCoordinator($uidorhashkey, $coordinatoruid)
{
    $newdata['parentuid'] = $coordinatoruid;
    return ModifyDBfield('users', $newdata, $uidorhashkey);
}

function ListALLUsers($wheredata = [], $fieldstoselect = '', $orderby = '')
{
    global $DB;
    if (!$wheredata) {
        $wheredata = [];
    }

    $list = listselectsql($DB, 'users', $wheredata, [], $fieldstoselect, $orderby) ?? '';
    if (empty($list)) {
        return false;
    }
    return $list;
}

function ListUserIDsbyParent($parentuid, $fieldstoselect = '', $orderby = '')
{
    if (!$parentuid) {
        return false;
    }
    return ListALLUsers(['parentuid' => $parentuid], $fieldstoselect, $orderby);
}

function ListUserIdsHashkey()
{
    $list = ListALLUsers([], ['hashkey', 'uid']);
    return $list ?? '';
}

class UserQuickMultipleSearch
{
    use DBClassSearch;
    public $data;

    public $tablename = 'users';

    private $parentidresults = [];
    public $DB;

    public function __construct($data = [], $likefields = [], $fieldstoselectarray = '', $orderby = '', $noindex = 0, $whereappend = ' and ', $dateonlyarray = '', $newdata = false)
    {
        return $this->initialize($data, $likefields, $fieldstoselectarray, $orderby, $noindex, $whereappend, $dateonlyarray, $newdata, $this->DB, $this->tablename);
    }

    function getNickname($uidorhashkey, $newdata = false)
    {
        return $this->getValueByUIDorHashkey($uidorhashkey, 'nickname', $newdata);
    }
    function getUsername($uidorhashkey, $newdata = false)
    {
        return $this->getValueByUIDorHashkey($uidorhashkey, 'username', $newdata);
    }

    function getNumberbyUIDorHashkey($uidorhashkey, $newdata = false)
    {
        return $this->getValueByUIDorHashkey($uidorhashkey, 'mnumber', $newdata);
    }
    function getParentUIDbyUserUID($useruid, $newdata = false)
    {
        return $this->GetValue('uid', $useruid, 'parentuid', $exact = true, false, $newdata);
    }
    function getParentUIDbyUserHashkey($useridorhashkey, $newdata = false)
    {
        return $this->getValueByUIDorHashkey($useridorhashkey, 'parentuid', $newdata);
    }
    function filterbyAcct_Type($acct_type, $newdata = false)
    {
        if (!$acct_type) {
            return false;
        }
        return $this->List('acct_type', $acct_type, $exact = true, true, $newdata);
    }
    public function searchUsersByParentUid($parentUid)
    {
        $this->parentidresults = [];
        $this->searchUsersByParentUidRecursive($this->data, $parentUid, $this->parentidresults);
        return $this->parentidresults;
    }

    private function searchUsersByParentUidRecursive($array, $parentUid, &$result)
    {
        foreach ($array as $user) {
            if ($user['parentuid'] == $parentUid) {
                $result[] = $user;
                $this->searchUsersByParentUidRecursive($array, $user['uid'], $result);
            }
        }
    }
}

function searchUsersByParentUid($array, $parentUid, &$result)
{
    foreach ($array as $user) {
        if ($user['parentuid'] == $parentUid) {
            $result[] = $user;
            searchUsersByParentUid($array, $user['uid'], $result);
        }
    }
}

function ListChildUsersofParent($parentuid, $fieldstoselect = '', $addself = false)
{
    $users = new UserQuickMultipleSearch();
    $user_list = $users->data;
    $list = [];
    //fix parent uid looping by itself when there is useruid and parentuid is the same
    searchUsersByParentUid($user_list, $parentuid, $list);
    if ($addself) {
        $list[] = $users->getDetailsbyUIDorHashkey($parentuid);
    }
    if ($fieldstoselect and is_array($fieldstoselect)) {
        $list = filterArrayColumns($list, $fieldstoselect);
    }

    return $list;
}

function isTargetUserAChildofParent($target_useruidorhash, $parentuid = '', $fieldstoselect = '', $addself = false)
{
    if (!$target_useruidorhash) {
        return false;
    }
    if (!$parentuid) {
        $parentuid = CurrentUserUID();
    }
    $children = ListChildUsersofParent($parentuid, $fieldstoselect = '', $addself = false);
    if (is_numeric($target_useruidorhash)) {
        $columnsearch = 'uid';
    } else {
        $columnsearch = 'hashkey';
    }
    $ischild = sqlarray_2dfilter($children, $columnsearch, $target_useruidorhash, true);
    if (!$ischild) {
        return false;
    } else {
        return $ischild[0] ?? false;
    }
}


function isTargetUserModificationAllowed($currentuseruidorhash, $targetuseruidorhash, $conditiontrue = true)
{ // to edit
    if (!$conditiontrue) {
        return false;
    }
    $currentuser = GetUserDatabyUID($currentuseruidorhash);
    $targetuser = GetUserDatabyUID($targetuseruidorhash);
    $currentuserUID = $currentuser['uid'] ?? false;
    $targetuserUID = $targetuser['uid'] ?? false;


    if (!$currentuser or !$targetuser) {
        return false;
    }
    $currentuser_type = $currentuser['acct_type'] ?? false;
    $targetuser_type = $targetuser['acct_type'] ?? false;

    if (!$currentuser_type or !$targetuser_type) {
        return false;
    }

    $CurrentUserisUltimate = $currentuser_type === 'ult';
    $CurrentUserisSuperOperator = $currentuser_type === 'super operator';
    $CurrentUserisOperator = $currentuser_type === 'operator';
    $CurrentUserisCoordinator = $currentuser_type === 'coordinator';
    $CurrentUserisUsher = $currentuser_type === 'usher';
    $CurrentUserisNormalUser = $currentuser_type === 'user';
    $CurrentUserisDisabler = $currentuser_type === 'disabler';
    $CurrentUserisViewer = $currentuser_type === 'viewer';

    $TargetUserisUltimate = $targetuser_type === 'ult';
    $TargetUserisSuperOperator = $targetuser_type === 'super operator';
    $TargetUserisOperator = $targetuser_type === 'operator';
    $TargetUserisCoordinator = $targetuser_type === 'coordinator';
    $TargetUserisUsher = $targetuser_type === 'usher';
    $TargetUserisNormalUser = $targetuser_type === 'user';
    $TargetUserisDisabler = $targetuser_type === 'disabler';
    $TargetUserisViewer = $targetuser_type === 'viewer';


    $CurrentUserlevel = ($CurrentUserisUltimate) ? 20 : (($CurrentUserisSuperOperator) ? 19 : (($CurrentUserisOperator) ? 18 : (($CurrentUserisCoordinator) ? 17 : (($CurrentUserisUsher) ? 16 : (($CurrentUserisDisabler) ? 15 : (($CurrentUserisNormalUser) ? 14 : (($CurrentUserisViewer) ? 13 : false)))))));

    $TargetUserlevel = ($TargetUserisUltimate) ? 20 : (($TargetUserisSuperOperator) ? 19 : (($TargetUserisOperator) ? 18 : (($TargetUserisCoordinator) ? 17 : (($TargetUserisUsher) ? 16 : (($TargetUserisDisabler) ? 15 : (($TargetUserisNormalUser) ? 14 : (($TargetUserisViewer) ? 13 : false)))))));


    $children = ListChildUsersofParent($currentuserUID, ['uid']);
    $children = array_column($children, 'uid');
    sort($children);
    $isIndirectParentofTargetUser = in_array($targetuserUID, $children);

    if ($CurrentUserisViewer) {
        return false;
    }
    if ($CurrentUserisUltimate) {
        return true;
    }
    if ($CurrentUserisSuperOperator and !$TargetUserisUltimate) {
        return true;
    }
    if ($CurrentUserlevel > $TargetUserlevel and $isIndirectParentofTargetUser) {
        return true;
    }


    return false;
}


require_once('EXT/DBEXT/USERINFODB.php');
require_once('EXT/DBEXT/FILESDB.php');
require_once('EXT/DBEXT/MARKETDB.php');