<?php

namespace App\Http\Controllers;

use App\Helpers\UserHelper;
use App\Http\Requests\IdRequest;
use App\Http\Requests\User\CreateRequest;
use App\Http\Requests\User\IndexRequest;
use App\Http\Requests\User\UpdateRequest;
use App\Models\Permission;
use App\Repository\Service\ServiceRepository;
use App\Services\Branch\BranchService;
use App\Services\Log\LogService;
use App\Services\Service\ServiceService;
use App\Services\User\RoleService;
use App\Services\User\UserService;
use App\Traits\RoleTrait;
use App\Traits\UserTrait;
use App\User;
use Illuminate\Contracts\Foundation\Application;
use Illuminate\Contracts\View\Factory;
use Illuminate\Http\RedirectResponse;
use Illuminate\Http\Request;
use Illuminate\Http\Response;
use Illuminate\Support\Facades\Auth;
use Illuminate\Support\Facades\Route;
use Illuminate\View\View;

class UserController extends Controller
{

    use UserTrait, RoleTrait;

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

    /** @var UserService */
    protected UserService $service;

    /**
     * Controller constructor.
     */
    public function __construct()
    {
        $this->service = new UserService();

        $this->middleware('auth');

        if ($this->permission) {
            $this->middleware(function (Request $request, $next) {
                if (substr_count(Route::currentRouteName(), 'users.edit') || substr_count(Route::currentRouteName(), 'users.update')) {
                    if (can(Permission::services)) {
                        return $next($request);
                    }
                }

                if (!can($this->permission)) {
                    abort('404');
                }

                return $next($request);
            });
        }
    }

    public function index(IndexRequest $request)
    {
        $data = $this->service->search($request);

        $columns = User::columns();

        $branches = BranchService::getDisplayed();
        $roles = RoleService::getNotServiceRoles();

        $status = User::statuses();

        return view('users.list', compact('data', 'columns', 'branches', 'roles', 'status'))->with(['sections' => ['status_id', 'role_id', 'branch_id']]);
    }

    /**
     * Show the form for creating a new resource.
     *
     * @return Application|Factory|Response|View
     */
    public function create()
    {
        $model = new User();

        $branches = BranchService::getDisplayed();
        $roles = RoleService::getNotServiceRoles();
        $services = ServiceService::getDisplayed()->pluck('name', 'id')->toArray();

        $validate = new CreateRequest();

        return view('users.create', compact('model', 'branches', 'services', 'roles', 'validate'))->with(['sections' => ['branch_ids', 'service_ids', 'role']]);
    }

    /**
     * Store a newly created resource in storage.
     *
     * @param CreateRequest $request
     * @param User $user
     *
     * @return RedirectResponse
     */
    public function store(CreateRequest $request)
    {
        $request->validate($request->rules());
        $fields = $request->all();
        $this->userCreate($fields);

        return redirect()->route('users.index')->with('messageSuccess', __('admins.users.messageCreateUser'));
    }

    /**
     * Show the form for editing the specified resource.
     *
     * @param IdRequest $request
     *
     * @return Application|Factory|Response|View
     */
    public function edit(IdRequest $request)
    {
        $data = User::query()->findOrFail($request->id);

        $validate = new UpdateRequest();

        if (!can(Permission::servicesAll)) {
            $service = ServiceService::getById($data->service_id); // fail if this is not my service user
        }

        $branches = [];
        if (can(Permission::branchesAll)) {
            $branches = BranchService::getDisplayed();
            if ($data->branch && $data->branch->display == 0) {
                $branches[$data->branch->id] = $data->branch->name;
            }
        } else {
            $user = UserHelper::getUser();
            if (empty(array_intersect($data->getBranchIds(), $user->getBranchIds()))) {
                return redirect()->route('services.index')->with('messageError', 'Пользователь не найден');
            }
        }

        $roles = $data->isService() ? RoleService::getServiceRoles() : RoleService::getNotServiceRoles();
        $data->branch_ids = $data->getBranchIds();
        $cancelRoute = $this->service->getCancelRoute($data);
        $services = ServiceService::getDisplayed()->pluck('name', 'id')->toArray();
        $data->service_ids = $data->services()->get()->pluck('id')->toArray();

        return view('users.edit', compact('data', 'branches', 'services', 'roles', 'validate', 'cancelRoute'))->with(['sections' => ['branch_ids', 'service_ids', 'role']]);
    }

    public function update(UpdateRequest $request)
    {
        $request->validate($request->rules());
        $fields = $request->all();

        if (!isset($fields['access_system'])) {
            $fields['access_system'] = 0;
        }

        $userData = $this->service->getById($request->id);

        $roles = $userData->isService() ? RoleService::getServiceRoles() : RoleService::getNotServiceRoles();
        $roles = array_keys($roles);
        $role = $fields['role'];
        unset($fields['role']);
        if (!in_array($role, $roles) || Auth::user()->isService()) {
            $role = false;
        }

        if ($userData->isService() && !can(Permission::servicesAll)) {
            ServiceRepository::getAvailable()->findOrFail($userData->service_id); // fail if this is not my service user
        }

        if (Auth::user()->isAdmin() && !empty($fields['new_password'])) {
            $fields['password'] = bcrypt($fields['new_password']);
        }
        unset($fields['new_password']);

        $this->userUpdate($fields, $userData);

        if ($role && $userData->roles()->first()->id <> $role) {
            $this->setUserRole($userData->id, $role);
            LogService::updatedRelations($userData, 'role', $role);
        }

        if ($userData->isService()) {
            $action = 'services.index';
        } else {
            $action = 'users.index';
        }

        return redirect()->route($action)->with('messageSuccess', __('admins.users.messageUpdateUser'));
    }

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

        return redirect()->route('users.index')->with('messageSuccess', __('admins.users.messageDeleteUser'));
    }

}