<?php

namespace App\Http\Controllers;

use App\Models\User;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Hash;
use Illuminate\Support\Facades\Log;
use Illuminate\Support\Facades\Validator;
use Illuminate\Validation\ValidationException;
use Illuminate\Support\Facades\Auth;
use Exception;
use Illuminate\Support\Facades\Artisan;
class AuthController extends Controller
{
    /**
     * Login do usuário
     */
    public function login(Request $request)
    {
        // Limpar cache da aplicação
   /* Artisan::call('cache:clear');

    // Limpar cache de configuração
    Artisan::call('config:clear');

    // Limpar cache de rotas
    Artisan::call('route:clear');

    // Limpar cache de views
    Artisan::call('view:clear');

    // Opcional: você pode obter a saída do comando
    $output = Artisan::output();
    return response()->json([
        'success' => true,
        'message' => 'Caches limpos com sucesso',
        'output' => $output
    ]);*/
        try {
            Log::info('Login attempt', [
                'phone' => $request->phone,
                'has_password' => !empty($request->password),
                'typeUser' => $request->typeUser,
                'user_agent' => $request->userAgent(),
                'ip' => $request->ip()
            ]);

            $validated = $request->validate([
                'phone' => 'required|string',
                'password' => 'required|string',
            ]
            
            );

            $user = User::where('phone', $validated['phone'])->first();

            if (!$user || !Hash::check($validated['password'], $user->password)) {
                Log::warning('Login failed - invalid credentials', [
                    'phone' => $validated['phone'],
                    'user_exists' => !!$user,
                    'ip' => $request->ip()
                ]);

                return response()->json([
                    'success' => false,
                    'message' => 'Dados incorretos.',
                    'timestamp' => now()->toISOString(),
                ], 401);
            }

            // Validação de tipo de usuário
            if ($user->typeUser === 'motorista' && $request->typeUser === 'cliente') {
                return response()->json([
                    'success' => false,
                    'message' => 'Use o app para motoristas.',
                    'timestamp' => now()->toISOString(),
                ], 403);
            }

            if ($user->typeUser === 'cliente' && $request->typeUser === 'motorista') {
                return response()->json([
                    'success' => false,
                    'message' => 'Use o app para passageiros.',
                    'timestamp' => now()->toISOString(),
                ], 403);
            }

            // Atualiza firebase token se enviado
            if ($request->filled('firebase_token')) {
                $user->firebase_token = $request->firebase_token;
                $user->save();
            }

            $token = $user->createToken('boleya_token')->plainTextToken;

            Log::info('Login successful', [
                'user_id' => $user->id,
                'user_type' => $user->typeUser,
                'token_length' => strlen($token)
            ]);

            return response()->json([
    'success' => true,
    'message' => 'Login realizado com sucesso',
    'user' => [
        'id' => $user->id,
        'name' => $user->name,
        'phone' => $user->phone,
        'typeUser' => $user->typeUser,
        'status' => $user->status,
    ],
    'token' => $token,
    'timestamp' => now()->toIso8601String(),
    'matricula' => $user->matricula,
    'marca_carro' => $user->marca_carro,
    'cor_carro' => $user->cor_carro,
    'assento' => $user->assento,
], 200);


        } catch (\Exception $e) {
            Log::error('Login error: ' . $e->getMessage());

            return response()->json([
                'success' => false,
                'message' => config('app.debug') ? $e->getMessage() : 'Erro interno',
                'timestamp' => now()->toISOString(),
            ], 500);
        }
    }
    
     public function user(Request $request)
    {
        $user = $request->user();

        return response()->json([
            'id'          => $user->id,
            'name'        => $user->name,
            'phone '       => $user->phone ,
            'marca_carro' => $user->marca_carro,
            'cor_carro'   => $user->cor_carro,
            'assento'     => $user->assento,
            'matricula'   => $user->matricula,
        ]);
    }

