<?php

namespace App\Http\Controllers;

use App\Helpers\CurrencyHelper;
use App\Helpers\UserHelper;
use App\Http\Requests\IdRequest;
use App\Http\Requests\ImportRequest;
use App\Http\Requests\Order\AddToCartFromSearchRequest;
use App\Http\Requests\Order\AddToCartRequest;
use App\Http\Requests\Order\CreateRequest;
use App\Http\Requests\Order\IndexRequest;
use App\Http\Requests\Order\UpdateRequest;
use App\Http\Requests\Order\UploadRequest;
use App\Models\Cart;
use App\Models\Order;
use App\Models\Permission;
use App\Repository\Address\AddressRepository;
use App\Repository\Part\PartRepository;
use App\Services\Branch\BranchService;
use App\Services\Order\OrderService;
use App\Services\Repair\RepairService;
use App\Services\Service\ServiceService;
use App\Services\Status\StatusService;
use FontLib\TrueType\Collection;
use Illuminate\Support\Facades\Auth;
use Illuminate\Support\Facades\Redirect;
use PhpOffice\PhpSpreadsheet\IOFactory;

class OrderController extends Controller
{

    protected string $permission = Permission::orders;

    protected string $protectedRedirect = 'orders.index';

    protected OrderService $service;

    public function __construct()
    {
        parent::__construct();

        $this->service = new OrderService();
    }

    public function index(IndexRequest $request)
    {
        $user = UserHelper::getUser();

        $data = $this->service->search($request);
        $columns = Order::columns();
        $canBranchesAll = can(Permission::branchesAll);

        $user = UserHelper::getUser();

        $branches = BranchService::getDisplayed();

        if ($user->isService()) {
            $services = [];
            if ($request->service_id) {
                $selectedService = ServiceService::getById($request->service_id);
                $services[$request->service_id] = $selectedService->name;
            }
        } else {
            $services = ServiceService::getAvailable()->get()->pluck('name', 'id')->toArray();
        }

        $statuses = StatusService::getOrderAll();

        $canActions = true;
        if ($user->isService()) {
            $canActions = canServiceActions($user->getCurrentServiceId());
        } elseif ($request->service_id) {
            $canActions = canServiceActions($request->service_id);
        }

        return view('orders.list', compact('user', 'canBranchesAll', 'data', 'columns', 'branches', 'services', 'statuses', 'canActions'))
            ->with(['sections' => ["service_id", 'branch_id', 'status']]);
    }

    public function edit($id)
    {
        $order = OrderService::getAvailableByStatus($id);
        $statuses = StatusService::getOrderAll();

        if (!$order || !$order->is_editable) {
            return redirect(route('orders.index'));
        }

        if ($redirect = $this->isRedirected($order->service_id)) {
            return $redirect;
        }

        $validate = new CreateRequest();

        $columns = Order::cart_columns('edit');

        $address = ServiceService::getSimpleAddress($order->service_id);
        $user = Auth::user();

        return view('orders.edit', compact('order', 'validate', 'statuses', 'columns', 'address', 'user'))->with(['sections' => ['status', 'address_id']]);
    }

    public function update(UpdateRequest $request)
    {
        $model = OrderService::getAvailableByStatus($request->id);
        if (!$model->is_editable) {
            return redirect(route('orders.index'));
        }

        if ($redirect = $this->isRedirected($model->service_id)) {
            return $redirect;
        }

        if (isset($request->status)) {
            if ($request->status == Order::STATUS_COMPLETED && $model->status == Order::STATUS_CANCELED) {
                return redirect(route('orders.index'))->with(['messageError' => __('orders.messageStatusCanceledError')]);
            }
            if ($request->status == Order::STATUS_CANCELED && $model->status == Order::STATUS_COMPLETED) {
                return redirect(route('orders.index'))->with(['messageError' => __('orders.messageStatusCompletedError')]);
            }
        }

        $this->service->update($request);

        return redirect()->route('orders.index')->with(['messageSuccess' => __('orders.messageUpdateOrder')]);
    }

    public function show($id)
    {
        $order = OrderService::getById($id);

        $columns = Order::cart_columns('show');
        $user = UserHelper::getUser();

        return view('orders.order', compact('order', 'columns', 'user'));
    }

