<?php


namespace App\Http\Controllers;

use App\Helpers\UserHelper;
use App\Http\Requests\ActTc\CreateRequest;
use App\Http\Requests\ActTc\IndexRequest;
use App\Http\Requests\ActTc\UpdateRequest;
use App\Http\Requests\Category\UploadRequest;
use App\Http\Requests\IdRequest;
use App\Models\ActTc;
use App\Models\ActTcAttachment;
use App\Models\Permission;
use App\Models\Repair\Repair;
use App\Services\ActTc\ActTcService;
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 App\User;
use Illuminate\Contracts\View\Factory;
use Illuminate\Http\RedirectResponse;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\App;
use Illuminate\Support\Facades\Auth;
use Illuminate\Support\Facades\Response;
use Illuminate\View\View;

class ActTcController extends Controller
{

    protected string $permission = Permission::act_tc_view;

    protected string $protectedRedirect = 'acttc.index';

    protected ActTcService $service;

    public function __construct()
    {
        parent::__construct();
        $this->service = new ActTcService();
    }

    /**
     * Display a listing of the resource.
     *
     * @param IndexRequest $request
     *
     * @return Factory|View
     */
    public function index(IndexRequest $request)
    {
        /** @var User $user */
        $user = Auth::user();

        $data = $this->service->search($request);
        $columns = ActTc::columns();
        $statuses = StatusService::getActtcAll();

        $canBranchesAll = can(Permission::branchesAll);

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

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

    /**
     * Show the form for creating a new resource.
     *
     * @param IdRequest $request
     */
    public function create(IdRequest $request)
    {
        if (!can(Permission::act_tc_create)) {
            return redirect()->route('acttc.index');
        }

        $user = UserHelper::getUser();

        $repair_id = $request->id;
        /** @var Repair $repair */
        $repair = RepairService::getById($repair_id);
        if ($user->isService() && !$repair->orders->isEmpty()) {
            return redirect()->route('acttc.index');
        }

        $model = new ActTc();
        $validate = new CreateRequest();

        $breakdown_causes = ActTc::breakdown_causes();
        if (empty($repair->pre_sale)) {
            unset($breakdown_causes['pre_sale']);
        }

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

        return view('acttc.create', compact('model', 'validate', 'repair_id', 'repair', 'breakdown_causes'))->with(["sections" => ["breakdown_cause"]]);
    }

    public function editSource(IdRequest $request)
    {

        /** @var ActTc $model */
        $model = ActTcService::getById($request->id);
        /** @var Repair $repair */
        $repair = RepairService::getById($model->repair_id);

        $breakdown_causes = ActTc::breakdown_causes();
        if (empty($repair->pre_sale)) {
            unset($breakdown_causes['pre_sale']);
        }
        $validate = new CreateRequest();

        return view('acttc.edit-source', compact('model', 'validate', 'repair', 'breakdown_causes'))->with(["sections" => ["breakdown_cause"]]);
    }

    /**
     * Store a newly created resource in storage.
     *
     * @param CreateRequest $request
     *
     * @return RedirectResponse
     */
    public function store(CreateRequest $request)
    {
        if (empty($request->acttc_id) && !can(Permission::act_tc_create)) {
            return redirect()->route('acttc.index');
        }

        $check = ActTcService::getByRepairId($request->repair_id);
        if ($check && ($check->id != $request->acttc_id)) {
            return redirect()->route('acttc.index')->with(['messageSuccess' => __('acttc.messageCreateError')]);
        }

        $repair = RepairService::getById($request->repair_id);
        if ($redirect = $this->isRedirected($repair->service_id)) {
            return $redirect;
        }

        if ($request->acttc_id) {
            $model = $this->service->updateSource($request);
            $message = __('acttc.messageUpdated');
        } else {
            $model = $this->service->save($request);
            $message = __('acttc.messageCreate');
        }

        if (!empty($request->get('fileId'))) {
            ActTcAttachment::query()->whereIn('id', $request->get('fileId'))->update(['act_tc_id' => $model->id]);
        }

        return redirect()->route('acttc.show', $model->id)->with(["messageSuccess" => $message]);
    }

    /**
     * Display the specified resource.
     *
     * @param IdRequest $request
     *
     * @return Factory|View
     */
    public function show(IdRequest $request)
    {
        /** @var ActTc $model */
        $model = $this->service->getById($request->id);

        return view('acttc.show', compact('model'));
    }

    public function edit(IdRequest $request)
    {
        if (!can(Permission::act_tc_edit)) {
            return redirect()->route('acttc.index');
        }

        $model = ActTcService::getById($request->id);
        $orders = OrderService::getAvailableOpenedOrders($model->repair_id);
        $validate = new UpdateRequest();

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

        return view('acttc.edit', compact('model', 'orders', 'validate'));
    }

    public function update(UpdateRequest $request)
    {
        if (!can(Permission::act_tc_edit)) {
            return redirect()->route('acttc.index');
        }

        $check = ActTcService::getById($request->id);
        if ($check->isAllowManager()) {
            return redirect()->route('acttc.index')->with(['messageSuccess' => __('acttc.messageEditError')]);
        }

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

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

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

    public function renderPdf(IndexRequest $request)
    {
        $model = ActTcService::getById($request->id);

        if (!$model->isAllowPdf()) {
            return redirect()->route('acttc.index');
        }

        $pdf = App::make('dompdf.wrapper');
        $pdf->setPaper('A4');
        $pdf->loadView('acttc.pdf', compact('model'));

        return $pdf->stream('act-' . $model->getPdfNumber() . '.pdf');
    }

    public function saveManagerComment(IndexRequest $request)
    {
        /** @var User $user */
        $user = Auth::user();

        $id = $request->get('id');

        if ($user->isManager()) {
            /** @var ActTc $actTs */
            $actTs = ActTc::query()->find($id);
            $actTs->manager_comment = $request->get('manager_comment');
            $actTs->save();
        }

        return redirect()->route('acttc.show', $id);
    }

    public function uploadFile(UploadRequest $request, $id = 0)
    {
        $file = $request->file('file');
        $result = $file->storeAs('app/public/acttc', $id . '_' . $file->getClientOriginalName());

        $actTcAttachment = new ActTcAttachment();
        $actTcAttachment->act_tc_id = empty($id) ? null : $id;
        $actTcAttachment->path = $result;
        $actTcAttachment->save();

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

    public function download(int $id)
    {
        /** @var ActTcAttachment $attachment */
        $attachment = ActTcAttachment::query()->find($id);
        if (empty($attachment)) {
            return redirect()->route('home');
        }

        $filePath = storage_path($attachment->path);
        if (!file_exists($filePath)) {
            return redirect()->route('home');
        }

        return Response::download($filePath);
    }

    public function deleteAttachment(int $id, Request $request)
    {
        /** @var ActTcAttachment $attachment */
        $attachment = ActTcAttachment::query()->find($id);
        if (empty($attachment)) {
            return redirect()->route('home');
        }

        $filePath = storage_path($attachment->path);
        $actTcId = $attachment->act_tc_id;
        if (file_exists($filePath)) {
            $attachment->delete();
        }

        $backUrl = $request->get('backUrl');
        if (empty($backUrl)) {
            return redirect()->route('home');
        }

        return redirect()->route($backUrl, $actTcId);
    }

}