<?php

namespace App\Http\Controllers\auth;

use App\Http\Controllers\Controller;
use App\Models\User;
use Carbon\Carbon;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Hash;
use Illuminate\Support\Facades\Auth;

class LoginController extends Controller
{
    public function login(Request $request)
    {
        $rules = [
            'idUsuario' => 'required|max:50',
            'contrasenaHash' => 'required|string',
        ];

        $validator = \Validator::make($request->input(), $rules);
        if ($validator->fails()) {
            return response()->json([
                'status' => 400,
                'errors' => $validator->errors(),
            ], 400);
        }

        // Busca el usuario por idUsuario
        $user = User::where('idUsuario', $request->idUsuario)->first();

        // Verifica si el usuario existe y si la contraseña es correcta
        if (!$user || !Hash::check($request->contrasenaHash, $user->contrasenaHash)) {
            return response()->json([
                'status' => 400,
                'message' => 'Usuario o contraseña incorrectos',
            ], 400);
        }

        // Verifica si la contraseña es "12345"
        if (Hash::check('12345', $user->contrasenaHash)) {
            return response()->json([
                'status' => 401,
                'type' => 'C_PASS',
                'message' => 'Por motivos de seguridad, debe cambiar la contraseña',
                'userId' => $user->idUsuario
            ], 401);
        }

        // *** Verifica la cantidad de tokens activos que tiene el usuario ***
        $minutes = 6*60; // 30 días si no hay config

        // Obtener todos los tokens del usuario
        $tokens = DB::table('personal_access_tokens')
            ->where('tokenable_id', $user->idUsuario)
            ->get();

        // Limpiar los tokens expirados
        foreach ($tokens as $token) {
            $expired = false;

            if ($token->expires_at && Carbon::parse($token->expires_at)->isPast()) {
                $expired = true;
            } elseif (!$token->expires_at && Carbon::parse($token->created_at)->lt(now()->subMinutes($minutes))) {
                $expired = true;
            }

            if ($expired) {
                DB::table('personal_access_tokens')->where('id', $token->id)->delete();
            }
        }

        // Volver a contar los tokens activos
        $tokensCount = DB::table('personal_access_tokens')
            ->where('tokenable_id', $user->idUsuario)
            ->count();

        if ($tokensCount >= 2) {
            return response()->json([
                'status' => 401,
                'type' => 'MAX_DEVICE',
                'errorMessage' => 'Máximo de sesiones abiertas alcanzadas, ciérrelas primero.',
            ], 401);
        }

        // Actualiza la información de login
        DB::table("usuarios")
            ->where(['idUsuario' => $request->idUsuario])
            ->update([
                'lastLoginIp' => $request->ip(),
                'lastLogin' => Carbon::now(),
            ]);

        // *** Genera un token de autenticación con expires_at ***
        $tokenResult = $user->createToken('API TOKEN');  // modelo de Sanctum
        $tokenModel = $tokenResult->accessToken;

        $tokenModel->expires_at = now()->addMinutes($minutes);
        $tokenModel->save();

        $plainTextToken = $tokenResult->plainTextToken;

        return response()->json([
            'status' => 200,
            'message' => 'Bienvenido',
            'data' => [$user->idUsuario, $user->tipoUsuario, $user->primerNombre],
            'token' => $plainTextToken,
        ], 200);
    }



    public function updatePassword(Request $request)
    {
        $request->validate([
            'contrasenaHash' => 'required',
        ]);

        DB::table("usuarios")
            ->where(['idUsuario' => $request->idUsuario])
            ->update([
                'contrasenaHash' => Hash::make($request->contrasenaHash),
            ]);

        return response()->json([
            'status' => 200,
            'message' => 'Contraseña actualizada',
        ], 200);
    }

    public function logout()
    {
        $user = auth()->user();

        if ($user) {
            $user->tokens()->delete();
            return response([
                'message' => 'Successfully logged out'
            ]);
        }

        return response([
            'message' => 'No authenticated user'
        ], 401); // 401 Unauthorized
    }

    public function checkUserTokens(Request $request)
    {
        $request->validate([
            'idUsuario' => 'required|max:50',
        ]);

        // Busca el usuario por idUsuario
        $user = User::where('idUsuario', $request->idUsuario)->first();

        if (!$user) {
            return response()->json([
                'status' => 404,
                'message' => 'Usuario no encontrado',
            ], 404);
        }

        // Verifica si hay tokens para el usuario
        $tokensCount = DB::table('personal_access_tokens')->where('tokenable_id', $user->idUsuario)->count();

        if ($tokensCount === 0) {
            return response()->json([
                'status' => 404,
                'message' => 'No hay tokens para este usuario',
            ], 404);
        }

        return response()->json([
            'status' => 200,
            'message' => 'El usuario tiene tokens activos',
            'tokensCount' => $tokensCount,
        ], 200);
    }
}
