<?php

namespace App\Http\Controllers;

use App\Helpers\UserHelper;
use App\Http\Requests\Branch\CreateRequest;
use App\Http\Requests\Branch\IndexRequest;
use App\Http\Requests\Branch\UpdateRequest;
use App\Http\Requests\IdRequest;
use App\Http\Requests\ImportRequest;
use App\Http\Requests\UploadRequest;
use App\Models\Branch;
use App\Models\Permission;
use App\Models\Region;
use App\Services\Branch\BranchService;
use App\Traits\GridTrait;
use Illuminate\Http\RedirectResponse;
use Illuminate\Http\Request;
use PhpOffice\PhpSpreadsheet\IOFactory;


class BranchesController extends Controller
{

    use GridTrait;

    /** @var string */
    protected string $permission = Permission::branches;

    protected BranchService $branchService;

    /**
     * BranchesController constructor.
     */
    public function __construct()
    {
        parent::__construct();

        $this->branchService = new BranchService();
    }

    public function index(IndexRequest $request)
    {
        $request->validate($request->rules());

        $data = $this->branchService->search($request);

        $columns = Branch::columns();

        $canBranches = can(Permission::branches);

        return view('branches.list', compact('data', 'columns', 'canBranches'));
    }

    public function create()
    {
        $branch = new Branch();
        $validate = new CreateRequest();
        $regions = [];
        foreach (Region::all() as $region) {
            /** @var Region $region */
            $regions[$region->id] = $region->name;
        }

        return view('branches.create', compact('branch', 'validate', 'regions'));
    }

    public function show(IdRequest $request)
    {
        $user = UserHelper::getUser();
        $branch = $this->branchService->getById($request->id);

        return view('branches.show', compact('user', 'branch'));
    }

    public function edit(Request $request)
    {
        $data = $this->branchService->getById($request->id);
        $validate = new UpdateRequest();
        $regions = [];
        foreach (Region::all() as $region) {
            /** @var Region $region */
            $regions[$region->id] = $region->name;
        }

        return view('branches.edit', compact('data', 'validate', 'regions'));
    }

    public function store(CreateRequest $request, Branch $branch)
    {
        $request->validate($request->rules());
        $fields = $request->all();
        $branch->fill($fields)->save();

        $this->branchService->updateCentral($branch);

        return redirect()->route('branches')->with(['messageSuccess' => __('admins.messageCreateBranch')]);
    }

    public function update(UpdateRequest $request)
    {
        $request->validate($request->rules());
        $fields = $request->all();
        if (!isset($fields['display'])) {
            $fields['display'] = 0;
        }
        if (!isset($fields['central'])) {
            $fields['central'] = 0;
        }

        $model = $this->branchService->getById($request->id);
        $model->fill($fields)->update();
        $this->branchService->updateCentral($model);

        return redirect()->route('branches')->with(["messageSuccess" => __('admins.messageUpdateBranch')]);
    }

    /**
     * Remove the specified resource from storage.
     *
     * @param int $id
     *
     * @return RedirectResponse
     */
    public function delete($id)
    {
        $this->branchService->delete($id);

        return redirect()->route('branches')->with(["messageSuccess" => __('admins.messageDeleteBranch')]);
    }

    public function importView()
    {
        if (!can(Permission::branches)) {
            return redirect()->route('branches');
        }

        return view('branches.import');
    }

    public function uploadFile(UploadRequest $request)
    {
        if (!can(Permission::branches)) {
            redirect()->route('branches');
        }

        $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('branches', $request->id)
                ->with("messageError", __('branches.wrongFile'));
        }

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

            $worksheet = $spreadsheet->getActiveSheet();

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

                $data = [];
                foreach ($cellIterator as $cell) {
                    array_push($data, $cell->getValue());
                }
                if ($data[0] && $data[4]) {
                    BranchService::fillStorage(strtok($data[0], '0'), $data[4]);
                }
            }

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

}