ldc-boutique-cnc/app/Http/Controllers/Fo/OrderController.php

<?php

namespace App\Http\Controllers\Fo;

use App\Enums\DeliveryMode\DeliveryModeEnum;
use App\Enums\GeneralConfigType;
use App\Enums\Order\DeliveryStatus;
use App\Enums\Order\OrderProcess;
use App\Enums\Order\PaymentStatus;
use App\Enums\Order\ValidationStatus;
use App\Http\Controllers\Controller;
use App\Http\Requests\Fo\Orders\CheckoutRequest;
use App\Http\Requests\Fo\Orders\SetOrderTimeSlotRequest;
use App\Http\Requests\Fo\Orders\ShippingFormRequest;
use App\Http\Requests\Fo\Orders\ShippingModeFormRequest;
use App\Http\Resources\ShopResource;
use App\Mail\NewOrderIncome;
use App\Models\Customer;
use App\Models\DeliveryMode;
use App\Models\GeneralConfig;
use App\Models\Order;
use App\Models\Shop;
use App\Models\Timeslot;
use App\Notifications\Order\OrderCreated;
use Carbon\Carbon;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Mail;
use Illuminate\Support\Facades\Session;
use Illuminate\Support\Facades\View;
use Illuminate\Support\Str;
use Illuminate\Validation\ValidationException;
use LDC\LDCCRM\Enums\Country;

class OrderController extends Controller
{
    // * --- TUNNEL DE COMMANDE ---
    /**
     * Récapitualtif du panier
     *
     * * ---  1  ---
     *
     * @return \Illuminate\Contracts\View\View
     */
    public function basketRecap()
    {
        $this->assertDoesNotHaveEmptyBasket();
        $this->assertBasketDidNotChange();
        // * On peut passer commande ?
        $this->authorize('orderThings', Order::class);
        $this->setOrderProcessStep(OrderProcess::reviewBasket());

        /** @var \Gloudemans\Shoppingcart\Cart */
        $basket   = app('basket');
        $messages = [];

        $basket = $this->filterBasketKeepOnlyOrderableItems($basket, $messages);

        if (!empty($messages)) {
            Session::flash('warning', \collect($messages)->implode(",\n"));
        }

        $basketItems = $this->basketToList($basket);

        return view('theme::pages.order-tunnel.basket-recap', compact(
            'basket',
            'basketItems'
        ));
    }

    /**
     * Select shipping Mode And create Session Order
     *
     * * ---  2  ---
     *
     * @return \Illuminate\Contracts\View\View
     */
    public function shippingMode()
    {
        $this->assertDoesNotHaveEmptyBasket();
        $this->assertBasketDidNotChange();
        $this->setOrderProcessStep(OrderProcess::shippingMethod(), OrderProcess::reviewBasket());

        // * CREATE ORDER

        /** @var \App\Models\Customer $customer */
        $customer = auth('frontend')->user();

        /** @var \Gloudemans\Shoppingcart\Cart */
        $basket = app('basket');

        /** @var \App\Models\Order|null $order */
        $order = Order::getCurrentOrder();

        // * If there was a previous order that was not ended use the ID.
        /** @var \App\Models\Order */
        $order                    = $order ?? new Order();
        $order->mail_sent         = false;
        $order->delivery_status   = DeliveryStatus::pending();
        $order->payment_status    = PaymentStatus::pending();
        $order->validation_status = ValidationStatus::pending();
        $order->assignBasket($basket);
        $order->customer()->associate($customer);

        // * Save Session Order
        Session::put('currentOrder', $order);

        /** @var \Illuminate\Database\Eloquent\Collection<\App\Models\DeliveryMode> */
        $deliveryModes = app('DeliveryModesGlobal');

        return view('theme::pages.order-tunnel.shipping-mode', \compact('deliveryModes'));
    }

    /**
     * Save shipping Mode
     *
     * * ---  2  ---
     *
     * @param \App\Http\Requests\Fo\Orders\ShippingModeFormRequest $request
     * @return \Illuminate\Contracts\View\View|\Illuminate\Contracts\View\Factory
     */
    public function shippingModeSubmit(ShippingModeFormRequest $request)
    {
        $this->assertDoesNotHaveEmptyBasket();
        $this->assertBasketDidNotChange();
        $this->assertDoesHaveCurrentOrder();
        $this->setOrderProcessStep(OrderProcess::shippingMethod(), OrderProcess::reviewBasket());

        /** @var \App\Models\DeliveryMode $mode */
        if (!($mode = DeliveryMode::availables()->whereId($request->mode)->first())) {
            $e = new \RuntimeException('Mode de livraison non disponible', 1);
            report($e);
            Session::flash('error', trans('Mode de livraison non disponible'));
            return \back()->withException($e);
        }

        $this->allowTimeSlotSelect();

        /** @var \App\Models\Order $order */
        $order = Order::getCurrentOrder();

        $order->deliveryMode()->associate($mode);

        Session::put('currentOrder', $order);

        return \response()->redirectToRoute('order-tunnel.shipping');
    }

