}
 
    public static function SetObject($key, $var, $expire = 86400) {
        return static::Set($key, serialize($var), $expire);
    }
 
    public static function SetArray($key, $var, $expire = 86400) {
        return static::Set($key, serialize($var), $expire);
    }
 
    public static function SetBoolean($key, $var, $expire = 86400) {
        return static::Set($key, serialize($var), $expire);
    }
 
    public static function Set($key, $var, $expire = 86400) {
        App::debugbarLog('debug', "Cache set: $key");
        if ($i = static::getInstance()) {
            $var = static::beforeSet($var);
            return $expire > 0?
                $i->setEx($key, $expire, $var) :
                $i->set($key, $var);
        }
        return null;
    }
 
    public static function Exists(...$key):?bool {
        if ($i = static::getInstance()) {
            return $i->exists($key);
        }
        return null;
    }
 
    public static function Expire($key, $ttl) {
        if ($i = static::getInstance()) {
            return $i->expire($key, $ttl);
        }
        return false;
    }
 
    /**

                if (!@static::$redisObj->connect(static::$host, (int)static::$port)) {
                    static::$redisObj = false;
                    Splunk::log(Splunk::LOG_REDIS_CONN, ['error' => 'Error connecting']);
                } else {
                    static::$redisObj->select(static::$db);
                }
            } catch (RedisException $e) {
                static::$redisObj = false;
                Splunk::log(Splunk::LOG_REDIS_CONN, ['error' => 'Error connecting: '.$e->getMessage()]);
            }
        }
        return static::$redisObj;
    }
 
    public static function SetObject($key, $var, $expire = 86400) {
        return static::Set($key, serialize($var), $expire);
    }
 
    public static function SetArray($key, $var, $expire = 86400) {
        return static::Set($key, serialize($var), $expire);
    }
 
    public static function SetBoolean($key, $var, $expire = 86400) {
        return static::Set($key, serialize($var), $expire);
    }
 
    public static function Set($key, $var, $expire = 86400) {
        App::debugbarLog('debug', "Cache set: $key");
        if ($i = static::getInstance()) {
            $var = static::beforeSet($var);
            return $expire > 0?
                $i->setEx($key, $expire, $var) :
                $i->set($key, $var);
        }
        return null;
    }
 
    public static function Exists(...$key):?bool {
        if ($i = static::getInstance()) {
            return $i->exists($key);

        if ($aObj || is_null($aObj)) {
            return $aObj;
        }
 
        $db_conn = DB::conn();
        $rbs = array();
        if ($cid && $isHiddenToCustomers) {
            $sql .= ' AND show_category_when_closed = 0';
        }
        $sql = "SELECT * FROM ".ClosedHours::getTableName()." WHERE (restaurant_id = ? OR category_id = ?) ".$sql." ORDER BY id DESC";
        $db_conn->bindParameter($sql, 1, $rid, "integer");
        $db_conn->bindParameter($sql, 1, $cid, "integer");
        $result = $db_conn->query($sql);
        if ($result && $result->rowCount() > 0) {
            while ($row = $result->fetch()) {
                $ch = new ClosedHours();
                $ch->loadFromArray($row, true);
                $rbs[] = $ch;
            }
            Cache::SetArray($cacheKey, $rbs);
            return $rbs;
        }
        Cache::SetObject($cacheKey, null);
        return null;
    }
    
    public static function clearCache($rid, $cid = null) {
        global $days;
        $types = ['PICKUP', 'DINEIN', 'DELIVERY'];
        $isHiddenToCustomersArray = [0, 1];
        foreach ($days as $d) {
            foreach ($types as $t) {
                foreach ($isHiddenToCustomersArray as $isHiddenToCustomers) {
                    Cache::Delete('ch_'.($cid > 0? ('c'.$cid) : ('r'.$rid)).'_'.mb_strtolower($d).'_'.$t.'_'.$isHiddenToCustomers);
                }
            }
        }
    }
 
    public function toString() {

        }
        if (!$time) {
            $time = $restaurant->getLocalTime();
        }
        $closedHours = ClosedHours::getByDateAndCategoryAndType($time, $category->getId(), $orderType, $isHiddenToCustomers);
        if (is_array($closedHours) && count($closedHours) > 0) {
            return $closedHours;
        }
        //check parent category too
        if ($category->getParentId()) {
            $closedHours = ClosedHours::getByDateAndCategoryAndType($time, $category->getParentId(), $orderType, $isHiddenToCustomers);
            if (is_array($closedHours) && count($closedHours) > 0) {
                return $closedHours;
            }
        }
        return false;
    }
 
    public static function getByDateAndRestaurantAndType($time = null, $rid = -1, $type = 'PICKUP') {
        return ClosedHours::getByDateAndTypeAndRestaurantOrCategory($time, $rid, null, $type);
    }
 
    public static function getByDateAndCategoryAndType($time = null, $cid = null, $type = 'PICKUP', $isHiddenToCustomers = false) {
        return ClosedHours::getByDateAndTypeAndRestaurantOrCategory($time, -1, $cid, $type, $isHiddenToCustomers);
    }
 
    public static function getByDateAndTypeAndRestaurantOrCategory($time = null, $rid = -1, $cid = -1, $type = 'PICKUP', $isHiddenToCustomers = false) {
        $day = mb_strtolower(date('l', $time));
        $sql = " AND ".$day." = 1";
 
        if (!$type) {
            $type = 'PICKUP';
        }
        switch ($type) {
            case 'PICKUP':
                $sql .= " AND pickup=1 ";
                break;
            case 'DELIVERY':
                $sql .= " AND delivery=1 ";
                break;

        // check to see if we are operating in holiday hours
        $holidayHours = HolidayHours::getByDateAndRestaurantAndType(date('Y-m-d 00:00:00', $local), $this->getId(), $type);
        if (is_object($holidayHours)) {
            $startTime = strtotime(date('1990-01-01 H:i:00', strtotime($holidayHours->getStartHour())));
            $endTime = strtotime(date('1990-01-01 H:i:00', strtotime($holidayHours->getEndHour())));
            $readyTime = strtotime(date('1990-01-01 H:i:s', $local));
            if (!$holidayHours->getIsClosed() && ($startTime <= $readyTime && $endTime >= $readyTime)) {
                return [
                    'open' => true,
                    'dayNumber' => $dayNumber,
                ];
            } else {
                return [
                    'open' => false,
                    'error' => 'We are closed at the selected time. '.$holidayHours->getMessage(),
                    'dayNumber' => $dayNumber,
                ];
            }
        }
        $closedHours = ClosedHours::getByDateAndRestaurantAndType($local, $this->getId(), $type);
        if (is_array($closedHours) && count($closedHours) > 0) {
            foreach ($closedHours as $h) {
                $startTime = strtotime(date('1990-01-01 H:i:00', strtotime($h->getStartTime())));
                $endTime = strtotime(date('1990-01-01 H:i:00', strtotime($h->getEndTime())));
                $readyTime = strtotime(date('1990-01-01 H:i:s', $local));
                if ($startTime <= $readyTime && $endTime >= $readyTime) {
                    if ($h->getOrderingDisabled()) {
                        return [
                            'open' => false,
                            'error' => 'We are closed at the selected time. '.$h->getMessage(),
                            'closedHours' => $h,
                            'dayNumber' => $dayNumber,
                        ];
                    } else {
                        return [
                            'open' => false,
                            'error' => 'We are closed at the selected time. '.$h->getMessage(),
                            'dayNumber' => $dayNumber,
                        ];
                    }

            }
        }
        return $additionalTime * 60; // converted from minutes to seconds
    }
 
    /**
     * Determines if the given restaurant location is closed at the given time
     * @param Restaurant $restaurant
     * @param string $selectedReadyTime The timestamp to check
     * @param null $menu
     * @param bool $returnClosedHours
     * @return bool|ClosedHours
     */
    public function getIsClosedAtTime($restaurant, $selectedReadyTime, $menu = null, $returnClosedHours = false, $ignoreMenuTime = false) {
        $menus = [null];
        if (!$ignoreMenuTime) {
            $menus = $menu ? [$menu] : ($this->getMenus() ?: [null]);
        }
        foreach ($menus as $menu) {
            $openInfo = $restaurant->isOpenAtForType($selectedReadyTime, $this->getBaseOrderType(), $menu);
            if ($returnClosedHours && isset($openInfo['closedHours']) && is_object($openInfo['closedHours'])) {
                return $openInfo['closedHours'];
            } elseif (!$openInfo['open']) {
                return true;
            }
        }
        return false;
    }
 
    public function getIsTypeClosed($restaurant) {
        return $this->getIsClosedAtTime($restaurant, $restaurant->getLocalTime());
    }
 
    /**
     * Finds what day an order is actually for (when placed after midnight especially)
     * @param Restaurant $restaurant
     * @param string     $selectedReadyTime The timestamp to check
     * @return int|null
     */
    public function getDayOrderIsFor($restaurant, $selectedReadyTime) {

     * @return false|float|int
     */
    public function getNextOpenTime($restaurant, $selectedTime, $ignoreMenuTime = false, $noLimit = false) {
        if (!$ignoreMenuTime && isset($_SESSION['menu_id'])) {
            $menu = new Menu($_SESSION['menu_id']);
        } else {
            $menu = null;
        }
 
        $selectedTime = floor($selectedTime / 60) * 60;
        //if we're open at the selected time, just return that
        if (!$this->getIsClosedAtTime($restaurant, $selectedTime, $menu, false, $ignoreMenuTime)) {
            return $selectedTime;
        }
 
        $limit = $noLimit ? 8736 : 336; //336 = 14 * 24 = 2 weeks  / 8736 = 1 year
 
        $findOpenTime = function ($selectedTime, $timeAdjust, $limit) use ($restaurant, $menu, $ignoreMenuTime) {
            $counter = 0;
            while ($this->getIsClosedAtTime($restaurant, $selectedTime, $menu, false, $ignoreMenuTime)) {
                $selectedTime = strtotime($timeAdjust, $selectedTime);
                if ($counter >= $limit) {
                    break;
                }
                $counter++;
            }
            return $selectedTime;
        };
 
        //going forward by each hour, check for an open time
        $selectedTime = $findOpenTime($selectedTime, '+60 Minute', $limit);
 
        //opened sometime in last hour. If open 30 minutes ago, check the 30 before that, otherwise check last 30 minutes
        $thrityAgo = strtotime('-30 Minute', $selectedTime);
        if (!$this->getIsClosedAtTime($restaurant, $thrityAgo, $menu, false, $ignoreMenuTime)) {
            $thrityAgo = strtotime('-60 Minute', $selectedTime);
        }
        return $findOpenTime($thrityAgo, '+1 Minute', 30);
    }
 

        if (!$this->getIsClosedAtTime($restaurant, $selectedTime, $menu, false, $ignoreMenuTime)) {
            return $selectedTime;
        }
 
        $limit = $noLimit ? 8736 : 336; //336 = 14 * 24 = 2 weeks  / 8736 = 1 year
 
        $findOpenTime = function ($selectedTime, $timeAdjust, $limit) use ($restaurant, $menu, $ignoreMenuTime) {
            $counter = 0;
            while ($this->getIsClosedAtTime($restaurant, $selectedTime, $menu, false, $ignoreMenuTime)) {
                $selectedTime = strtotime($timeAdjust, $selectedTime);
                if ($counter >= $limit) {
                    break;
                }
                $counter++;
            }
            return $selectedTime;
        };
 
        //going forward by each hour, check for an open time
        $selectedTime = $findOpenTime($selectedTime, '+60 Minute', $limit);
 
        //opened sometime in last hour. If open 30 minutes ago, check the 30 before that, otherwise check last 30 minutes
        $thrityAgo = strtotime('-30 Minute', $selectedTime);
        if (!$this->getIsClosedAtTime($restaurant, $thrityAgo, $menu, false, $ignoreMenuTime)) {
            $thrityAgo = strtotime('-60 Minute', $selectedTime);
        }
        return $findOpenTime($thrityAgo, '+1 Minute', 30);
    }
 
    public function getNextOpenTimeForAnyType($restaurant, $time = false) {
        $tmpOt = $this->getBaseOrderType();
        $nextOpenTime = null;
        foreach (CustomerOrder::TYPES_CAMEL as $type => $typeCamel) {
            if ($restaurant->{'getHas' . $typeCamel . 'Base'}()) {
                $this->setBaseOrderType($type);
                $newNextOpenTime = $this->getNextOpenTime($restaurant, $time ?: $restaurant->getLocalTime(), true, true);
                $nextOpenTime = !$nextOpenTime || $newNextOpenTime < $nextOpenTime ? $newNextOpenTime : $nextOpenTime;
            }
        }
        $this->setBaseOrderType($tmpOt);

                    $openTimeWithPrep = $opensAtTime + ($restaurant->getRequirePrepTimeOpening() ? $prepTime : 0);
                    $eot = max($openTimeWithPrep, $eot);
                }
            }
            $eot = $this->addThrottleTime($restaurant, $eot);
 
            //if allow delivery orders right up till closing time despite prep time, check if closed before prep time
            if ($restaurant->getDeliveryAllowedTillClosing()) {
                $eotCheckTime = strtotime('-'.$prepTime.' Seconds', $eot);
            } else {
                $eotCheckTime = $eot;
            }
 
            if ($calculateNextOpenTime) {
                $this->setClosedAtEot(false);
                $this->setOrderPushedToNextDay(false);
                $this->setCalculatedNextOpenTime(0);
                if ($this->getIsClosedAtTime($restaurant, $eotCheckTime, null, false, $ignoreMenuTimes)) {
                    $this->setClosedAtEot(true);
                    $eot = $this->getNextOpenTime($restaurant, $eot, $ignoreMenuTimes, true);
                    $this->setCalculatedNextOpenTime($eot);
                    if (date('Y-m-d', $localTime) != date('Y-m-d', $eot)) {
                        if ($restaurant->getRequirePrepTimeOpening()) {
                            $eot = strtotime('+'.$prepTime.' Seconds', $eot);
                        }
                    }
                    $eot = $this->addThrottleTime($restaurant, $eot);
                } else {
                    $openTime = $this->getNextOpenTime($restaurant, $eot, $ignoreMenuTimes);
                    $this->setCalculatedNextOpenTime($openTime);
                }
 
                //If order is pushed to next day - save that info to show warnings to customer
                if ($this->getIsOrderForAnotherDay($restaurant, $eot)) {
                    $this->setOrderPushedToNextDay(true);
                }
            } elseif ($this->getCalculatedNextOpenTime() && $this->getIsClosedAtTime($restaurant, $eotCheckTime, null, false, $ignoreMenuTimes)) {
                if ($this->getCalculatedNextOpenTime() < $eot) {
                    $eot = $this->getNextOpenTime($restaurant, $eot, $ignoreMenuTimes, true);
                } else {

    $timeRangesArray = [];
    if ($timeRange->getEnd() < $timeRange->getStart()) {
        $timeRangesArray[] = [$timeRange->getStart() => '23:59'];
    } else {
        $timeRangesArray = [[$timeRange->getStart() => $timeRange->getEnd()]];
    }
    return getTimes($timeRangesArray);
}
 
function checkTimeWarning(Cart $cart, Restaurant $restaurant) {
    $originalOrderType = $cart->base_order_type;
    $localTime = $restaurant->local_time;
    $holidayDate = date('Y-m-d 00:00:00', $localTime);
 
    $closedTypePickup = false;
    if ($restaurant->getHasPickupBase()) {
        $cart->setBaseOrderType('PICKUP');
        $cart->updateToSession();
        $closedTypePickup = $cart->getIsClosedAtTime($restaurant, $localTime);
        $eot['PICKUP'] = $restaurant->hasAvailableDays($localTime, 'PICKUP') ? $cart->getEarliestOrderTime($restaurant, null, true) : null;
    }
 
    $closedTypeDinein = false;
    if ($restaurant->getHasDineInBase()) {
        $cart->setBaseOrderType('DINEIN');
        $cart->updateToSession();
        $closedTypeDinein = $cart->getIsClosedAtTime($restaurant, $localTime);
        $eot['DINEIN'] = $restaurant->hasAvailableDays($localTime, 'DINEIN') ? $cart->getEarliestOrderTime($restaurant, null, true) : null;
    }
 
    if ($restaurant->getHasDineInBase() || $restaurant->getHasPickupBase()) {
        $holidayHours = HolidayHours::getByDateAndRestaurantAndType($holidayDate, $restaurant->id, $cart->base_order_type);
        if ($holidayHours) {
            $startTime = strtotime(date('1990-01-01 H:i:00', strtotime($holidayHours->start_hour)));
            $endTime = strtotime(date('1990-01-01 H:i:00', strtotime($holidayHours->end_hour)));
            $readyTime = strtotime(date('1990-01-01 H:i:s', $localTime));
            if ($holidayHours->is_closed || ($startTime > $readyTime || $endTime < $readyTime)) {
                $eot['DINEIN_HOLIDAY'] = $holidayHours->message;
            }
        }

        }
 
        if (ClosedHours::isCategoryHidden($restaurant, $category) || HolidayHours::isCategoryHidden($restaurant, $category)) {
            redirectToOrderingWithError('Sorry, this category is currently unavailable.', [$restaurant, $menu, -1]);
        }
        $page_fragment = $account->getCategoryPageFragment($menu, $category->getId(), $restaurant->getHideAllPrices(), $restaurant, true);
 
        if (isset($_REQUEST['sort'])) {
            if ($_REQUEST['sort'] == "name") {
                usort($items, array("MenuItem", "nameAlphaSort"));
            } elseif ($_REQUEST['sort'] == "price") {
                usort($items, array("MenuItem", "priceSort"));
            }
        }
        break;
    case 4: //Item
    case 5: //Price
        //check if we're closed right now. If so, display warning
        if (!isset($_SESSION['time_ok']) && is_object($restaurant)) {
            $eot = checkTimeWarning($cart, $restaurant);
        }
        break;
}
 
if ($_REQUEST['ordering_level'] < 3 && is_object($menu)) {
    if ($account->getDefaultOrderingPage() == 1) {
        if ($_GET['embed']) {
            $qs = '?embed='.$_GET['embed'];
        } else {
            $qs = '';
        }
        redirectToOrdering([$restaurant, $menu, -1], $qs);
    } elseif ($account->getDefaultOrderingPage() == 2) {
        if ($_GET['embed']) {
            $qs = '?sort=alpha&embed='.$_GET['embed'];
        } else {
            $qs = '?sort=alpha';
        }
        redirectToOrdering([$restaurant, $menu, -1], $qs);
    }

 
        $cart->setDefaultOrderType($account, $restaurant);
 
        $cart->setDefaultFees($account, $restaurant);
    }
 
    $restaurantRequiredPages = [
        'login',
        'customerorders'
    ];
    if (is_null($restaurant) && in_array($_REQUEST['form'], $restaurantRequiredPages)) {
        redirectTo('home');
    }
 
    $modelPath = CORE_PATH . 'model4.0/customer/'.$_REQUEST['form'].'.php';
} else {
    $_REQUEST['mobiledetect'] = new Mobile_Detect;
}
if (is_readable($modelPath)) {
    include_once($modelPath);
}
App::debugbarTime("model '{$_REQUEST['form']}'");
 