    public function cancelOrder($id)
    {
        $order = OrderService::getById($id);

        if (!$order->is_editable) {
            return redirect(route('orders.index'));
        }

        if ($redirect = $this->isRedirected($order->service_id)) {
            return $redirect;
        }

        if ($order->status == Order::STATUS_COMPLETED) {
            return redirect(route('orders.index'))->with(["messageError" => __('orders.messageStatusCompletedError')]);
        }

        $order->status = Order::STATUS_CANCELED;
        $order->save();

        return redirect(route('orders.index'));
    }

    public function completeOrder($id)
    {
        /** @var Order $order */
        $order = OrderService::getById($id);
        if (!$order->is_editable) {
            return redirect(route('orders.index'));
        }

        if ($redirect = $this->isRedirected($order->service_id)) {
            return $redirect;
        }

        if ($order->status == Order::STATUS_CANCELED) {
            return redirect(route('orders.index'))->with(['messageError' => __('orders.messageStatusCanceledError')]);
        }

        $order->status = Order::STATUS_COMPLETED;
        $order->save();

        return redirect(route('orders.index'));
    }

    public function cart(IdRequest $request)
    {
        if ($redirect = $this->isRedirected()) {
            return $redirect;
        }

        $user = UserHelper::getUser();

        $part_errors = [];
        if ($request->session()->has('part_errors')) {
            $part_errors = $request->session()->get('part_errors');
            $request->session()->forget('part_errors');
        }

        $undefined = [];
        if ($request->session()->has('undefined')) {
            $undefined = $request->session()->get('undefined');
            $request->session()->forget('undefined');
        }

        /** @var Collection|Cart[] $parts */
        $parts = $this->service->getParts();

        $total = 0;
        foreach ($parts as $part) {
            $total += $part->amount * $part->part->price;
        }

        $user = UserHelper::getUser();

        $main_address_id = '';
        $name = '';
        $email = '';
        $phone = '';
        $addressError = null;
        if ($user->isManager()) {
            $branches = BranchService::getDisplayed();
            if (can(Permission::branchesAll)) {
                $services = ServiceService::getByBranchAjax($user->getBranchIds(), null, 'inline');
            } else {
                $services = ServiceService::getDisplayed()->pluck('name', 'id')->toArray();
            }
            $address = [];
        } else {
            $services = [];
            $branches = [];
            $address = ServiceService::getSimpleAddress($user->getRealServiceId());
            $mainAddress = AddressRepository::getMainByServiceId($user->getRealServiceId());
            if (isset($mainAddress)) {
                $main_address_id = $mainAddress->id;
                $name = $mainAddress->name;
                $email = $mainAddress->email;
                $phone = $mainAddress->phone;
            } else {
                $addressError = 'У СЦ не указано ни одного адреса!';
            }
        }

        $validate = new CreateRequest();

        $model = new Order();

        $columns = Order::cart_columns('create');

        $repair = null;
        if ($user->isService()) {
            if ($request->id) {
                $repair = RepairService::getById($request->id);
                $request->session()->put('repair_id', $repair->id);
            } elseif ($request->session()->has('repair_id')) {
                $repairId = (int) $request->session()->get('repair_id');
                $repair = RepairService::getById($repairId);
            }
        }

        $data = compact('parts', 'user', 'model', 'services', 'validate', 'total', 'branches', 'columns', 'part_errors', 'undefined', 'repair', 'address', 'main_address_id', 'name', 'email', 'phone', 'addressError');

        return view('orders.cart', $data)->with(['sections' => ['service_id', 'branch_id', 'parts', 'address_id']]);
    }

    public function create(CreateRequest $request)
    {
        if ($redirect = $this->isRedirected($request->service_id)) {
            return $redirect;
        }
        if (!empty($request->session()->get('repair_id'))) {
            $request->repair_id = $request->session()->get('repair_id');
        }
        $res = $this->service->save($request);
        $request->session()->forget('repair_id');

        $result = [];
        $routeParameters = [];
        $route = 'orders.index';

        if (isset($res['errors'])) {
            $result['messageError'] = __($res['errors']);
            $route = 'orders.cart';
        } else {
            $result['messageSuccess'] = __($res['success']);

            if (Auth::user()->isService() && isset($res['model']) && empty($res['model']->repair_id)) {
                $route = 'repairs.create';
                $routeParameters['id'] = $res['model']->id;
            }
        }

        return redirect()->route($route, $routeParameters)->with($result);
    }