    /**
     * Shipping informations
     *
     * * ---  3  ---
     *
     * ! Pour - Click and collect
     *
     * @return \Illuminate\Contracts\View\View|\Illuminate\Contracts\View\Factory
     * @throws \RuntimeException If delivery mode is unhandled.
     */
    public function shipping()
    {
        $this->assertDoesNotHaveEmptyBasket();
        $this->assertBasketDidNotChange();
        $this->assertDoesHaveCurrentOrder();
        $this->setOrderProcessStep(OrderProcess::shippment(), OrderProcess::shippingMethod());

        /** @var \App\Models\Order $order */
        $order = Order::getCurrentOrder();

        // * Switch Delivery modes
        // * Pour afficher formulaire qui devra retourner une adresse 'shipping'
        /**
         * * Switch Delivery modes
         * - Pour afficher formulaire qui devra retourner une adresse 'shipping'.
         * - Qui devra fournir un timeslot dans le cas de clickAndCollect.
         */
        /** @var \App\Enums\DeliveryMode\DeliveryModeEnum|null */
        $delivery_mode = \optional($order->deliveryMode)->mode;
        switch ($delivery_mode) {
            case DeliveryModeEnum::inShop():
                // * 1 Select timeslot if not already done.
                if (!$order->timeslot()->first() or !Session::get('deliveryModePickSlot')) {
                    $shops = Shop::all()->map(function (Shop $shop) {
                        return new ShopResource($shop);
                    });
                    $this->allowTimeSlotSelect(true);
                    View::share('mustSelectTimeSlot', true);
                    return \view('theme::pages.order-tunnel.pick-slot', \compact('order', 'shops'));
                }
                return \view('theme::pages.order-tunnel.shipping', \compact('order'));
            default:
                throw new \RuntimeException('Unhandled delivery mode ');
        }

        throw new \RuntimeException('This should never happen');
    }

    /**
     * Save and validate timeslot
     *
     * * ---  3  ---
     *
     * @param \App\Http\Requests\Fo\Orders\SetOrderTimeSlotRequest $request
     * @return \Illuminate\Http\RedirectResponse
     * @throws \Illuminate\Validation\ValidationException If Creneau is not available anomore.
     */
    public function validateSelectedTimeSlot(SetOrderTimeSlotRequest $request)
    {
        $this->assertDoesNotHaveEmptyBasket();
        $this->assertBasketDidNotChange();
        $this->assertDoesHaveCurrentOrder();
        $this->setOrderProcessStep(OrderProcess::shippment(), OrderProcess::shippingMethod());
        /** @var \App\Models\Shop */
        $shop    = Shop::query()->where('id', $request->shop_id)->firstOrFail();
        $creneau = Carbon::createFromFormat('d/m/Y H:i', "{$request->selected_day} {$request->selected_time}");
        if (!$shop->isCreneauAvailable($creneau)) {
            throw ValidationException::withMessages([
                'error' => 'Ce créneau n\'est plus disponible'
            ]);
        }

        DB::transaction(function () use ($shop, $creneau) {
            /** @var \App\Models\Order $order */
            $order = Order::getCurrentOrder();
            // * Assign order uuid we would use, if none already.
            if (!$order->uuid) {
                $order->uuid = Str::uuid();
            }
            Session::put('currentOrder', $order);

            /** @var \App\Models\Timeslot */
            $timeSlot = Timeslot::query()->where('order_uuid', $order->uuid)->firstOrNew();
            $timeSlot->order()->associate($order);
            $timeSlot->shop()->associate($shop);
            $timeSlot->slot = $creneau;
            $timeSlot->saveOrFail();
        });
        return response()->redirectToRoute('order-tunnel.shipping');
    }

