<?php

    namespace Modules\UserManager\Http\Controllers\Users;

    use App\Http\Controllers\Controller;
    use Exception;
    use Illuminate\Http\Request;
    use Illuminate\Http\Response;
    use Illuminate\Support\Facades\Auth;
    use Modules\UserManager\DataTables\RolesDataTable;
    use Modules\UserManager\Entities\Permission;
    use Modules\UserManager\Entities\PermissionGroup;
    use Modules\UserManager\Http\Requests\Role\StoreRoleRequest;
    use Modules\UserManager\Http\Requests\Role\UpdateRoleRequest;
    use Spatie\Permission\Models\Role;

    class RolesController extends Controller
    {
        public $user;

        public function __construct()
        {
            $this->middleware(function ($request, $next) {
                $this->user = Auth::guard('web')->user();
                return $next($request);
            });
        }

        /**
         * Display a listing of the resource.
         *
         * @return Response
         */
        public function index(RolesDataTable $dataTable)
        {
            if (is_null($this->user) || !$this->user->can('role.read')) {
                abort(403, 'Sorry !! You are Unauthorized to view any role !');
            }
            $permissiongroups = PermissionGroup::all();

            return $dataTable->render('usermanager::users.roles.index', compact('permissiongroups'));
        }

        /**
         * Store a newly created resource in storage.
         *
         * @param Request $request
         *
         * @return Response
         */
        public function store(StoreRoleRequest $request)
        {
            if (is_null($this->user) || !$this->user->can('role.create')) {
                abort(403, 'Sorry !! You are Unauthorized to create any role !');
            }

            // Validation Data
            $validated = $request->validated();


            if ($validated) {
                try {
                    // Process Data
                    $validated['guard_name'] = 'web';

                    $role = Role::create($validated);

                    $permissions = $request->input('permissions');

                    if (!empty($permissions)) {
                        $role = Role::find($role->id);
                        $role->syncPermissions($permissions);
                    }

                    echo json_encode(['status' => 'success', 'message' => 'Role Created Successfully']);
                } catch (Exception $e) {
                    echo json_encode(['status' => 'error', 'message' => 'Role Created Failed']);
                }
            }

            return false;
        }

        /**
         * Show the form for creating a new resource.
         *
         * @return Response
         */
        public function create()
        {
        }

        /**
         * Display the specified resource.
         *
         * @param int $id
         *
         * @return Response
         */
        public function show($id)
        {
            //
        }

        /**
         * Show the form for editing the specified resource.
         *
         * @param int $id
         *
         * @return Response
         */
        public function edit($id)
        {
            if (is_null($this->user) || !$this->user->can('role.update')) {
                abort(403, 'Sorry !! You are Unauthorized to edit any role !');
            }

            $role             = Role::findById($id, 'web');
            $permissions      = Permission::all();
            $permissiongroups = PermissionGroup::all();

            $_array = [
                'role'             => $role,
                'permissions'      => $permissions,
                'permissiongroups' => $permissiongroups
            ];

            return view('usermanager::users.roles.edit', $_array);
        }

        /**
         * Update the specified resource in storage.
         *
         * @param Request $request
         * @param int     $id
         *
         * @return Response
         */
        public function update(UpdateRoleRequest $request, Role $role)
        {
            if (is_null($this->user) || !$this->user->can('role.update')) {
                abort(403, 'Sorry !! You are Unauthorized to edit any role !');
            }

            // Validation Data
            $validated = $request->validated();
            if ($validated) {
                try {
                    $role->update($validated);
                    $permissions = $request->input('permissions');
                    if (!empty($permissions)) {
                        $role->syncPermissions($permissions);
                    }

                    session()->flash('success', 'Role has been updated !!');
                    return redirect()->route('user.roles.index');

                } catch (Exception $e) {
                    session()->flash('error', 'Role updated failed!!');
                }

            }
        }

        /**
         * Remove the specified resource from storage.
         *
         * @param int $id
         *
         * @return Response
         */
        public function destroy($id)
        {
            if (is_null($this->user) || !$this->user->can('role.delete')) {
                abort(403, 'Sorry !! You are Unauthorized to delete any role !');
            }


            $role = Role::findById($id, 'web');
            if (!is_null($role)) {
                $role->delete();
            }

            session()->flash('success', 'Role has been deleted !!');
            return redirect()->route('user.roles.index');
        }
    }