<?php

namespace App\Commands;

use App\Component\Models\Client;
use App\Component\Models\Dishes;
use App\Component\Models\Places;
use App\Component\Models\Reasons;
use App\Component\Models\Settings;
use App\Component\Models\ShiftOnlineActions;
use App\Component\Models\ShiftOnlineDeleted;
use App\Component\Models\ShiftOnlineItems;
use App\Component\Models\ShiftOnlineOrders;
use App\Component\Models\Shifts;
use App\Component\Models\Staff;
use App\Component\Models\Tables;
use App\Console\Commands\HRCCommand;
use App\Console\Commands\HRCCommandInterface;
use Carbon\Carbon;
use Illuminate\Support\Facades\Log;

class GETDashboard extends HRCCommand implements HRCCommandInterface
{
    protected $signature = 'getdashboard';

    public function command($input, $output = null)
    {
        if (isset($input['method'])) {
            if (isset($input['more'])) {
                $more = $input['more'];
            } else {
                $more = false;
            }
            if (isset($input['items'])) {
                if (isset($input['order_id'])) {
                    $order_id = $input['order_id'];
                } else {
                    return [
                        'status' => 'fail',
                        'message' => 'Проверьте введенные данные'
                    ];
                }
                $items = $input['items'];
            } else {
                $items = false;
            }
            if (isset($input['type'])) {
                $type = $input['type'];
            } else {
                $type = false;
            }
            $method = $input['method'];
        } else {
            return [
                'status' => 'fail',
                'message' => 'Проверьте введенные данные'
            ];
        }
        $setting = Settings::getValue(10);

        if ($method == "profit") {
            if ($setting > 0) {
                $orders = ShiftOnlineOrders::where('who_open', '>', 0)
                    ->where('full_sum', '>=', 0)
                    ->where('is_closed', 1)
                    ->where('is_deleted', 0)
                    ->where('who_close', '>', 0)
                    ->get();
            } else {
                $orders = ShiftOnlineOrders::where('who_open', '>', 0)
                    ->where('full_sum', '>=', 0)
                    ->where('is_closed', 1)
                    ->where('is_deleted', 0)
                    ->where('who_close', '>', 0)
                    ->where('place_name', '<>', 'ДОСТАВКА')
                    ->get();
            }
            $profit = $middle = 0;
            $guests = $amount = 0;
            foreach ($orders as $order) {
                $order_status = ShiftOnlineOrders::getOrderStatus($order['code']);
                if ($setting > 0) {
                    $order_info = ShiftOnlineOrders::getInfo($order['code']);
                    $order_items = $order_info['items'];
                    $guests += $order_info['client_count'];
                    $amount += $order_info['amount'] - $order_info['returned_sum'];
                } elseif ($setting < 1 && $order_status != "Оплачен (*)") {
                    $order_info = ShiftOnlineOrders::getInfo($order['code']);
                    $order_items = $order_info['items'];
                    $guests += $order_info['client_count'];
                    $amount += $order_info['amount'] - $order_info['returned_sum'];
                } else {
                    continue;
                }

                foreach ($order_items as $order_item) {
                    $profit += $order_item['profit'];
                }

            }
            if ($guests > 0) {
                $middle = round($amount / $guests, 2);
            } else {
                $middle = 0;
            }
            return [
                'status' => 'success',
                'profit' => round($profit, 2),
                'guests' => $guests,
                'amount' => $amount,
                'middle' => $middle
            ];
        }

        if ($method == "total") {
            $orders = ShiftOnlineOrders::where('who_open', '>', 0)
                ->where('full_sum', '>=', 0)
                ->get();
            $waited_count = $waited_sum = 0;
            $closed_count = $closed_sum = 0;
            $returned_count = $returned_sum = 0;
            $cancellations_count = $cancellations_sum = 0;
            $deleted_count = $deleted_sum = 0;
            foreach ($orders as $order) {
                $order_status = ShiftOnlineOrders::getOrderStatus($order['code']);
                $returned_order_sum = 0;
                if ($order['order_sum'] >= 0
                    && $order['is_deleted'] > 0
                    && $order['check_number'] > 0
                    && $order['who_open'] > 0) {
                    $cancellations_count += 1;
                    $cancellations_sum += $order['order_sum'];
                }
                if ($setting > 0) {
                    if ($order['order_sum'] >= 0
                        && $order['who_open'] > 0
                        && $order['who_close'] == 0) {
                        $waited_count++;
                        $waited_sum += $order['order_sum'];
                    }
                } else {
                    if ($order['order_sum'] >= 0
                        && $order['who_open'] > 0
                        && $order['who_close'] == 0
                        && $order['place_name'] != 'ДОСТАВКА') {
                        $waited_count++;
                        $waited_sum += $order['order_sum'];
                    }
                }

                if ($setting > 0) {
                    if ($order['order_sum'] >= 0
                        && $order['who_open'] > 0
                        && $order['who_close'] > 0
                        && $order['is_closed'] == 1
                        && $order['is_deleted'] == 0
                        && $order['is_returned'] == 0
                        && $order['place_name'] != 'ДОСТАВКА') {
                        $closed_count++;
                        $closed_sum += $order['order_sum'];
                    }
                } else {
                    if ($order['order_sum'] >= 0
                        && $order['who_open'] > 0
                        && $order['who_close'] > 0
                        && $order['is_closed'] == 1
                        && $order['is_deleted'] == 0
                        && $order['is_returned'] == 0
                        && $order['place_name'] != 'ДОСТАВКА'
                        && $order_status != "Оплачен(*)") {
                        $closed_count++;
                        $closed_sum += $order['order_sum'];
                    }
                }
                if ($setting > 0) {
                    if ($order['order_sum'] >= 0
                        && $order['who_open'] > 0
                        && $order['who_close'] > 0
                        && $order['is_closed'] == 1
                        && $order['is_deleted'] == 0
                        && $order['is_returned'] == 1
                        && $order['place_name'] != 'ДОСТАВКА') {
                        $returned_items = ShiftOnlineOrders::getReturnedItems($order['code']);
                        foreach ($returned_items as $returned_item) {
                            $returned_sum += round(abs($returned_item['sale_price']) * $returned_item['count'], 2);
                            $returned_order_sum += round(abs($returned_item['sale_price']) * $returned_item['count'], 2);
                            $returned_count += $returned_item['count'];
                        }
                        $closed_count += 1;
                        $closed_sum += round($order['order_sum'], 2) - $returned_order_sum;
                    }
                } else {
                    if ($order['order_sum'] >= 0
                        && $order['who_open'] > 0
                        && $order['who_close'] > 0
                        && $order['is_closed'] == 1
                        && $order['is_deleted'] == 0
                        && $order['is_returned'] == 1) {
                        $returned_items = ShiftOnlineOrders::getReturnedItems($order['code']);
                        foreach ($returned_items as $returned_item) {
                            $returned_sum += round(abs($returned_item['sale_price']) * $returned_item['count'], 2);
                            $returned_order_sum += round(abs($returned_item['sale_price']) * $returned_item['count'], 2);
                            $returned_count += $returned_item['count'];
                        }
                        $closed_count += 1;
                        $closed_sum += round($order['order_sum'], 2) - $returned_order_sum;
                    }
                }
                if ($setting > 0) {
                    $deleted_items_count = ShiftOnlineDeleted::where('order_code', $order['code'])->sum('count');
                    $deleted_items_sum = ShiftOnlineDeleted::selectRaw('sum(sale_price * count) as deleted_sum')
                        ->where('order_code', $order['code'])
                        ->first();
                    $deleted_items_sum = $deleted_items_sum['deleted_sum'];
                    $deleted_count += $deleted_items_count;
                    $deleted_sum += $deleted_items_sum;
                } else {
                    if ($order['place_name'] != 'ДОСТАВКА') {
                        $deleted_items_count = ShiftOnlineDeleted::where('order_code', $order['code'])->sum('count');
                        $deleted_items_sum = ShiftOnlineDeleted::selectRaw('sum(sale_price * count) as deleted_sum')
                            ->where('order_code', $order['code'])
                            ->first();
                        $deleted_items_sum = $deleted_items_sum['deleted_sum'];
                        $deleted_count += $deleted_items_count;
                        $deleted_sum += $deleted_items_sum;
                    }
                }
            }

            return [
                'status' => 'success',
                'total' => round($closed_sum + $waited_sum, 2),
                'closed_sum' => round($closed_sum, 2),
                'closed_count' => $closed_count,
                'waited_sum' => round($waited_sum, 2),
                'waited_count' => $waited_count,
                'cancellations_sum' => round($cancellations_sum, 2),
                'cancellations_count' => $cancellations_count,
                'returned_sum' => round($returned_sum, 2),
                'returned_count' => $returned_count,
                'deleted_sum' => round($deleted_sum, 2),
                'deleted_count' => $deleted_count,
            ];
        }

        if ($method == "deleted") {
            $deleted_count = $deleted_sum = 0;
            $orders = ShiftOnlineOrders::where('who_open', '>', 0)
                ->where('full_sum', '>=', 0)
                ->get();
            foreach ($orders as $order) {
                if ($setting > 0) {
                    $deleted_items_count = ShiftOnlineDeleted::where('order_code', $order['code'])->sum('count');
                    $deleted_items_sum = ShiftOnlineDeleted::selectRaw('sum(sale_price * count) as deleted_sum')
                        ->where('order_code', $order['code'])
                        ->first();
                    $deleted_items_sum = $deleted_items_sum['deleted_sum'];
                    $deleted_count += $deleted_items_count;
                    $deleted_sum += $deleted_items_sum;
                } else {
                    if ($order['place_name'] != 'ДОСТАВКА') {
                        $deleted_items_count = ShiftOnlineDeleted::where('order_code', $order['code'])->sum('count');
                        $deleted_items_sum = ShiftOnlineDeleted::selectRaw('sum(sale_price * count) as deleted_sum')
                            ->where('order_code', $order['code'])
                            ->first();
                        $deleted_items_sum = $deleted_items_sum['deleted_sum'];
                        $deleted_count += $deleted_items_count;
                        $deleted_sum += $deleted_items_sum;
                    }
                }
            }

            if ($more) {
                $deleted_items = ShiftOnlineDeleted::select('order_code')
                    ->selectRaw('SUM(count * sale_price) as sum')
                    ->groupBy('order_code')
                    ->get();
                $orders = [];
                if ($deleted_count > 0) {
                    foreach ($deleted_items as $deleted_item) {
                        $order = ShiftOnlineOrders::select('opened', 'closed')
                            ->where('code', $deleted_item['order_code'])
                            ->first();
                        $closed = $order['closed'];
                        if ($closed == '0000-00-00 00:00:00') {
                            $closed = '30.12.1899';
                        }
                        $orders[] = array(
                            'number' => $deleted_item['order_code'],
                            'opened' => $order['opened'],
                            'closed' => $closed,
                            'deleted_sum' => round($deleted_item['sum'], 2)
                        );
                    }
                }
                return [
                    'status' => 'success',
                    'title' => 'Подробнее об удаленных',
                    'total_sum' => round($deleted_sum, 2),
                    'total_count' => $deleted_count,
                    'deleted_orders' => $orders
                ];
            }
            if ($items) {
                $all_sum = $all_count = 0;
                $deleted_items = ShiftOnlineDeleted::where('order_code', $order_id)
                    ->get();
                if ($deleted_count > 0) {
                    foreach ($deleted_items as $deleted_item) {
                        $order = ShiftOnlineActions::where('order_code', $deleted_item['order_code'])
                            ->where('type_action', 5)
                            ->first();
                        $out_items[] = array(
                            'dish' => Dishes::getName($deleted_item['menu_code']),
                            'time' => $order['time'],
                            'reason' => Reasons::getName($order['reason']),
                            'count' => $deleted_item['count'],
                            'sale_price' => $deleted_item['count'] * $deleted_item['sale_price'],
                            'who_deleted' => Staff::getName($order['who'])
                        );
                        $all_sum += $deleted_item['count'] * $deleted_item['sale_price'];
                        $all_count += $deleted_item['count'];
                    }
                } else {
                    $out_items = [];
                }
                return [
                    'status' => 'success',
                    'code' => $order_id,
                    'all_sum' => round($all_sum, 2),
                    'all_count' => round($all_count, 3),
                    'items' => $out_items
                ];
            }
            return [
                'status' => 'success',
                'sum' => round($deleted_sum, 2),
                'count' => $deleted_count
            ];
        }

        if ($method == 'guests') {
            if ($type == 'median') {
                $data = [];
                $orders = ShiftOnlineOrders::where('is_waited', 1)
                    ->where('is_deleted', 0)
                    ->get();
                if (isset($orders)) {
                    foreach ($orders as $order) {
                        $originalTime = $order['opened'];
                        $newTime = Carbon::createFromFormat('Y-m-d H:i:s', $originalTime)->format('d.m.Y H:i:s');
                        $data[] = array(
                            'time' => $newTime,
                            'count' => $order['client_count']
                        );
                    }
                }
                return [
                    'status' => 'success',
                    'data' => $data
                ];
            }
            if ($type == 'more') {
                $clientsIDS = ShiftOnlineOrders::select('client_code')
                    ->where('is_deleted', 0)
                    ->where('is_returned', 0)
                    ->where('who_open', '<>', 0)
                    ->where('client_code', '<>', '')
                    ->groupBy('client_code')
                    ->get();
                $clientsOrdersCount = ShiftOnlineOrders::select('client_code')
                    ->where('is_deleted', 0)
                    ->where('is_returned', 0)
                    ->where('who_open', '<>', 0)
                    ->where('client_code', '<>', '')
                    ->groupBy('client_code')
                    ->count();
                if ($clientsOrdersCount > 0) {
                    foreach ($clientsIDS as $clientsID) {
                        $orders_info = ShiftOnlineOrders::where('client_code', $clientsID['client_code'])
                            ->where('is_deleted', 0)
                            ->where('is_returned', 0)
                            ->where('who_open', '<>', 0)
                            ->get();
                        $clientName = Client::getName($clientsID['client_code']);
                        $clientOrders[$clientName] = [];
                        foreach ($orders_info as $order_info) {
                            if ($order_info['closed'] == '0000-00-00 00:00:00') {
                                $closed = false;
                            } else {
                                $closed = $order_info['closed'];
                            }
                            $order = array(
                                'number' => $order_info['code'],
                                'opened' => $order_info['opened'],
                                'closed' => $closed,
                                'sum' => $order_info['order_sum']
                            );
                            array_push($clientOrders[$clientName], $order);
                        }
                    }
                    foreach ($clientOrders as $key => $ordersInfo) {
                        if ($setting > 0) {
                            $out[] = array(
                                'name' => $key,
                                'orders' => $ordersInfo
                            );
                        } else {
                            $filtered_orders = [];
                            foreach ($ordersInfo as $orderInfo) {
                                $order_status = ShiftOnlineOrders::getOrderStatus($orderInfo['number']);
                                if ($order_status != 'Доставка' && $order_status != 'Оплачен(*)') {
                                    $filtered_orders[] = array(
                                        'number' => $orderInfo['number'],
                                        'opened' => $orderInfo['opened'],
                                        'closed' => $orderInfo['closed'],
                                        'sum' => $orderInfo['sum']
                                    );
                                }
                            }
                            $out[] = array(
                                'name' => $key,
                                'orders' => $filtered_orders
                            );
                        }
                    }
                    $clients_info = [];
                    foreach ($out as $out_item) {
                        if (count($out_item['orders']) > 0) {
                            array_push($clients_info, $out_item);
                        }
                    }
                    return [
                        'status' => 'success',
                        'title' => 'Подробнее о заказах гостей',
                        'clients' => $clients_info
                    ];
                } else {
                    return [
                        'status' => 'success',
                        'title' => 'Подробнее о заказах гостей',
                        'clients' => []
                    ];
                }

            }
            $guests = $namedGuests = $totalSum = 0;
            $orders = ShiftOnlineOrders::where('is_waited', 1)
                ->where('is_deleted', 0)
                ->get();
            if (isset($orders)) {
                foreach ($orders as $order) {
                    $returned_order_sum = 0;
                    $order_status = ShiftOnlineOrders::getOrderStatus($order['code']);
                    if ($setting > 0) {
                        $guests += $order['client_count'];
                        if ($order['client_code'] != '') {
                            if ($order_status == "Возвращен" || $order_status == "Возвращен частично") {
                                $returned_order_id = ShiftOnlineOrders::getReturnedOrderId($order['code']);
                                $returned_order_sum = ShiftOnlineOrders::where('code', $returned_order_id)->first();
                                $returned_order_sum = $returned_order_sum['order_sum'];
                            }
                            $namedGuests += 1;
                            $totalSum += $order['order_sum'] - abs($returned_order_sum);
                        }
                    } else {
                        if ($order_status != 'Доставка' && $order_status != 'Оплачен(*)') {
                            $guests += $order['client_count'];
                            if ($order['client_code'] != '') {
                                if ($order_status == "Возвращен" || $order_status == "Возвращен частично") {
                                    $returned_order_id = ShiftOnlineOrders::getReturnedOrderId($order['code']);
                                    $returned_order_sum = ShiftOnlineOrders::where('code', $returned_order_id)->first();
                                    $returned_order_sum = $returned_order_sum['order_sum'];
                                }
                                $namedGuests += 1;
                                $totalSum += $order['order_sum'] - abs($returned_order_sum);
                            }
                        }
                    }
                }
            }
            return [
                'status' => 'success',
                'namedGuests' => $namedGuests,
                'guestsCount' => $guests,
                'totalSum' => round($totalSum, 2)
            ];
        }

        if ($method == 'info') {
            $response['status'] = 'success';
            $response['exists'] = 'false';
            $shifts = Shifts::first();
            if (isset($shifts)) {
                $response['exists'] = true;
                $response['opened'] = $shifts['opened'];
                $response['open'] = Staff::getName($shifts['who_open']);
                $response['z_number'] = $shifts['z_number'];
                if ($shifts['who_close'] > 0) {
                    $response['closed'] = $shifts['closed'];
                    $response['close'] = Staff::getName($shifts['who_close']);
                }
            }
            return $response;
        }

        if ($method == 'online') {
            if ($type == 'items') {
                $response['status'] = 'success';
                $shifts = Shifts::first();
                if (isset($shifts)) {
                    $response['shift_time'] = $shifts['opened'];
                    $items = ShiftOnlineItems::select('menu_code')
                        ->selectRaw('SUM(count - IFNULL(`count_return`, 0)) as count')
                        ->where('menu_code', '>', 0)
                        ->where('dish_code', '>', 0)
                        ->where('real_price', '>=', 0)
                        ->where('sale_price', '>=', 0)
                        ->groupBy('menu_code')
                        ->get();
                    foreach ($items as $item) {
                        if ($item['count'] > 0) {
                            $output_items[] = array(
                                'code' => $item['menu_code'],
                                'name' => Dishes::getName($item['menu_code']),
                                'count' => round($item['count'], 2)
                            );
                        }
                    }
                    $response['items'] = $output_items;
                }
                return $response;
            } else {
                return [
                    'status' => 'fail',
                    'message' => 'Проверьте введенные данные'
                ];
            }
        }

        if ($method == 'staff') {
            if ($type == 'online') {
                $orders = ShiftOnlineOrders::where('who_open', '>', 0)
                    ->where('full_sum', '>=', 0)
                    ->get();
                $orders_count = ShiftOnlineOrders::where('who_open', '>', 0)
                    ->where('full_sum', '>=', 0)
                    ->count();
                $staff_data = [];
                $sum = 0;
                if ($orders_count > 0) {
                    $staff = Staff::where('is_history', 0)->get();
                    $staff_data[] = array(
                        'code' => 0,
                        'name' => 'Персонал не найден',
                        'orders_count' => 0,
                        'orders_sum' => 0
                    );
                    foreach ($staff as $staff_item) {
                        $staff_data[] = array(
                            'code' => $staff_item['code'],
                            'name' => Staff::getName($staff_item['code']),
                            'orders_count' => 0,
                            'orders_sum' => 0
                        );
                    }
                    foreach ($orders as $order) {
                        $order_status = ShiftOnlineOrders::getOrderStatus($order['code']);
                        $returned_order_sum = 0;
                        if ($setting > 0) {
                            if ($order_status == 'Возвращен' && $order_status != 'Возвращен частично') {
                                $returned_order_id = ShiftOnlineOrders::getReturnedOrderId($order['code']);
                                $returned_order = ShiftOnlineOrders::where('code', $returned_order_id)->first();
                                $returned_order_sum = abs($returned_order['full_sum']);
                            }
                            $staff_name = Staff::getName($order['who_open']);
                            $sum = $order['full_sum'] - $returned_order_sum;
                            $res = array_filter($staff_data,
                                function ($x) use ($staff_name) {
                                    return $x['name'] == $staff_name;
                                });
                            $key = key($res);
                            $staff_data[$key]['orders_sum'] += $sum;
                            $staff_data[$key]['orders_count']++;

                        } else {
                            if ($order_status != 'Доставка' && $order_status != 'Оплачен(*)') {
                                if ($order_status == 'Возвращен' && $order_status != 'Возвращен частично') {
                                    $returned_order_id = ShiftOnlineOrders::getReturnedOrderId($order['code']);
                                    $returned_order = ShiftOnlineOrders::where('code', $returned_order_id)->first();
                                    $returned_order_sum = abs($returned_order['full_sum']);
                                }
                                $staff_name = Staff::getName($order['who_open']);
                                $sum = $order['full_sum'] - $returned_order_sum;
                                $res = array_filter($staff_data,
                                    function ($x) use ($staff_name) {
                                        return $x['name'] == $staff_name;
                                    });
                                $key = key($res);
                                $staff_data[$key]['orders_sum'] += $sum;
                                $staff_data[$key]['orders_count']++;
                            }
                        }
                    }
                    return [
                        'status' => 'success',
                        'staff' => $staff_data,
                    ];
                } else {
                    return [
                        'status' => 'success',
                        'staff' => $staff_data,
                    ];
                }
            }
        }

        if ($method == 'tables') {
            if ($type == 'online') {
                if ($setting > 0) {
                    $orders = ShiftOnlineOrders::selectRaw("COUNT(`id`) AS `orders_count`, SUM(`full_sum`) AS `orders_sum`, CONCAT(place_name, '_', `table_name`) AS `tables`")
                        ->where('who_open', '>', 0)
                        ->where('full_sum', '>=', 0)
                        ->where('is_deleted', 0)
                        ->where('is_closed', 0)
                        ->where('is_waited', 1)
                        ->groupBy('tables')
                        ->get();
                    $orders_count = ShiftOnlineOrders::where('who_open', '>', 0)
                        ->where('full_sum', '>=', 0)
                        ->where('is_deleted', 0)
                        ->where('is_closed', 0)
                        ->where('is_waited', 1)
                        ->count();
                } else {
                    $orders = ShiftOnlineOrders::selectRaw("COUNT(`id`) AS `orders_count`, SUM(`full_sum`) AS `orders_sum`, CONCAT(place_name, '_', `table_name`) AS `tables`")
                        ->where('who_open', '>', 0)
                        ->where('full_sum', '>=', 0)
                        ->where('is_deleted', 0)
                        ->where('is_closed', 0)
                        ->where('is_waited', 1)
                        ->where('place_name', '<>', 'ДОСТАВКА')
                        ->groupBy('tables')
                        ->get();
                    $orders_count = ShiftOnlineOrders::where('who_open', '>', 0)
                        ->where('full_sum', '>=', 0)
                        ->where('is_deleted', 0)
                        ->where('is_closed', 0)
                        ->where('is_waited', 1)
                        ->where('place_name', '<>', 'ДОСТАВКА')
                        ->count();
                }
                $tables_data = [];
                if ($orders_count > 0) {
                    foreach ($orders as $order) {
                        $table_info = explode("_", $order['tables']);
                        $tables_data[] = array(
                            'place_name' => $table_info[0],
                            'table_name' => $table_info[1],
                            'orders_count' => $order['orders_count'],
                            'orders_sum' => $order['orders_sum']
                        );
                    }
                }
                return [
                    'status' => 'success',
                    'tables' => $tables_data,
                ];
            }
        }

        if ($method == 'discounts') {
            if ($type == 'online') {
                $count = $discountSum = $totalSum = 0;
                $orders = ShiftOnlineOrders::where('sale_sum', '>', 0)
                    ->where('full_sum', '>=', 0)
                    ->get();
                foreach ($orders as $order) {
                    if ($setting > 0) {
                        $count++;
                    } else {
                        $order_status = ShiftOnlineOrders::getOrderStatus($order['code']);
                        if ($order_status != 'Оплачен(*)' && $order_status != 'ДОСТАВКА') {
                            $count++;
                        }
                    }
                }
                if ($count > 0) {
                    foreach ($orders as $key => $order) {
                        if ($setting > 0) {
                            $totalSum += $order['order_sum'];
                            $items = ShiftOnlineItems::where('order_code', $order['code'])->get();
                            foreach ($items as $key => $item) {
                                $realPrice = $item['real_price'] * $item['count'] * $item['cof'];
                                $salePrice = $item['sale_price'] * $item['count'];
                                $discountSum = round(($discountSum + abs($salePrice - $realPrice)), 2);
                            }
                        } else {
                            $order_status = ShiftOnlineOrders::getOrderStatus($order['code']);
                            if ($order_status != 'Оплачен(*)' && $order_status != 'ДОСТАВКА') {
                                $totalSum += $order['order_sum'];
                                $items = ShiftOnlineItems::where('order_code', $order['code'])->get();
                                foreach ($items as $key => $item) {
                                    $realPrice = $item['real_price'] * $item['count'] * $item['cof'];
                                    $salePrice = $item['sale_price'] * $item['count'];
                                    $discountSum = round(($discountSum + abs($salePrice - $realPrice)), 2);
                                }
                            }
                        }
                    }
                }

                return [
                    'status' => 'success',
                    'count' => $count,
                    'sum' => $discountSum,
                    'total_sum' => $totalSum
                ];
            }
        }
    }
}