<?php

namespace App\Http\Controllers;

use App\Mail\EmailChangeConfirmedMail;
use App\Mail\NotifyEmailChangeMail;
use App\Mail\RegisterMail;
use App\Mail\RequestEmailChangeMail;
use App\Mail\UpdatePasswordMail;
use App\Mail\UpdateRoleMail;
use App\Notifications\VolunteerRoleUpdated;
use App\Mail\CreateUserByAdminMail;
use App\Mail\DeactivateAccountMail;
use App\Mail\DeleteAccountMail;
use App\Mail\ValidateMail;
use Illuminate\Support\Facades\Notification;
use App\Models\User;
use App\Notifications\UserRegistered;
use App\Services\GetRole;
use Illuminate\Database\Eloquent\ModelNotFoundException;
use Illuminate\Http\JsonResponse;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Gate;
use Illuminate\Support\Facades\Hash;
use Illuminate\Support\Facades\Log;
use App\Services\UserService;
use Illuminate\Support\Facades\Mail;
use Pest\Support\Str;
use Propaganistas\LaravelPhone\PhoneNumber;

class UserController extends Controller
{
    public function me(Request $request): JsonResponse {
        try {
            return response()->json(UserService::getData($request->user()->id));
        } catch(\Exception $e) {
            Log::info($e->getMessage());
            return response()->json(['message' => "Server error"], 500);
        }
    }

    public function create(Request $request): JsonResponse {

        $request->validate([
            'phone' => ['required', 'phone:FR,national'],
            'email' => ['required', 'email:strict,rfc', 'unique:users,email'],
        ]);

        $phone = new PhoneNumber($request["phone"], 'FR');

        $user = User::create([
            "name" => $request["name"],
            "email" => $request["email"],
            "password" => Hash::make($request["password"]),
            "lastname" => $request["lastname"],
            "validate" => 0,
            "phone" => $phone->formatInternational(),
            "web_notifications" => 1,
            "email_notifications" => 1,
        ]);

        $admins = User::whereIn('role', [1, 2])->get();
        Notification::sendNow($admins, new UserRegistered($user));

        foreach ($admins as $admin) {
            if ($admin->email_notifications) {
                Mail::to($admin->email)->send(new RegisterMail([
                    'adminName' => $admin->name,
                    'adminLastname' => $admin->lastname,
                    'userName' => $user->name,
                    'userLastname' => $user->lastname,
                ]));
            }
        }

        return response()->json(['message' => 'User created successfully']);
    }

    public function createUserByAdmin(Request $request): JsonResponse {

        if(Gate::denies('createOther', $request->user())){
            return response()->json(["message" => "Can't create this user"], 403);
        }

        $request->validate([
            'phone' => ['required', 'phone:FR,national'],
            'email' => ['required', 'email:strict,rfc', 'unique:users,email'],
        ]);

        $phone = new PhoneNumber($request["phone"], 'FR');

        $password = Str::random(12);

        $user = User::create([
            "name" => $request["name"],
            "email" => $request["email"],
            "password" => Hash::make($password),
            "lastname" => $request["lastname"],
            "validate" => 1,
            "role" => 3,
            "phone" => $phone->formatInternational(),
            "web_notifications" => 1,
            "email_notifications" => 1,
        ]);

        if ($user->email_notifications) {
            $data = [
                'name' => $user->name,
                'lastname' => $user->lastname,
            ];
            Mail::to($user->email)->send(new CreateUserByAdminMail($data));
        }

        return response()->json([
            'message' => 'User created successfully',
            "password" => $password,
        ]);
    }

    public function delete(Request $request): JsonResponse {
        try {
            $user = User::find($request->user()->id);

            if ($user->email_notifications) {
                $data = [
                    'name' => $user->name,
                    'lastname' => $user->lastname,
                ];
                Mail::to($user->email)->send(new DeleteAccountMail($data));
            }

            $user->delete();
            return response()->json(['message' => 'User deleted successfully']);
        } catch(\Exception $e) {
            Log::info($e->getMessage());
            return response()->json(['message' => "Server error"], 500);
        }
    }

    public function getUser(Request $request, int $id): JsonResponse {
        try {
            return response()->json(UserService::getData($id));
        } catch (ModelNotFoundException $e) {
            return response()->json(['message' => 'Utilisateur non trouvé'], 404);
        } catch (\Exception $e) {
            Log::info($e->getMessage());
            return response()->json(['message' => "Server error"], 500);
        }
    }