    /**
     * Registro de usuário cliente
     */
    public function registerUser(Request $request)
    {
        try {
            $validated = $request->validate([
                'name' => 'required|string|min:3',
                'phone' => 'required|digits:9|unique:users,phone',
                'bilhete' => 'required|string|size:14|unique:users,bilhete',
                'password' => 'required|string|min:5',
            ], [
            // Mensagens personalizadas para campos únicos
            'phone.unique' => 'Este número de telefone já está registrado.',
            'bilhete.unique' => 'Este bilhete de identidade já está registrado.',
            // Outras mensagens de validação
            'name.required' => 'O nome é obrigatório.',
            'name.min' => 'O nome deve ter pelo menos 3 caracteres.',
            'phone.required' => 'O número de telefone é obrigatório.',
            'phone.digits' => 'O número de telefone deve ter exatamente 9 dígitos.',
            'bilhete.required' => 'O bilhete de identidade é obrigatório.',
            'bilhete.size' => 'O bilhete de identidade deve ter exatamente 14 caracteres.',
            'password.required' => 'A senha é obrigatória.',
            'password.min' => 'A senha deve ter pelo menos 5 caracteres.'
        ]);

            $user = User::create([
                'name' => $validated['name'],
                'phone' => $validated['phone'],
                'bilhete' => $validated['bilhete'],
                'password' => Hash::make($validated['password']),
                'typeUser' => 'cliente',
                'status' => 1
            ]);

            $token = $user->createToken('boleya_token')->plainTextToken;

            return response()->json([
                'success' => true,
                'message' => 'Usuário registrado com sucesso!',
                'user' => [
                    'id' => $user->id,
                    'name' => $user->name,
                    'phone' => $user->phone,
                    'typeUser' => $user->typeUser,
                    'status' => $user->status
                ],
                'token' => $token,
                'timestamp' => now()->toISOString(),
            ], 201);

        } catch (ValidationException $e) {
            return response()->json([
                'success' => false,
                'message' => 'Dados inválidos',
                'errors' => $e->errors(),
                'timestamp' => now()->toISOString(),
            ], 422);
        } catch (\Exception $e) {
            Log::error('Register user error: ' . $e->getMessage());
            return response()->json([
                'success' => false,
                'message' => 'Erro interno do servidor',
                'timestamp' => now()->toISOString(),
            ], 500);
        }
    }

    /**
     * Logout
     */
    public function logout(Request $request)
    {
        try {
            $request->user()->tokens()->delete();
            
            return response()->json([
                'success' => true,
                'message' => 'Logout efetuado com sucesso.',
                'timestamp' => now()->toISOString(),
            ]);
        } catch (\Exception $e) {
            Log::error('Logout error: ' . $e->getMessage());
            return response()->json([
                'success' => false,
                'message' => 'Erro ao fazer logout',
                'timestamp' => now()->toISOString(),
            ], 500);
        }
    }

    /**
     * Verificar se usuário tem foto - COMPATÍVEL COM FLUTTER
     */
    public function checkPhoto(Request $request)
    {
        try {
            $user = $request->user();

            if (!$user) {
                Log::error('Usuário não autenticado em checkPhoto');
                return response()->json([
                    'success' => false,
                    'message' => 'Usuário não autenticado',
                    'error' => 'unauthenticated',
                    'timestamp' => now()->toISOString(),
                ], 401);
            }

            $hasPhoto = !empty($user->photo);
            $photoUrl = null;
            $photoExists = false;

            if ($hasPhoto) {
                $photoPath = storage_path('app/public/' . $user->photo);
                $photoExists = file_exists($photoPath);
                
                if ($photoExists) {
                    $photoUrl = asset('storage/' . $user->photo);
                } else {
                    Log::warning('Foto não encontrada no disco, mas mantendo referência no banco');
                    $photoUrl = asset('storage/' . $user->photo);
                }
            }

            $response = [
                'success' => true,
                'hasPhoto' => $hasPhoto,
                'photoExists' => $photoExists,
                'photoUrl' => $photoUrl,
                'url' => $photoUrl,
                'photo_url' => $photoUrl,
                'profile_photo_url' => $photoUrl,
                'avatar_url' => $photoUrl,
                'image_url' => $photoUrl,
                'file_url' => $photoUrl,
                'image' => $photoUrl,
                'photo' => $photoUrl,
                'user' => [
                    'id' => $user->id,
                    'name' => $user->name,
                    'photo' => $user->photo,
                    'hasPhoto' => $hasPhoto,
                ],
                'timestamp' => now()->toISOString(),
            ];

            if (!$hasPhoto) {
                foreach ([
                    'photoUrl', 'url', 'photo_url', 'profile_photo_url', 
                    'avatar_url', 'image_url', 'file_url', 'image', 'photo'
                ] as $field) {
                    $response[$field] = null;
                }
            }

            return response()->json($response, 200);
            
        } catch (\Exception $e) {
            Log::error('Erro em checkPhoto', [
                'error' => $e->getMessage(),
                'file' => $e->getFile(),
                'line' => $e->getLine(),
                'user_id' => $request->user()->id ?? 'unknown'
            ]);
            
            return response()->json([
                'success' => false,
                'message' => 'Erro interno do servidor',
                'error' => config('app.debug') ? $e->getMessage() : 'internal_server_error',
                'timestamp' => now()->toISOString(),
            ], 500);
        }
    }