    /**
     * SaveShippingAdress
     *
     * * ---  3  ---
     *
     * @param \App\Http\Requests\Fo\Orders\ShippingFormRequest $request
     * @return \Illuminate\Http\RedirectResponse
     * @throws \RuntimeException If somehow no email can be found.
     */
    public function shippingSubmit(ShippingFormRequest $request)
    {
        $this->assertDoesNotHaveEmptyBasket();
        $this->assertDoesHaveCurrentOrder();
        $this->assertBasketDidNotChange();
        $this->setOrderProcessStep(OrderProcess::shippment(), OrderProcess::shippingMethod());

        /** @var \App\Models\Order $order */
        $order = Order::getCurrentOrder();

        $order->fill($request->validated());

        /** @var object */
        $billing          = $order->billing;
        $billing->country = Country::france();
        $order->billing   = $billing;

        $this->allowTimeSlotSelect();

        // Fetch right email to send in.
        if ($order->billing->email) {
            $order->email = $order->billing->email;
        } elseif ($order->shipping->email) {
            $order->email = $order->shipping->email;
        } else {
            $order->email = $order->customer->api_data->email;
        }

        if (!$order->email) {
            throw new \RuntimeException('Somehow no email was provided');
        }

        $this->fillShippingFromShopInfo($order);

        // * Allow timeslot select
        Session::put('currentOrder', $order);

        return \response()->redirectToRoute('order-tunnel.review');
    }

    /**
     * Valider le panier avant achat.
     *
     * @return \Illuminate\Contracts\View\View|\Illuminate\Contracts\View\Factory
     */
    public function review()
    {
        $this->assertDoesNotHaveEmptyBasket();
        $this->assertBasketDidNotChange();
        $this->assertDoesHaveCurrentOrder();
        $this->setOrderProcessStep(OrderProcess::paymentReview(), OrderProcess::shippment());

        $this->allowTimeSlotSelect();

        /** @var \App\Models\Customer $customer */
        $customer = auth('frontend')->user();

        /** @var \App\Models\Order $order */
        $order = Order::getCurrentOrder();

        // * Order completed email already sent.
        if ($order->mail_sent) {
            self::detroyCurrentBasket();
            return \view('theme::pages.order-tunnel.done', \compact('order'));
        }

        /** @var \Gloudemans\Shoppingcart\Cart */
        $basket = app('basket');

        return view('theme::pages.order-tunnel.review', \compact('basket', 'order'));
    }

    /**
     * Setup Order for stripe submit
     *
     * @param \App\Http\Requests\Fo\Orders\CheckoutRequest $request
     * @return \Illuminate\Contracts\View\View|\Illuminate\Contracts\View\Factory
     * @throws \RuntimeException If payment method is unhandled somehow.
     */
    public function reviewSubmit(CheckoutRequest $request)
    {
        $this->assertDoesNotHaveEmptyBasket();
        $this->assertBasketDidNotChange();
        $this->assertDoesHaveCurrentOrder();
        $this->setOrderProcessStep(OrderProcess::paymentReview(), OrderProcess::shippment());

        /** @var \App\Models\Customer $customer */
        $customer = auth('frontend')->user();

        // * Force clone here to prevent session save model state (If something goes wrong).
        /** @var \App\Models\Order $order */
        $order = clone Order::getCurrentOrder();

        // * Order completed email already sent.
        if (!$order->exists and $order->mail_sent) {
            self::detroyCurrentBasket();
            return \view('theme::pages.order-tunnel.done', \compact('order'));
        }

        if ($request->method === 'cnc') {
            return $this->checkoutCnC($customer, $order);
        }

        throw new \RuntimeException('Unhandled method payment');
    }

    /**
     * Checkout click and collect
     *
     * @param \App\Models\Customer $customer
     * @param \App\Models\Order    $order
     * @return \Illuminate\Contracts\View\View|\Illuminate\Contracts\View\Factory
     * @throws \Illuminate\Validation\ValidationException If saving order fails.
     */
    private function checkoutCnC(Customer $customer, Order $order)
    {
        return DB::transaction(function () use ($customer, $order) {
            // * Notification has been sent
            $order->mail_sent = true;

            // * Enregistrement commande + envoi de mail.
            if (!$order->save()) {
                report(new \RuntimeException("Order saving error happened."));
                throw ValidationException::withMessages([
                    'error' => trans('Une erreur est survenue, veuillez réssayer')
                ]);
            }

            // * Notifiy customer
            $customer->notify(new OrderCreated($order));

            /** @var object|null */
            $notificationMail = \optional(\optional(GeneralConfig::query()->where('type', GeneralConfigType::global())
                ->first())->data)->confirmed_orders_destination_email;
            if (!\optional($notificationMail)->value) {
                throw new \RuntimeException('Could not get new order email notification setting');
            }
            Mail::to($notificationMail->value)->send(new NewOrderIncome($order));

            self::detroyCurrentBasket();

            return \view('theme::pages.order-tunnel.done', \compact('order'));
        });
    }


    // * --- FIN TUNNEL DE COMMANDE ---
    // * PRIVATE METHODS

    /**
     * Allow timeslot select in the tunnel even if already selected
     *
     * @param boolean $disallow To force disallow timeslot picker select.
     * @return void
     */
    private function allowTimeSlotSelect(bool $disallow = false)
    {
        // * Allow timeslot select
        Session::put('deliveryModePickSlot', $disallow);
    }