    public function deleteById(Request $request, int $id): JsonResponse {

        if(Gate::denies('deleteOther', $request->user())){
            return response()->json(["message" => "Can't delete this user"], 403);
        }

        try {
            $user = User::find($id);

            if ($user->email_notifications) {
                $data = [
                    'name' => $user->name,
                    'lastname' => $user->lastname,
                ];
                Mail::to($user->email)->send(new DeleteAccountMail($data));
            }

            $user->delete();
            return response()->json(['message' => 'User deleted successfully']);
        } catch(\Exception $e) {
            Log::info($e->getMessage());
            return response()->json(['message' => "Server error"], 500);
        }
    }

    public function deactivate(Request $request, int $id): JsonResponse {
        $userToDeactivate = User::findOrFail($id);

        if(Gate::denies('deactivate', $userToDeactivate)){
            return response()->json(["message" => "Can't delete this user"], 403);
        }

        try {
            $userToDeactivate->update(['validate' => 0]);

            if ($userToDeactivate->email_notifications) {
                $data = [
                    'name' => $userToDeactivate->name,
                    'lastname' => $userToDeactivate->lastname,
                ];
                Mail::to($userToDeactivate->email)->send(new DeactivateAccountMail($data));
            }

            return response()->json(['message' => 'User deactivated successfully']);
        } catch (ModelNotFoundException $e) {
            return response()->json(['message' => 'Utilisateur non trouvé'], 404);
        } catch (\Exception $e) {
            Log::info($e->getMessage());
            return response()->json(['message' => "Server error"], 500);
        }
    }

    public function update(Request $request): JsonResponse {
        try {
            $phone = new PhoneNumber($request["phone"], 'FR');

            $user = User::find($request->user()->id);
            $user->name = $request["name"];
            $user->lastname = $request["lastname"];
            $user->phone = $phone;
            $user->save();

            return response()->json(['message' => 'User updated successfully']);
        } catch(\Exception $e) {
            Log::info($e->getMessage());
            return response()->json(['message' => "Server error"], 500);
        }
    }

    public function validate(Request $request, int $id): JsonResponse {

        if(Gate::denies('validate', $request->user())){
            return response()->json(["message" => "Can't validate this user"], 403);
        }

        try {
            $user = User::find($id);

            $user->validate = 1;
            $user->role = 3;
            $user->verified_at = now();
            $user->save();

            if ($user->email_notifications) {
                $data = [
                    'name' => $user->name,
                    'lastname' => $user->lastname,
                ];
                Mail::to($user->email)->send(new ValidateMail($data));
            }

            return response()->json(['message' => 'User validated successfully']);
        } catch(\Exception $e) {
            Log::info($e->getMessage());
            return response()->json(['message' => "Server error"], 500);
        }
    }

    public function addRole(Request $request, int $id): JsonResponse {

        if(Gate::denies('addRole', $request->user())){
            return response()->json(["message" => "Can't add role to this user"], 403);
        }

        try {
            $user = User::find($id);
            $user->role = $request['role'];
            $user->save();

            $role = GetRole::getRole($request['role']);

            $user->notify(new VolunteerRoleUpdated($role));

            if ($user->email_notifications) {
                Mail::to($user->email)->send(new UpdateRoleMail([
                    'name' => $user->name,
                    'lastname' => $user->lastname,
                    'role' => $role,
                ]));
            }

            return response()->json(['message' => 'User role added successfully']);
        } catch(\Exception $e) {
            Log::info($e->getMessage());
            return response()->json(['message' => "Server error"], 500);
        }
    }

    public function getUsers(Request $request): JsonResponse {
        try {
            $users = User::where('validate', 1)
                ->orderBy('verified_at', 'desc')
                ->pluck('id');

            return response()->json($users);
        } catch(\Exception $e) {
            Log::info($e->getMessage());
            return response()->json(['message' => "Server error"], 500);
        }
    }

    public function getUserTasks(Request $request): JsonResponse {
        try {
            return response()->json(['data' => $request->user()->tasks]);
        } catch (\Exception $e) {
            Log::info($e->getMessage());
            return response()->json(['message' => "Server error"], 500);
        }
    }

    public function getUserByIdTasks(Request $request, int $id): JsonResponse {
        try {
            return response()->json(['data' => User::find($id)->tasks]);
        } catch (\Exception $e) {
            Log::info($e->getMessage());
            return response()->json(['message' => "Server error"], 500);
        }
    }