    /**
     * @param UploadRequest $request
     */
    public function upload(UploadRequest $request)
    {
        $file = $request->file('file')->store('app/public/import');

        return response()->json(['success' => $file]);
    }

    public function import(ImportRequest $request)
    {
        $file = storage_path() . '/' . $request->filePath[0];

        if (!file_exists($file)) {
            return redirect()->route('orders.cart')
                ->with("messageError", __('orders.wrongFile'));
        }

        try {
            $reader = IOFactory::createReaderForFile($file);
            $reader->setReadDataOnly(true);
            $spreadsheet = $reader->load($file);

            $worksheet = $spreadsheet->getActiveSheet();

            $success = 0;
            $errors = 0;
            $undefined = [];

            foreach ($worksheet->getRowIterator() as $row) {
                $cellIterator = $row->getCellIterator();
                $cellIterator->setIterateOnlyExistingCells(FALSE);

                $data = [];
                foreach ($cellIterator as $cell) {
                    array_push($data, $cell->getValue());
                }

                if (trim($data[0]) && is_numeric($data[1]) && $data[1] > 0) {
                    $part = PartRepository::searchByNameOrVendorCode(trim($data[0]));
                    if ($part && count($part) == 1) {
                        $success++;
                        $this->service->addToCartFromCsv($part[0]->id, (int) $data[1]);
                    } elseif ($part && count($part) > 1) {
                        array_push($undefined, $data);
                        $errors++;
                    } else {
                        $errors++;
                    }
                } else {
                    $errors++;
                }
            }

            $result = [];
            if ($errors) {
                $result['messageError'] = __('orders.errors', ['x' => $errors]);
            }
            if ($success) {
                $result['messageSuccess'] = __('orders.success', ['x' => $success]);
            }
            if ($undefined) {
                $result['undefined'] = $undefined;
            }

            return redirect()->route('orders.cart')->with($result);

        } catch (\Exception $e) {
            return redirect()->route('orders.cart')
                ->with("messageError", __('orders.wrongFile'));
        }
    }

    public function addToCart(AddToCartRequest $request)
    {
        $this->service->addToCart($request->part_id, $request->amount);
        $count = $this->service->count();
        $messageSuccess = __('orders.successfulAdd');

        return response()->json(compact('count', 'messageSuccess'));
    }

    public function addToCartFromSearch(AddToCartFromSearchRequest $request)
    {
        $validate = $request->validate([
            'parts' => 'required|array',
            'parts.*' => 'integer',
        ]);
        if ($validate) {
            foreach ($request->parts as $part_id) {
                $this->service->addToCart($part_id, 1);
            }
        }

        return redirect()->route('orders.cart')->with(['messageSuccess' => __('orders.successfulAdd')]);
    }

    public function changeAmount(AddToCartRequest $request)
    {
        $this->service->addToCart($request->part_id, $request->amount);
        $amount = $this->service->part($request->part_id)->amount;

        /** @var Collection|Cart[] $parts */
        $parts = $this->service->getParts();

        $totalByPart = 0;
        $total = 0;
        foreach ($parts as $part) {
            if ($part->part_id == $request->part_id) {
                $totalByPart += $part->amount * $part->part->price;
            }
            $total += $part->amount * $part->part->price;
        }
        $totalByPart = CurrencyHelper::getPriceConverted($totalByPart);
        $total = CurrencyHelper::getPriceConverted($total);

        return response()->json(compact('totalByPart', 'amount', 'total'));
    }

    public function removeFromCart(AddToCartRequest $request)
    {
        $this->service->deleteOneFromCart($request);

        $parts = $this->service->getParts();

        $total = 0;
        foreach ($parts as $part) {
            $total += $part->amount * $part->part->price;
        }

        $columns = Order::cart_columns('create');

        return view('orders._table', ['parts' => $parts, 'total' => $total, 'type' => 'create', 'title' => 'orders.cart', 'columns' => $columns]);
    }

    public function getAddress(\App\Http\Requests\IdRequest $request)
    {
        $items = ServiceService::getAddress($request->id);
        $items[0]['selected'] = true;

        return response()->json(compact('items'));
    }

    public function invoice(IdRequest $request)
    {
        $order = OrderService::getById($request->id);
        if (can(Permission::orders) && $order) {
            return Redirect::to($order->invoice);
        } else {
            return redirect(route('orders.index'));
        }
    }
}