<?php

namespace App\Http\Controllers\Repuve;

use App\Http\Controllers\Controller;
use Illuminate\Http\Request;
use App\Http\Requests\Repuve\VehicleUpdateRequest;
use Notsoweb\ApiResponse\Enums\ApiResponse;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Storage;
use Illuminate\Support\Facades\Cache;
use App\Models\Record;
use App\Models\File;
use App\Models\Owner;
use App\Models\Error;
use App\Models\CatalogNameImg;
use App\Models\VehicleTagLog;
use App\Services\RepuveService;
use App\Services\PadronEstatalService;
use Exception;
use Illuminate\Support\Facades\Auth;

class UpdateController extends Controller
{
    private RepuveService $repuveService;
    private PadronEstatalService $padronEstatalService;

    public function __construct(
        RepuveService $repuveService,
        PadronEstatalService $padronEstatalService
    ) {
        $this->repuveService = $repuveService;
        $this->padronEstatalService = $padronEstatalService;
    }

    public function vehicleData(Request $request)
    {
        try {
            $request->validate([
                'folio' => 'required|string|exists:records,folio',
                'tag_number' => 'required|string|exists:tags,tag_number',
                'niv' => 'required|string|exists:vehicle,niv'
            ]);

            $folio = $request->input('folio');
            $tagNumber = $request->input('tag_number');
            $niv = $request->input('niv');

            $isStolen = $this->checkIfStolen($niv);

            if ($isStolen) {
                return ApiResponse::FORBIDDEN->response([
                    'message' => 'El vehículo reporta robo. No se puede continuar con la actualización.',
                ]);
            }

            $record = Record::with([
                'vehicle:id,owner_id,placa,niv,marca,linea,modelo,color',
                'vehicle.owner:id,name,paternal,maternal,rfc',
                'vehicle.tag:id,vehicle_id,folio,tag_number,status_id',
                'files:id,record_id,name_id,path,md5',
                'files.catalogName:id,name',
                'user:id,name,email',
                'error:id,code,description'
            ])
                ->select([
                    'id',
                    'folio',
                    'vehicle_id',
                    'user_id',
                    'error_id',
                    'created_at',
                    'updated_at'
                ])->where('folio', $folio)
                ->first();

            if (!$record) {
                return ApiResponse::NOT_FOUND->response([
                    'message' => 'No se encontró el expediente',
                ]);
            }

            $vehicle = $record->vehicle;
            $tag = $vehicle->tag;

            if (!$tag || $tag->tag_number !== $tagNumber) {
                return ApiResponse::BAD_REQUEST->response([
                    'message' => 'El tag_number no coincide con el registrado en el expediente',
                ]);
            }

            if ($vehicle->niv !== $niv) {
                return ApiResponse::BAD_REQUEST->response([
                    'message' => 'El NIV no coincide con el registrado en el expediente',
                ]);
            }

            // Consultar REPUVE Estatal para obtener datos actualizados
            $vehicleDataEstatal = $this->getVehicle($niv);
            $ownerDataEstatal = $this->getOwner($niv);

            // Guardar en caché por 30 minutos
            Cache::put("update_vehicle_{$niv}", $vehicleDataEstatal, 1800);
            Cache::put("update_owner_{$niv}", $ownerDataEstatal, 1800);

            // Detectar si hay cambios entre BD y padrón estatal
            $hasVehicleChanges = $this->detectVehicleChanges($vehicle, $vehicleDataEstatal);
            $hasOwnerChanges = $this->detectOwnerChanges($vehicle->owner, $ownerDataEstatal);

            return ApiResponse::OK->response([
                'message' => 'Datos del vehículo obtenidos exitosamente',
                'current_data' => $record,
                'estatal_data' => [
                    'vehicle' => $vehicleDataEstatal,
                    'owner' => $ownerDataEstatal,
                ],
                'has_changes' => $hasVehicleChanges || $hasOwnerChanges,
                'changes_detail' => [
                    'vehicle' => $hasVehicleChanges,
                    'owner' => $hasOwnerChanges,
                ],
            ]);
        } catch (Exception $e) {
            return ApiResponse::BAD_REQUEST->response([
                'message' => 'Error de validación',
                'error' => $e->getMessage(),
            ]);
        }
    }