    public function getUserTaskById(Request $request, int $idTask): JsonResponse {
        try {
            return response()->json(['data' => $request->user()->tasks->find($idTask)]);
        } catch (\Exception $e) {
            Log::info($e->getMessage());
            return response()->json(['message' => "Server error"], 500);
        }
    }

    public function getInvalidUsers(Request $request): JsonResponse {
        if(Gate::denies('getInvalidUsers', $request->user())){
            return response()->json(["message" => "Can't add role to this user"], 403);
        }

        try {
            $users = User::where('validate', 0)->pluck('id');

            return response()->json($users);
        } catch (\Exception $e) {
            Log::info($e->getMessage());
            return response()->json(['message' => "Server error"], 500);
        }
    }

    public function toggleEmailNotifications(Request $request, int $id): JsonResponse {
        try {
            $user = User::findOrFail($id);
            $user->email_notifications = $user->email_notifications ? 0 : 1;
            $user->save();

            return response()->json($user);
        } catch(\Exception $e){
            Log::info($e->getMessage());
            return response()->json(['message' => "Server error"], 500);
        }
    }

    public function toggleWebNotifications(Request $request, int $id): JsonResponse {
        try {
            $user = User::findOrFail($id);
            $user->web_notifications = $user->web_notifications ? 0 : 1;
            $user->save();

            return response()->json($user);
        } catch(\Exception $e){
            Log::info($e->getMessage());
            return response()->json(['message' => "Server error"], 500);
        }
    }

    public function updatePassword(Request $request): JsonResponse {
        try {
            $request->validate([
                'current_password' => ['required'],
                'new_password' => ['required', 'confirmed'],
            ]);

            $user = $request->user();

            if (!Hash::check($request['current_password'], $user->password)) {
                return response()->json(['message' => 'Mot de passe actuel incorrect'], 403);
            }

            $user->password = Hash::make($request['new_password']);
            $user->save();

            if ($user->email_notifications) {
                Mail::to($user->email)->send(new UpdatePasswordMail([
                    'name' => $user->name,
                    'lastname' => $user->lastname,
                ]));
            }

            return response()->json(['message' => 'Mot de passe mis à jour avec succès']);
        } catch (\Exception $e) {
            Log::error($e->getMessage());
            return response()->json(['message' => 'Server error'], 500);
        }
    }

    public function requestEmailChange(Request $request): JsonResponse
    {
        try {
            $request->validate([
                'email' => ['required', 'email:strict,rfc', 'unique:users,email'],
            ]);

            $user = $request->user();

            $token = \Str::random(64);

            $user->pending_email = $request['email'];
            $user->email_change_token = hash('sha256', $token);
            $user->email_change_token_expires_at = now()->addHour();
            $user->save();

            $data = [
                'name' => $user->name,
                'lastname' => $user->lastname,
                'token' => $token
            ];
            Mail::to($user->email)->send(new NotifyEmailChangeMail($data));
            Mail::to($request['email'])->send(new RequestEmailChangeMail($data));

            return response()->json(['message' => 'Un email de confirmation a été envoyé à votre nouvelle adresse.']);
        } catch (\Exception $e) {
            Log::error($e->getMessage());
            return response()->json(['message' => 'Server error'], 500);
        }
    }

    public function confirmEmailChange(Request $request): JsonResponse
    {
        try {
            $request->validate([
                'token' => ['required', 'string'],
            ]);

            $user = User::where('email_change_token', hash('sha256', $request['token']))
                ->where('email_change_token_expires_at', '>', now())
                ->firstOrFail();

            $newEmail = $user->pending_email;
            $oldEmail = $user->email;

            $user->email = $newEmail;
            $user->pending_email = null;
            $user->email_change_token = null;
            $user->email_change_token_expires_at = null;
            $user->save();

            $data = [
                'name' => $user->name,
                'lastname' => $user->lastname,
                'newEmail' => $newEmail
            ];
            Mail::to($newEmail)->send(new EmailChangeConfirmedMail($data));
            Mail::to($oldEmail)->send(new EmailChangeConfirmedMail($data));

            return response()->json(['message' => 'Email mis à jour avec succès']);
        } catch (ModelNotFoundException $e) {
            return response()->json(['message' => 'Token invalide ou expiré'], 400);
        } catch (\Exception $e) {
            Log::error($e->getMessage());
            return response()->json(['message' => 'Server error'], 500);
        }
    }
}