<?php

namespace App\Repositories\User;

use App\Domain\Users\UserService;
use App\Enums\RoleEnum;
use App\Models\Role;
use App\Models\User;
use App\Models\System;
use App\Repositories\Model\Interfaces\ModelInterface;
use App\Repositories\User\Interfaces\UserInterface;
use Illuminate\Http\Request;

class UserRepository implements UserInterface
{
    public function __construct(protected UserService $service, private ModelInterface $modelRepository)
    {
    }

    public function index($type, Request $request)
    {
        $query = User::query();

        if ($type == 'active') {
            if ($request->model_id) {
                $modelId = (int)$request->input('model_id');
                $query->where('is_blocked', false)
                    ->whereHas('roles', function ($q) use ($modelId) {
                        $q->where('model_id', $modelId)
                            ->where('role', '!=', 'null')
                            ->with('model');
                    });
            } else {
                $query->where('is_blocked', false)
                    ->with([
                        'roles', 'roles.model'
                    ]);
            }
        } else {
            if ($request->model_id) {
                $modelId = (int)$request->input('model_id');
                $query->where('is_blocked', true)
                    ->whereHas('roles', function ($q) use ($modelId) {
                        $q->where('model_id', $modelId)
                            ->where('role', '!=', 'null')
                            ->with('model');
                    });
            } else {
                $query->where('is_blocked', true)
                    ->with([
                        'roles', 'roles.model'
                    ]);
            }
        }

        $users = $query->get();

        return $users;
    }

    public function show(int $userId)
    {
        return User::query()->with('roles')->find($userId);
    }

    public function update(array $data, int $userId)
    {
        $user = User::find($userId);

        if ($user) {
            if (isset($data['delete_image'])) {
                $user->clearMediaCollection('avatars');
            }

            if (isset($data['image'])) {
                $user->clearMediaCollection('avatars');
                $user->addMedia($data['image'])->toMediaCollection('avatars');
            }

            $this->syncModels($userId, $data['model']);

            $allowedFields = ['first_name', 'last_name', 'start_page', 'email', 'password'];
            $user->update(array_intersect_key($data, array_flip($allowedFields)));
            return $user->refresh();
        }

        return 1;
    }

    public function store($data, $image)
    {
        $user = User::query()->create([
            'first_name' => $data['first_name'],
            'last_name' => $data['last_name'],
            'email' => $data['email'],
            'start_page' => $data['start_page'],
            'password' => $data['password']
        ]);

        foreach ($data['model'] as $key => $item) {
            if (isset($item['roles']) && $item['roles'] != 'null') {
                $role = RoleEnum::from($item['roles']);
                $this->service->assignRole($user, $role, $key);
            }
        }

        foreach ($data['model'] as $key => $item) {
            if (isset($item['permissions']) && $item['permissions'] != 'null') {
                $this->service->assignPermissions($user, $item['permissions'], $key);
            }
        }


        if ($image) {
            $media = $user->addMedia($image)->toMediaCollection('avatars');
        }


        return $user;
    }

    public function blocked(int $userId, bool $type)
    {
        $user = User::find($userId);

        if ($user) {
            $user->update(['is_blocked' => $type]);
            return true;
        }

        return false;
    }

    public function destroy(int $userId)
    {
        $user = User::find($userId);

        if ($user) {
            $user->delete();
            return true;
        }
        return false;
    }

    public function showPermissions($userId, int $modelId)
    {
        return User::query()
            ->with([
                'roles' => function ($query) use ($modelId) {
                    $query->where('model_id', $modelId);
                },
            ])
            ->find($userId);
    }

    private function syncModels(int $userId, array $modelsData)
    {
        $models = $this->modelRepository->getAll();

        /** @var System $model */
        foreach ($models as $model) {
            if (isset($modelsData[$model->id]['roles'])) {
                $role = Role::query()
                    ->where(['user_id' => $userId, 'model_id' => $model->id])->first();

                if ($modelsData[$model->id]['roles'] == 'null') {
                    if ($role) {
                        $role->delete();
                    }
                }

                if ($role) {
                    $role->update(['role' => $modelsData[$model->id]['roles']]);
                } else {
                    Role::query()->create(['user_id' => $userId, 'model_id' => $model->id, 'role' => $modelsData[$model->id]['roles']]);
                }
            }

            if (isset($modelsData[$model->id]['permissions'])) {
                Role::query()
                    ->where(['user_id' => $userId, 'model_id' => $model->id])
                    ->update(['permissions' => json_encode($modelsData[$model->id]['permissions'])]);
            }
        }
    }
}