    public function vehicleUpdate(VehicleUpdateRequest $request)
    {
        try {
            $folio = $request->input('folio');
            $tagNumber = $request->input('tag_number');
            $niv = $request->input('niv');

            $isStolen = $this->checkIfStolen($niv);

            if ($isStolen) {
                return ApiResponse::FORBIDDEN->response([
                    'niv' => $niv,
                    'stolen' => true,
                    'message' => 'El vehículo reporta robo. No se puede continuar con la actualización.',
                ]);
            }

            $record = Record::with(['vehicle.owner', 'vehicle.tag', 'files', 'error'])
                ->where('folio', $folio)
                ->first();

            if (!$record) {
                return ApiResponse::NOT_FOUND->response([
                    'message' => 'No se encontró el expediente',
                    'folio' => $folio,
                ]);
            }

            $vehicle = $record->vehicle;
            $tag = $vehicle->tag;

            if (!$tag) {
                return ApiResponse::NOT_FOUND->response([
                    'message' => 'No se encontró el tag con el tag_number proporcionado',
                    'tag_number' => $tagNumber,
                ]);
            }

            if ($vehicle->niv !== $niv) {
                return ApiResponse::BAD_REQUEST->response([
                    'message' => 'El NIV no coincide con el registrado en el expediente',
                ]);
            }

            DB::beginTransaction();

            // Intentar obtener datos del caché primero
            $vehicleData = Cache::get("update_vehicle_{$niv}");
            $ownerData = Cache::get("update_owner_{$niv}");

            // Si no hay
            if (!$vehicleData || !$ownerData) {
                $vehicleData = $this->getVehicle($niv);
                $ownerData = $this->getOwner($niv);
            }

            // Limpiar caché
            Cache::forget("update_vehicle_{$niv}");
            Cache::forget("update_owner_{$niv}");

            // Detectar si hay cambios
            $hasVehicleChanges = $this->detectVehicleChanges($vehicle, $vehicleData);
            $hasOwnerChanges = $this->detectOwnerChanges($vehicle->owner, $ownerData);

            // Actualizar propietario solo si hay cambios
            $owner = $vehicle->owner;
            if ($hasOwnerChanges) {
                $owner = Owner::updateOrCreate(
                    ['rfc' => $ownerData['rfc']],
                    [
                        'name' => $ownerData['name'],
                        'paternal' => $ownerData['paternal'],
                        'maternal' => $ownerData['maternal'],
                        'curp' => $ownerData['curp'],
                        'address' => $ownerData['address'],
                        'tipopers' => $ownerData['tipopers'],
                        'pasaporte' => $ownerData['pasaporte'],
                        'licencia' => $ownerData['licencia'],
                        'ent_fed' => $ownerData['ent_fed'],
                        'munic' => $ownerData['munic'],
                        'callep' => $ownerData['callep'],
                        'num_ext' => $ownerData['num_ext'],
                        'num_int' => $ownerData['num_int'],
                        'colonia' => $ownerData['colonia'],
                        'cp' => $ownerData['cp'],
                    ]
                );
            }

            // Actualizar vehículo solo si hay cambios
            if ($hasVehicleChanges) {
                $vehicle->update([
                    'placa' => $vehicleData['placa'],
                    'marca' => $vehicleData['marca'],
                    'linea' => $vehicleData['linea'],
                    'sublinea' => $vehicleData['sublinea'],
                    'modelo' => $vehicleData['modelo'],
                    'color' => $vehicleData['color'],
                    'numero_motor' => $vehicleData['numero_motor'],
                    'clase_veh' => $vehicleData['clase_veh'],
                    'tipo_servicio' => $vehicleData['tipo_servicio'],
                    'rfv' => $vehicleData['rfv'],
                    'rfc' => $vehicleData['rfc'],
                    'ofcexpedicion' => $vehicleData['ofcexpedicion'],
                    'fechaexpedicion' => $vehicleData['fechaexpedicion'],
                    'tipo_veh' => $vehicleData['tipo_veh'],
                    'numptas' => $vehicleData['numptas'],
                    'observac' => $vehicleData['observac'],
                    'cve_vehi' => $vehicleData['cve_vehi'],
                    'nrpv' => $vehicleData['nrpv'],
                    'tipo_mov' => $vehicleData['tipo_mov'],
                    'owner_id' => $owner->id,
                ]);
            }

            $uploadedFiles = [];
            $replacedFiles = [];

            if ($request->hasFile('files')) {
                $files = $request->file('files');
                $nameIds = $request->input('name_id', []);

                if (!empty($nameIds)) {
                    $validIds = CatalogNameImg::whereIn('id', $nameIds)->pluck('id')->toArray();
                    if (count($validIds) !== count($nameIds)) {
                        DB::rollBack();
                        return ApiResponse::BAD_REQUEST->response([
                            'message' => 'Algunos ids del catálogo de nombres no son válidos',
                            'provided_id' => $nameIds,
                            'valid_id' => $validIds,
                        ]);
                    }
                }

                foreach ($files as $indx => $file) {
                    $nameId = $nameIds[$indx] ?? null;

                    if ($nameId === null) {
                        DB::rollBack();
                        return ApiResponse::BAD_REQUEST->response([
                            'message' => "Falta el name_id para el archivo",
                        ]);
                    }

                    $existingFile = File::where('record_id', $record->id)
                        ->where('name_id', $nameId)
                        ->first();

                    if ($existingFile) {
                        Storage::disk('public')->delete($existingFile->path);

                        $replacedFiles[] = [
                            'id' => $existingFile->id,
                            'name_id' => $nameId,
                            'old_path' => $existingFile->path,
                        ];

                        $existingFile->delete();
                    }

                    // Obtener el nombre del catálogo para el nombre del archivo
                    $catalogName = CatalogNameImg::find($nameId);
                    $extension = $file->getClientOriginalExtension();
                    $fileName = $catalogName->name . '_' . date('dmY_His') . '.' . $extension;
                    $path = $file->storeAs("records/{$record->folio}", $fileName, 'public');
                    $md5 = md5_file($file->getRealPath());

                    $fileRecord = File::create([
                        'name_id' => $nameId,
                        'path' => $path,
                        'md5' => $md5,
                        'record_id' => $record->id,
                    ]);

                    $uploadedFiles[] = [
                        'id' => $fileRecord->id,
                        'name' => $catalogName->name,
                        'path' => $fileRecord->path,
                        'url' => $fileRecord->url,
                        'replaced' => $existingFile !== null,
                    ];
                }
            }

            if ($hasVehicleChanges || $hasOwnerChanges || count($uploadedFiles) > 0) {
                VehicleTagLog::create([
                    'vehicle_id' => $vehicle->id,
                    'tag_id' => $tag->id,
                    'action_type' => 'actualizacion',
                    'performed_by' => Auth::id(),
                ]);
            }

            // Solo enviar a REPUVE Nacional si hay cambios
            if ($hasVehicleChanges || $hasOwnerChanges || count($uploadedFiles) > 0) {
                //Envio de datos
                $apiResponse = $this->sendToRepuveNacional($niv);
                $apiResponse["repuve_response"]["folio_ci"] = $record->folio;
                $apiResponse["repuve_response"]["identificador_ci"] = $tag->tag_number;

                if (isset($apiResponse['has_error']) && $apiResponse['has_error']) {
                    $error = Error::where('code', $apiResponse['error_code'])->first();

                    if (!$error) {
                        // Usar error genérico si no se encuentra el código
                        logger()->warning('Código de error REPUVE no catalogado', [
                            'error_code' => $apiResponse['error_code'],
                            'error_message' => $apiResponse['error_message'],
                            'niv' => $niv,
                        ]);

                        // Buscar error
                        $error = Error::where('code', '-1')->first();

                        if (!$error) {
                            // Si ni siquiera existe el error genérico
                            $error = Error::create([
                                'code' => '-1',
                                'name' => 'Error Interno',
                                'description' => 'Error interno del web service. Problemas con la base de datos o en la red.',
                                'type' => 'Error de Conexión',
                            ]);
                        }
                    }

                    $record->update([
                        'error_id' => $error->id,
                        'api_response' => $apiResponse,
                        'error_occurred_at' => now(),
                    ]);

                    DB::commit();

                    return ApiResponse::NOT_ACCEPTABLE->response([
                        'message' => 'Datos guardados con error. Corrija y vuelva a enviar.',
                        'has_error' => true,
                        'can_retry' => true,
                        'error' => [
                            'code' => $error->code,
                            'description' => $error->description,
                            'occurred_at' => $record->error_occurred_at->toDateTimeString(),
                        ],
                        'record' => [
                            'id' => $record->id,
                            'folio' => $record->folio,
                        ],
                    ]);
                }

                $record->update([
                    'error_id' => null,
                    'api_response' => $apiResponse,
                    'error_occurred_at' => null,
                ]);
            }

            DB::commit();

            $sentToRepuve = $hasVehicleChanges || $hasOwnerChanges || count($uploadedFiles) > 0;

            $message = 'Vehículo actualizado exitosamente';
            if (!$hasVehicleChanges && !$hasOwnerChanges && empty($uploadedFiles)) {
                $message = 'No se detectaron cambios. Los datos ya estaban actualizados.';
            } elseif (!$hasVehicleChanges && !$hasOwnerChanges && empty($uploadedFiles)) {
                $message = 'Solo se actualizaron archivos. Los datos del vehículo/propietario no cambiaron.';
            } elseif (($hasVehicleChanges || $hasOwnerChanges) && empty($uploadedFiles)) {
                $message = 'Datos del vehículo/propietario actualizados exitosamente. No se subieron archivos.';
            } elseif ((!$hasVehicleChanges && !$hasOwnerChanges) && !empty($uploadedFiles)) {
                $message = 'Archivos subidos exitosamente. No hubo cambios en los datos del vehículo/propietario.';
            }

            return ApiResponse::OK->response([
                'message' => $message,
                'has_error' => false,
                'sent_to_repuve' => $sentToRepuve,
                'changes_made' => [
                    'vehicle_updated' => $hasVehicleChanges,
                    'owner_updated' => $hasOwnerChanges,
                    'files_uploaded' => count($uploadedFiles) > 0,
                ],
                'record' => [
                    'id' => $record->id,
                    'folio' => $record->folio,
                    'updated_at' => $record->updated_at->toDateTimeString(),
                ],
                'vehicle' => [
                    'id' => $vehicle->id,
                    'placa' => $vehicle->placa,
                    'niv' => $vehicle->niv,
                    'marca' => $vehicle->marca,
                    'modelo' => $vehicle->modelo,
                    'color' => $vehicle->color,
                ],
                'owner' => [
                    'id' => $owner->id,
                    'full_name' => $owner->full_name,
                    'rfc' => $owner->rfc,
                ],
                'tag' => [
                    'id' => $tag->id,
                    'tag_number' => $tag->tag_number,
                    'status' => $tag->status->name,
                ],
                'uploaded_files' => $uploadedFiles,
                'replaced_count' => count($replacedFiles),
                'total_files' => File::where('record_id', $record->id)->count(),
            ]);
        } catch (Exception $e) {
            return ApiResponse::INTERNAL_ERROR->response([
                'message' => 'Error al actualizar el vehículo',
                'error' => $e->getMessage(),
            ]);
        }
    }

