<?php

namespace App\Http\Controllers;

use App\Models\User;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Validator;
use Illuminate\Support\Facades\Hash;
use Spatie\Permission\Models\Role;
use Carbon\Carbon;
use Illuminate\Support\Str;
use Illuminate\Support\Facades\Storage;
use SimpleSoftwareIO\QrCode\Facades\QrCode;
use BaconQrCode\Renderer\ImageRenderer;
use BaconQrCode\Renderer\Image\GdImageBackEnd;
use BaconQrCode\Renderer\RendererStyle\RendererStyle;
use BaconQrCode\Writer;
use Illuminate\Support\Facades\DB;

class AuthController extends \Illuminate\Routing\Controller
{
    /**
     * Register a new user
     */
    public function registerold(Request $request)
    {
        $validator = Validator::make($request->all(), [
            'name'     => 'required|string|max:255',
            'email'    => 'required|string|email|max:255|unique:users',
            'password' => 'required|string|min:6|confirmed',
        ]);

        if ($validator->fails()) {
            return response()->json($validator->errors(), 422);
        }

        $user = User::create([
            'name'     => $request->name,
            'email'    => $request->email,
             'username'    => $request->username,
              'address'    => $request->address,
            'password' => Hash::make($request->password),
        ]);

        // Assign default role
        $user->assignRole('user');

        return response()->json([
            'message' => 'User successfully registered',
            'user'    => $user
        ], 201);
    }

    public function registerperfect(Request $request)
{
    $validator = Validator::make($request->all(), [
        'surname' => 'required|string|max:255',
        'first_name'  => 'required|string|max:255',
        'gender'   => 'required|string|max:255',
        'email'      => 'required|string|email|max:255|unique:users',
        'password'   => 'required|string|min:6|confirmed',
        'cat_of_school' => 'required|string|min:6',
        'institution' => 'required|string|min:6',
        'matric_no' => 'string|min:3',
        'course'   => 'required|string|max:255',
        'address' => 'required|string|min:6',
        'phone' => 'required|string|min:6',
        'role_id'    => 'nullable|in:2', 

           'profile_picture' => 'nullable|image|mimes:jpg,jpeg,png|max:2048',
    ]);

    $imagePath = null;

if ($request->hasFile('profile_picture')) {
    $file = $request->file('profile_picture');

    // Generate unique name
    $filename = time() . '_' . $file->getClientOriginalName();

    // Store in storage/app/public/profile_pictures
    $imagePath = $file->storeAs('profile_pictures', $filename, 'public');
}

    if ($validator->fails()) {
        return response()->json($validator->errors(), 422);
    }

    $roleId = $request->input('role_id', 2); // default = user
    // Generate enrol number
//$enrolNo = 'ENR-' . strtoupper(Str::random(8));
$enrolNo = strtoupper(Str::random(2)) . rand(10, 99); 

    $user = User::create([
        'surname'              => $request->surname,
        'first_name'               => $request->first_name,
        'gender'                => $request->gender,
        'email'                   => $request->email,
        'cat_of_school'                   => $request->cat_of_school,
            'institution'                   => $request->institution,
        'matric_no'                   => $request->matric_no,
         'course'                => $request->course,
        'address'                   => $request->address,
        'enrol_no'       => $enrolNo,
         'phone'                   => $request->phone,
        'password'                => Hash::make($request->password),
        'role_id'                 => $roleId,
        'approved'                => false,
        'status'                  => 'inactive',

         'image' => $imagePath,
    ]);

// Public profile URL (no auth required)
//$profileUrl = url('/api/public/user/' . $user->id);
$profileUrl = url('/api/user/' . $user->enrol_no);

// $renderer = new ImageRenderer(
//     new RendererStyle(300),
//     new GdImageBackEnd()
// );

// $writer = new Writer($renderer);

// Generate QR Code (stores the URL inside)
// $qr = QrCode::format('png')
//     ->size(300)
//      ->margin(1)
//     ->generate($profileUrl);

   // $qr = $writer->writeString($profileUrl);

// Save QR image
// $qrPath = 'qr_codes/' . $user->id . '.png';
// Storage::disk('public')->put($qrPath, $qr);

// Save path in DB
// $user->update([
//     'qr_code' => $qrPath
// ]);

    // ✅ Map role_id → Spatie role
    $roleMap = [
        2 => 'user',
        // 3 => 'merchant',
        // 4 => 'vendor',
    ];

    if (isset($roleMap[$roleId])) {
        $user->assignRole($roleMap[$roleId]);
    }

    // return response()->json([
    //     'message' => 'User successfully registered',
    //     'user'    => $user,
    // ], 201);

    return response()->json([
    'message' => 'User successfully registered',
    'user' => [
        ...$user->toArray(),
        'image_url' => $user->image 
            ? asset('storage/' . $user->image)
            : null,
           // 'qr_code_url' => asset('storage/' . $user->qr_code),
        'profile_url' => $profileUrl
    ],
], 201);
}

public function register(Request $request)
{
    $validator = Validator::make($request->all(), [
        'surname' => 'required|string|max:255',
        'first_name' => 'required|string|max:255',
        'gender' => 'required|string|max:255',
        'email' => 'required|string|email|max:255|unique:users',
        'password' => 'required|string|min:6|confirmed',
        'cat_of_school' => 'required|string',
        'institution' => 'required|string',
        'matric_no' => 'nullable|string|min:3',
        'course' => 'required|string|max:255',
        'address' => 'required|string',
        'phone' => 'required|string',
        'profile_picture' => 'required|image|mimes:jpg,jpeg,png|max:2048',
    ]);

    if ($validator->fails()) {
        return response()->json([
            'errors' => $validator->errors()
        ], 422);
    }

    DB::beginTransaction();

    try {
        $data = $validator->validated();

        // ✅ Handle Image AFTER validation
        $imagePath = null;
        if ($request->hasFile('profile_picture')) {
            $imagePath = $request->file('profile_picture')
                ->store('profile_pictures', 'public');
        }

        // Generate enrol number
        $enrolNo = strtoupper(Str::random(2)) . rand(10, 99);

        $user = User::create([
            'surname' => $data['surname'],
            'first_name' => $data['first_name'],
            'gender' => $data['gender'],
            'email' => $data['email'],
            'cat_of_school' => $data['cat_of_school'],
            'institution' => $data['institution'],
            'matric_no' => $data['matric_no'] ?? null,
            'course' => $data['course'],
            'address' => $data['address'],
            'phone' => $data['phone'],
            'enrol_no' => $enrolNo,
            'password' => Hash::make($data['password']),
            'role_id' => 2,
            'approved' => false,
            'status' => 'inactive',
            'image' => $imagePath,
        ]);

        // Assign role
        $user->assignRole('user');

        DB::commit();

        return response()->json([
            'message' => 'User successfully registered',
            'user' => [
                ...$user->toArray(),
                'image_url' => $imagePath ? asset('storage/' . $imagePath) : null,
            ]
        ], 201);

    } catch (\Throwable $e) {
        DB::rollBack();

        return response()->json([
            'message' => 'Registration failed',
            'error' => $e->getMessage() // remove in production
        ], 500);
    }
}