$custom_nav = CustomNavigationTab::getAllForAccount($account->getId());
 
$view2HideRightColumns = ['checkout', 'dashboard', 'customerdetails', 'customerorders',
                                'mydeliveryaddresses', 'emailpreferences', 'mycoupons', 'mycreditcards', 'mypassword',
                                'customerorderdetails', 'editcustomer', 'adddeliveryaddress',
                                'editlocation', 'orderconfirmation','viewcart', 'map', 'validatecallback'];
if (in_array($_REQUEST['form'], $view2HideRightColumns)) {
    $hideRightColumn = true;
}
 
$myAccountPages = ['accountsettings', 'dashboard', 'customerdetails', 'customerorders', 'editaddress', 'editcustomer', 'mydeliveryaddresses', 'editlocation', 'emailpreferences', 'mycoupons', 'mycreditcards', 'mypassword', 'adddeliveryaddress', 'map', 'myloyalty'];
if (in_array($_REQUEST['form'], $myAccountPages)) {
    $isMyAccountPage = true;
}
 
if (!isset($cart) || !is_object($cart)) {
    $GLOBALS['cart'] = \Cart::getCurrent();

App::startTime();
 
ErrorHandlers::register();
 
// Global.php is the core setup file for the application
App::debugbarTime('Global.php');
require(dirname(__DIR__) . '/PHP/Global.php');
App::debugbarTime('Global.php');
/** @var string $controller The main controller - defined at /PHP/Global.php */
 
App::debugbarTime('Sentry - controller');
ErrorHandlers::sentryInit($controller); //doesn't always do much - not every controller has a Sentry project
App::debugbarTime('Sentry - controller');
 
App::debugbarTime("controller: $controller");
apache_note('AppController', $controller);
if (file_exists(CORE_PATH."lib/helpers/$controller.php")) {
    require CORE_PATH."lib/helpers/$controller.php";
}
require CORE_PATH."controllers/$controller.php";
App::debugbarTime("controller: $controller");