    private function checkIfStolen(string $niv): bool
    {
        return $this->repuveService->verificarRobo($niv);
    }

    private function prepararDatosParaInscripcion(string $niv): array
    {
        $datos = $this->padronEstatalService->getVehiculoByNiv($niv);

        return [
            'ent_fed' => $datos['ent_fed'] ?? '',
            'ofcexp' => $datos['ofcexp'] ?? '',
            'fechaexp' => $datos['fechaexp'] ?? '',
            'placa' => $datos['placa'] ?? '',
            'tarjetacir' => $datos['tarjetacir'] ?? '',
            'marca' => $datos['marca'] ?? '',
            'submarca' => $datos['submarca'] ?? '',
            'version' => $datos['version'] ?? '',
            'clase_veh' => $datos['clase_veh'] ?? '',
            'tipo_veh' => $datos['tipo_veh'] ?? '',
            'tipo_uso' => $datos['tipo_uso'] ?? '',
            'modelo' => $datos['modelo'] ?? '',
            'color' => $datos['color'] ?? '',
            'motor' => $datos['motor'] ?? '',
            'niv' => $datos['niv'] ?? '',
            'rfv' => $datos['rfv'] ?? '',
            'numptas' => $datos['numptas'] ?? '',
            'observac' => $datos['observac'] ?? '',
            'tipopers' => $datos['tipopers'] ?? '',
            'curp' => $datos['curp'] ?? '',
            'rfc' => $datos['rfc'] ?? '',
            'pasaporte' => $datos['pasaporte'] ?? '',
            'licencia' => $datos['licencia'] ?? '',
            'nombre' => $datos['nombre'] ?? '',
            'ap_paterno' => $datos['ap_paterno'] ?? '',
            'ap_materno' => $datos['ap_materno'] ?? '',
            'munic' => $datos['munic'] ?? '',
            'callep' => $datos['callep'] ?? '',
            'num_ext' => $datos['num_ext'] ?? '',
            'num_int' => $datos['num_int'] ?? '',
            'colonia' => $datos['colonia'] ?? '',
            'cp' => $datos['cp'] ?? '',
            'cve_vehi' => $datos['cve_vehi'] ?? '',
            'nrpv' => $datos['nrpv'] ?? '',
            'tipo_mov' => $datos['tipo_mov'] ?? '',
        ];
    }