    /**
     * Atualizar foto do usuário - COMPATÍVEL COM FLUTTER
     */
    public function updatePhoto(Request $request)
    {
        try {
            if (!$request->hasFile('photo')) {
                return response()->json([
                    'success' => false,
                    'message' => 'Nenhuma foto foi enviada.',
                ], 400);
            }

            $file = $request->file('photo');
            $extension = strtolower($file->getClientOriginalExtension());
            $allowedExtensions = ['jpg', 'jpeg', 'png', 'gif', 'webp'];

            if (!in_array($extension, $allowedExtensions)) {
                return response()->json([
                    'success' => false,
                    'message' => 'Formato não permitido.',
                    'allowed' => $allowedExtensions
                ], 400);
            }

            $filename = 'profile_' . time() . '_' . uniqid() . '.' . $extension;
            $relativePath = 'profiles/' . $filename;

            $publicProfilesDir = public_path('storage/profiles');
            if (!is_dir($publicProfilesDir)) {
                mkdir($publicProfilesDir, 0755, true);
            }

            $file->move($publicProfilesDir, $filename);

            $user = $request->user();

            if ($user->photo) {
                $oldFile = public_path('storage/' . $user->photo);
                if (file_exists($oldFile)) {
                    unlink($oldFile);
                }
            }

            $user->photo = $relativePath;
            $user->save();

            $photoUrl = asset('storage/' . $relativePath);

            return response()->json([
                'success' => true,
                'message' => 'Foto atualizada com sucesso!',
                'photo_url' => $photoUrl,
                'path' => $relativePath,
                'filename' => $filename,
            ], 200);

        } catch (\Exception $e) {
            return response()->json([
                'success' => false,
                'message' => 'Erro interno.',
                'error' => config('app.debug') ? $e->getMessage() : 'internal_server_error',
            ], 500);
        }
    }

    /**
     * Verificar status do usuário
     */
    public function verificarstatus(Request $request)
    {
        $user = $request->user();

        if (!$user) {
            return response()->json([
                'success' => false,
                'message' => 'Usuário não autenticado.',
            ], 401);
        }

        return response()->json([
            'status' => $user->status,
        ]);
    }