    /**
     * Assert user does not have an empty basket
     * or redirect with warning
     *
     * @return void
     */
    private function assertDoesHaveCurrentOrder()
    {
        $order = Order::getCurrentOrder();
        if (
            $order = Order::getCurrentOrder() and
            $order->payment_status and
            $order->payment_status->equals(PaymentStatus::payed())
        ) {
            self::detroyCurrentBasket();
            abort(\response()->view('theme::pages.order-tunnel.done', \compact('order')));
        }

        if (!$order) {
            \redirect()->route('order-tunnel.basket.recap')->throwResponse();
        }
    }

    /**
     * Delete order steps, removes basket, ends tunnel transaction.
     *
     * @return void
     */
    public static function detroyCurrentBasket()
    {
        /** @var \Gloudemans\Shoppingcart\Cart */
        $basket = app('basket');
        $basket->destroy();

        Session::remove('currentOrder');
        Session::remove('PreviousOrderStep');
        Session::remove('OrderStep');
        Session::remove('deliveryModePickSlot');
        Session::remove('basketFingerPrint');
    }

    /**
     * Assert user does not have an empty basket
     * or redirect with warning
     *
     * @return void
     */
    private function assertDoesNotHaveEmptyBasket(): void
    {
        /** @var \Gloudemans\Shoppingcart\Cart */
        $basket = app('basket');

        if (!$basket->count()) {
            \redirect()->route('home')
            ->with('warning', trans('Vous n\'avez aucun produit dans votre panier'))
            ->throwResponse();
        }
    }

    /**
     * Assert user does not have an empty basket
     * or redirect with warning
     *
     * @return void
     */
    private function assertBasketDidNotChange(): void
    {
        /** @var \Gloudemans\Shoppingcart\Cart */
        $basket               = app('basket');
        $actual_finger_print  = hash('sha256', \json_encode($basket->content()->jsonSerialize()));
        $session_finger_print = Session::get('basketFingerPrint');

        Session::put('basketFingerPrint', $actual_finger_print);

        if ($session_finger_print !== $actual_finger_print) {
            Session::remove('deliveryModePickSlot');
            \redirect()->route('order-tunnel.basket.recap')
            ->with('warning', trans('Votre panier à été modifié'))
            ->throwResponse();
        }
    }

    /**
     * Validate Process step
     *
     * @param \App\Enums\Order\OrderProcess      $step
     * @param \App\Enums\Order\OrderProcess|null $assertDid
     * @return void
     * @throws \Illuminate\Validation\ValidationException If previous was not done.
     */
    private function setOrderProcessStep(OrderProcess $step, OrderProcess $assertDid = null): void
    {
        if ($assertDid) {
            if (!Session::get('PreviousOrderStep')) {
                Session::put('PreviousOrderStep', collect());
            }
            /** @var \Illuminate\Support\Collection */
            $previousSteps = Session::get('PreviousOrderStep');
            if (Session::get('OrderStep') < $step) {
                /** @var \App\Enums\OrderProcess */
                $previousStep = Session::get('OrderStep');
                $previousSteps->put($previousStep->value, $previousStep);
                Session::put('PreviousOrderStep', $previousSteps);
            }
            if (!$previousSteps->count()) {
                \redirect()->route('home')
                ->with('warning', trans('Vous devez d\'abord valider votre panier'))
                ->throwResponse();
            }
            if (!$previousSteps->contains($assertDid)) {
                throw ValidationException::withMessages(['Étape précédente requise']);
            }
        } //end if

        Session::put('OrderStep', $step);
    }

    /**
     * Fill order shipping with in shop infos
     *
     * @param \App\Models\Order $order
     * @return void
     * @throws \Illuminate\Validation\ValidationException Si le créneau de reservation n'est plus trouvable.
     */
    private function fillShippingFromShopInfo(Order $order)
    {
        /** @var \App\Models\Customer */
        $user = auth('frontend')->user();
        if ($order->deliveryMode->mode->equals(DeliveryModeEnum::inShop())) {
            /** @var \App\Models\Timeslot|null */
            if (!($timeslot = $order->timeslot()->first())) {
                throw ValidationException::withMessages([
                    'error' => trans('Créneau de réservation introuvable')
                ]);
            }
            $order->shipping = [
                'firstname' => $timeslot->shop->name,
                'lastname' => '',
                'email' => null,
                'phone' => $timeslot->shop->phone,
                'line1' => $timeslot->shop->address,
                'postal_code' => $timeslot->shop->postal_code,
                'city' => $timeslot->shop->city,
                'country' => $timeslot->shop->country
            ];
        }
    }
}