    public function registerwork(Request $request)
{
    // Validate input
    $validator = Validator::make($request->all(), [
        'first_name' => 'required|string|max:255',
        'last_name'  => 'required|string|max:255',
        'username'   => 'required|string|max:255|unique:users',
        'email'      => 'required|string|email|max:255|unique:users',
        'password'   => 'required|string|min:6|confirmed',
    ]);

    if ($validator->fails()) {
        return response()->json($validator->errors(), 422);
    }

    // Create user
    $user = User::create([
        'first_name'              => $request->first_name,
        'last_name'               => $request->last_name,
        'username'                => $request->username,
        'email'                   => $request->email,
        'password'                => Hash::make($request->password),
        'role_id'                 => 2, // Default role id = 2
        'approved'                => false, // Or false if you want manual approval
        'status'                  => 'inactive',
    ]);
    // Optional: assign Spatie role by name
if (! $user->hasRole('user')) {
    $user->assignRole('user');
}

    return response()->json([
        'message' => 'User successfully registered',
        'user'    => $user,
    ], 201);
}

    /**
     * Login user and return JWT token
     */
    public function login(Request $request)
    {
        $validator = Validator::make($request->all(), [
            'email'    => 'required|email',
            'password' => 'required|string',
        ]);

        if ($validator->fails()) {
            return response()->json($validator->errors(), 422);
        }

        $credentials = $request->only('email', 'password');

        // 🔑 Use 'api' guard explicitly for JWT
        if (!$token = auth('api')->attempt($credentials)) {
            return response()->json(['error' => 'Unauthorized'], 401);
        }

        return $this->respondWithToken($token);
    }

    /**
     * Get the currently authenticated user
     */
    public function me()
    {
        return response()->json(auth('api')->user());
    }

    /**
     * Logout user (invalidate the token)
     */
    public function logout()
    {
        auth('api')->logout();
        return response()->json(['message' => 'Successfully logged out']);
    }

    /**
     * Refresh a JWT token
     */
    public function refresh()
    {
        return $this->respondWithToken(auth('api')->refresh());
    }

    /**
     * Format JWT token response
     */
    protected function respondWithToken($token)
    {
        return response()->json([
            'access_token' => $token,
            'token_type'   => 'bearer',
            'expires_in'   => auth('api')->factory()->getTTL() * 60,
            'user'         => auth('api')->user()
        ]);
    }
}