    /**
     * Registro de motorista
     */
    public function registerDriver(Request $request)
    {
        // Validação personalizada com mensagens específicas para campos únicos
        $validator = Validator::make($request->all(), [
            'name' => 'required|string|min:3',
            'phone' => 'required|digits:9|unique:users,phone',
            'bilhete' => 'required|string|size:14|unique:users,bilhete',
            'password' => 'required|string|min:5',
            'carta_conducao' => 'required|string|size:8|unique:users,carta_conducao',
            'data_emissao' => 'required|string',
            'tipo_conta' => 'nullable|string|in:boleya,comercial',
            'tipo_carga' => 'nullable|string|in:Ligeiro,Pesado',
            'marca_carro' => 'nullable|string',
            'cor_carro' => 'nullable|string',
            'ano_fabrico' => 'nullable|string',
            'matricula' => 'nullable|string|unique:users,matricula',
            'lugares' => 'nullable|integer|min:1|max:50',
            'ivm_image' => 'nullable|file|max:4096',
            'firebase_token' => 'nullable|string'
        ], [
            // Mensagens personalizadas para campos únicos
            'phone.unique' => 'Este número de telefone já está registrado.',
            'bilhete.unique' => 'Este bilhete de identidade já está registrado.',
            'carta_conducao.unique' => 'Esta carta de condução já está registrada.',
            'matricula.unique' => 'Esta matrícula já está registrada.',
            
            // Outras mensagens de validação
            'name.required' => 'O nome é obrigatório.',
            'name.min' => 'O nome deve ter pelo menos 3 caracteres.',
            'phone.required' => 'O número de telefone é obrigatório.',
            'phone.digits' => 'O número de telefone deve ter exatamente 9 dígitos.',
            'bilhete.required' => 'O bilhete de identidade é obrigatório.',
            'bilhete.size' => 'O bilhete de identidade deve ter exatamente 14 caracteres.',
            'password.required' => 'A senha é obrigatória.',
            'password.min' => 'A senha deve ter pelo menos 5 caracteres.',
            'carta_conducao.required' => 'A carta de condução é obrigatória.',
            'carta_conducao.size' => 'A carta de condução deve ter exatamente 8 caracteres (formato LD-12345).',
            'data_emissao.required' => 'A data de emissão é obrigatória.',
            'tipo_conta.in' => 'Tipo de conta inválido. Deve ser "boleya" ou "comercial".',
            'tipo_carga.in' => 'Tipo de carga inválido. Deve ser "Ligeiro" ou "Pesado".',
            'lugares.integer' => 'O número de lugares deve ser um número inteiro.',
            'lugares.min' => 'O número de lugares deve ser pelo menos 1.',
            'lugares.max' => 'O número de lugares não pode ser maior que 50.',
            'ivm_image.max' => 'A imagem do IVM não pode ser maior que 4MB.',
        ]);

        // Verificar se a validação falhou
        if ($validator->fails()) {
            return response()->json([
                'message' => 'Dados de validação inválidos.',
                'errors' => $validator->errors()
            ], 422);
        }

        $validated = $validator->validated();

        // Validação adicional da imagem
        $ivmImagePath = null;
        if ($request->hasFile('ivm_image')) {
            $ext = strtolower($request->file('ivm_image')->getClientOriginalExtension());

            if (!in_array($ext, ['jpg', 'jpeg', 'png'])) {
                return response()->json([
                    'message' => 'Formato de imagem inválido.',
                    'errors' => [
                        'ivm_image' => ['Apenas imagens JPG, JPEG ou PNG são permitidas.']
                    ]
                ], 422);
            }

            try {
                $ivmImagePath = $request->file('ivm_image')->store('ivm_images', 'public');
            } catch (Exception $e) {
                return response()->json([
                    'message' => 'Erro ao fazer upload da imagem.',
                    'errors' => [
                        'ivm_image' => ['Falha no upload da imagem. Tente novamente.']
                    ]
                ], 500);
            }
        }

        try {
            // Criar o usuário com todos os campos
            $user = User::create([
                'name' => $validated['name'],
                'phone' => $validated['phone'],
                'bilhete' => $validated['bilhete'],
                'password' => Hash::make($validated['password']),
                'carta_conducao' => $validated['carta_conducao'],
                'data_emissao' => $validated['data_emissao'],
                'firebase_token' => $validated['firebase_token'] ?? null,
                'tipo_conta' => $validated['tipo_conta'] ?? null,
                'tipo_carga' => $validated['tipo_carga'] ?? null,
                'marca_carro' => $validated['marca_carro'] ?? null,
                'cor_carro' => $validated['cor_carro'] ?? null,
                'ano_fabrico' => $validated['ano_fabrico'] ?? null,
                'matricula' => $validated['matricula'] ?? null,
                'ivm_image_path' => $ivmImagePath,
                'typeUser' => 'motorista',
                'assento' => $validated['lugares'] ?? 0,
                'status' => 0
            ]);

            // Gerar token de autenticação
            $token = $user->createToken('boleya_token')->plainTextToken;

            // Resposta de sucesso com todos os dados
            return response()->json([
                'message' => 'Conta criada com sucesso!',
                'user' => [
                    'id' => $user->id,
                    'name' => $user->name,
                    'phone' => $user->phone,
                    'bilhete' => $user->bilhete,
                    'carta_conducao' => $user->carta_conducao,
                    'data_emissao' => $user->data_emissao,
                    'tipo_conta' => $user->tipo_conta,
                    'tipo_carga' => $user->tipo_carga,
                    'marca_carro' => $user->marca_carro,
                    'cor_carro' => $user->cor_carro,
                    'ano_fabrico' => $user->ano_fabrico,
                    'matricula' => $user->matricula,
                    'ivm_image_url' => $ivmImagePath ? asset('storage/' . $ivmImagePath) : null,
                    'typeUser' => $user->typeUser,
                    'status' => $user->status,
                    'lugares' => $user->assento,
                ],
                'token' => $token
            ], 201);

        } catch (Exception $e) {
            // Log do erro para debugging
            Log::error('Erro ao criar usuário motorista: ' . $e->getMessage());
            
            return response()->json([
                'message' => 'Erro interno do servidor.',
                'errors' => [
                    'server' => ['Ocorreu um erro ao criar a conta. Tente novamente.']
                ]
            ], 500);
        }
    }
    
    public function ganhos(Request $request)
{
    $user = $request->user();

    if (!$user) {
        return response()->json(['error' => 'Usuário não autenticado'], 401);
    }

    try {
        $query = \App\Models\Post::where('user_id', $user->id)
            ->where('status', \App\Models\Post::STATUS_TERMINADO);

        $ganhos = [
            'diario' => (clone $query)->whereDate('created_at', today())->sum('preco'),
            'semanal' => (clone $query)->whereBetween('created_at', [now()->startOfWeek(), now()->endOfWeek()])->sum('preco'),
            'mensal' => (clone $query)->whereMonth('created_at', now()->month)->sum('preco'),
            'anual' => (clone $query)->whereYear('created_at', now()->year)->sum('preco'),
        ];

        return response()->json($ganhos);
    } catch (\Exception $e) {
        \Log::error("Erro em ganhos: " . $e->getMessage());
        return response()->json(['error' => 'Erro interno'], 500);
    }
}
}