    private function sendToRepuveNacional(string $niv): array
    {
        $datosCompletos = $this->prepararDatosParaInscripcion($niv);
        return $this->repuveService->inscribirVehiculo($datosCompletos);
    }

    private function detectVehicleChanges($vehicle, array $vehicleDataEstatal): bool
    {
        $fieldsToCompare = [
            'placa',
            'marca',
            'linea',
            'sublinea',
            'modelo',
            'color',
            'numero_motor',
            'clase_veh',
            'tipo_servicio',
            'rfv',
            'rfc',
            'ofcexpedicion',
            'tipo_veh',
            'numptas',
            'observac',
            'cve_vehi',
            'nrpv',
            'tipo_mov'
        ];

        foreach ($fieldsToCompare as $field) {
            $bdValue = $vehicle->$field ?? null;
            $estatalValue = $vehicleDataEstatal[$field] ?? null;

            if (strval($bdValue) !== strval($estatalValue)) {
                return true;
            }
        }

        return false;
    }

    private function detectOwnerChanges($owner, array $ownerDataEstatal): bool
    {
        $fieldsToCompare = [
            'name',
            'paternal',
            'maternal',
            'rfc',
            'curp',
            'address',
            'tipopers',
            'pasaporte',
            'licencia',
            'ent_fed',
            'munic',
            'callep',
            'num_ext',
            'num_int',
            'colonia',
            'cp'
        ];

        foreach ($fieldsToCompare as $field) {
            $bdValue = $owner->$field ?? null;
            $estatalValue = $ownerDataEstatal[$field] ?? null;

            if (strval($bdValue) !== strval($estatalValue)) {
                return true;
            }
        }

        return false;
    }

    private function getVehicle(string $niv): array
    {
        $datos = $this->padronEstatalService->getVehiculoByNiv($niv);
        return $this->padronEstatalService->extraerDatosVehiculo($datos);
    }

    private function getOwner(string $niv): array
    {
        $datos = $this->padronEstatalService->getVehiculoByNiv($niv);
        return $this->padronEstatalService->extraerDatosPropietario($datos);
    }
}