<?php

namespace App\Http\Controllers;

use App\Models\DnsZoneAssignment;
use App\Models\PowerDnsChangelog;
use App\Models\PowerDnsRecordMetadata;
use App\Services\PowerDNSService;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Auth;
use Illuminate\Support\Facades\Log;

class PowerDNSUserController extends Controller
{
    protected $powerDNS;

    public function __construct()
    {
        // Nu mai folosim injectarea de dependență pentru PowerDNS
        // Vom detecta automat nameserver-ul corect pentru fiecare zonă
        $this->powerDNS = null; // Se va inițializa dinamic cu getPowerDNSForZone()
    }

    /**
     * Găsește PowerDNS service-ul corect pentru o zonă specificată
     */
    private function getPowerDNSForZone($zoneName)
    {
        $activeNameservers = \App\Models\Nameserver::where('is_active', true)->get();

        foreach ($activeNameservers as $nameserver) {
            try {
                $powerDNS = new PowerDNSService($nameserver->api_url, $nameserver->api_key);
                $zoneResult = $powerDNS->getZone($zoneName);

                if ($zoneResult['success']) {
                    \Log::info("Found zone {$zoneName} on nameserver {$nameserver->name}");
                    return $powerDNS;
                }
            } catch (\Exception $e) {
                \Log::warning("Failed to connect to nameserver {$nameserver->name}: " . $e->getMessage());
                continue;
            }
        }

        \Log::error("Zone {$zoneName} not found on any active nameserver");
        // Fallback: încearcă primul nameserver disponibil
        $firstNameserver = \App\Models\Nameserver::where('is_active', true)->first();
        if ($firstNameserver) {
            return new PowerDNSService($firstNameserver->api_url, $firstNameserver->api_key);
        }

        throw new \Exception("Nu există nameservere active disponibile!");
    }

    /**
     * Sincronizează un record local către toate nameserverele atribuite
     */
    private function syncRecordToNameservers($dnsZone, $localRecord)
    {
        try {
            \Log::info("Sincronizare record {$localRecord->name} {$localRecord->type} către nameservere pentru zona {$dnsZone->domain}");

            // Pentru acum, doar log-uim - implementarea completă va fi cu Job/Queue
            // TODO: Implementează Job pentru sincronizare асинхронă

            // Găsește nameserver-ul principal al zonei
            if ($dnsZone->nameServer && $dnsZone->nameServer->is_active) {
                $this->syncSingleRecordToNameserver($dnsZone, $localRecord, $dnsZone->nameServer);
            } else {
                // Fallback: încearcă să găsească nameserver-ul prin getPowerDNSForZone
                $powerDNSService = $this->getPowerDNSForZone($dnsZone->domain);
                // Sincronizare imediată pentru dezvoltare
                $this->syncRecordDirectly($dnsZone, $localRecord, $powerDNSService);
            }

        } catch (\Exception $e) {
            \Log::error("Eroare sincronizare record către nameservere: " . $e->getMessage());
        }
    }

    /**
     * Sincronizează direct un record către PowerDNS (pentru dezvoltare)
     */
    private function syncRecordDirectly($dnsZone, $localRecord, $powerDNSService)
    {
        try {
            $zoneName = rtrim($dnsZone->domain, '.') . '.';

            // Construiește numele complet al record-ului
            $fullName = $localRecord->name === '@'
                ? $zoneName
                : $localRecord->name . '.' . $zoneName;

            // Obține RRset-ul existent din PowerDNS
            $recordsResponse = $powerDNSService->getRecords($zoneName);

            if (!$recordsResponse['success']) {
                throw new \Exception("Eroare obținere records din PowerDNS: " . ($recordsResponse['message'] ?? 'Unknown'));
            }

            $existingRRSet = collect($recordsResponse['data'])->first(function ($rrset) use ($fullName, $localRecord) {
                return $rrset['name'] === $fullName && $rrset['type'] === $localRecord->type;
            });

            // Construiește content-ul pentru PowerDNS
            $content = $localRecord->content;
            if ($localRecord->type === 'MX' && $localRecord->priority) {
                $content = $localRecord->priority . ' ' . $content;
            }

            $recordData = [
                'content' => $content,
                'disabled' => !$localRecord->is_active,
            ];

            // Dacă RRset-ul există, actualizează-l; altfel creează unul nou
            if ($existingRRSet) {
                // Înlocuiește înregistrarea în RRset-ul existent
                $updatedRecords = [];
                $found = false;

                foreach ($existingRRSet['records'] ?? [] as $rec) {
                    if ($rec['content'] === $content) {
                        $updatedRecords[] = $recordData;
                        $found = true;
                    } else {
                        $updatedRecords[] = $rec;
                    }
                }

                if (!$found) {
                    $updatedRecords[] = $recordData;
                }
            } else {
                $updatedRecords = [$recordData];
            }

            // Actualizează în PowerDNS
            $data = [
                'rrsets' => [
                    [
                        'name' => $fullName,
                        'type' => $localRecord->type,
                        'changetype' => 'REPLACE',
                        'ttl' => $localRecord->ttl,
                        'records' => $updatedRecords
                    ]
                ]
            ];

            $result = $powerDNSService->updateZone($zoneName, $data);

            if ($result && (!is_array($result) || $result['success'] !== false)) {
                \Log::info("Record sincronizat cu succes către PowerDNS: {$localRecord->name} {$localRecord->type}");
            } else {
                throw new \Exception("Eroare actualizare PowerDNS: " . (is_array($result) ? ($result['message'] ?? 'Unknown') : 'Failed'));
            }

        } catch (\Exception $e) {
            \Log::error("Eroare sincronizare directă către PowerDNS: " . $e->getMessage());
            throw $e;
        }
    }

    /**
     * Sincronizează statusul unui record către toate nameserverele atribuite
     */
    private function syncRecordStatusToNameservers($dnsZone, $localRecord, $disabled)
    {
        try {
            \Log::info("=== ÎNCEPE SINCRONIZARE STATUS ===");
            \Log::info("Record: {$localRecord->name} {$localRecord->type}");
            \Log::info("Content: {$localRecord->content}");
            \Log::info("Disabled value: " . ($disabled ? 'TRUE' : 'FALSE'));
            \Log::info("Zone: {$dnsZone->domain}");

            // Sincronizează către TOATE nameserver-ele care au zona, nu doar cel principal
            $activeNameservers = \App\Models\Nameserver::where('is_active', true)->where('status', 'online')->get();
            $syncedNameservers = 0;

            foreach ($activeNameservers as $nameserver) {
                try {
                    // Verifică dacă nameserver-ul are zona
                    $powerDNS = new \App\Services\PowerDNSService($nameserver->api_url, $nameserver->api_key);
                    $zoneResult = $powerDNS->getZone($dnsZone->domain . '.');

                    if ($zoneResult['success']) {
                        \Log::info("Sincronizând către nameserver: {$nameserver->name}");
                        $this->syncRecordStatusToNameserver($dnsZone, $localRecord, $nameserver, $disabled);
                        $syncedNameservers++;
                    } else {
                        \Log::info("Nameserver {$nameserver->name} nu are zona {$dnsZone->domain}");
                    }
                } catch (\Exception $e) {
                    \Log::warning("Nu s-a putut conecta la nameserver {$nameserver->name}: {$e->getMessage()}");
                }
            }

            \Log::info("Sincronizare completă către {$syncedNameservers} nameserver-e");

            \Log::info("=== SINCRONIZARE STATUS COMPLETĂ ===");

        } catch (\Exception $e) {
            \Log::error("Eroare sincronizare status record către nameservere: " . $e->getMessage());
            \Log::error("Stack trace: " . $e->getTraceAsString());
        }
    }

    /**
     * Sincronizează direct statusul unui record către PowerDNS
     */
    private function syncRecordStatusDirectly($dnsZone, $localRecord, $powerDNSService, $disabled)
    {
        try {
            $zoneName = rtrim($dnsZone->domain, '.') . '.';

            // Construiește numele complet al record-ului
            $fullName = $localRecord->name === '@'
                ? $zoneName
                : $localRecord->name . '.' . $zoneName;

            // Construiește content-ul pentru PowerDNS
            $content = $localRecord->content;
            if ($localRecord->type === 'MX' && $localRecord->priority) {
                $content = $localRecord->priority . ' ' . $content;
            }

            // Folosește metoda toggleRecordStatus din PowerDNSService
            $result = $powerDNSService->toggleRecordStatus($zoneName, $fullName, $localRecord->type, $disabled, $content);

            if ($result && (!is_array($result) || $result['success'] !== false)) {
                \Log::info("Status record sincronizat cu succes către PowerDNS: {$localRecord->name} {$localRecord->type} (disabled: {$disabled})");
            } else {
                throw new \Exception("Eroare toggle status PowerDNS: " . (is_array($result) ? ($result['message'] ?? 'Unknown') : 'Failed'));
            }

        } catch (\Exception $e) {
            \Log::error("Eroare sincronizare status către PowerDNS: " . $e->getMessage());
            throw $e;
        }
    }

    /**
     * Sincronizează statusul unui record către un nameserver specific
     */
    private function syncRecordStatusToNameserver($dnsZone, $localRecord, $nameserver, $disabled)
    {
        try {
            $powerDNS = new \App\Services\PowerDNSService($nameserver->api_url, $nameserver->api_key);
            $this->syncRecordStatusDirectly($dnsZone, $localRecord, $powerDNS, $disabled);
        } catch (\Exception $e) {
            \Log::error("Eroare sincronizare status către nameserver {$nameserver->name}: " . $e->getMessage());
        }
    }

    /**
     * Sincronizează un record către un nameserver specific
     */
    private function syncSingleRecordToNameserver($dnsZone, $localRecord, $nameserver)
    {
        try {
            $powerDNS = new \App\Services\PowerDNSService($nameserver->api_url, $nameserver->api_key);
            $this->syncRecordDirectly($dnsZone, $localRecord, $powerDNS);
        } catch (\Exception $e) {
            \Log::error("Eroare sincronizare către nameserver {$nameserver->name}: " . $e->getMessage());
        }
    }

    /**
     * Sincronizează statusul unui record către toate nameserver-ele care au zona
     * Folosește aceeași metodă ca și dezactivarea domeniului - sincronizare directă
     */
    private function syncRecordStatusToAllNameservers($dnsZone, $localRecord, $disabled)
    {
        try {
            \Log::info("=== ÎNCEPE SINCRONIZARE RECORD STATUS DIRECT ===");
            \Log::info("Record: {$localRecord->name} {$localRecord->type}");
            \Log::info("Content: {$localRecord->content}");
            \Log::info("Disabled value: " . ($disabled ? 'TRUE' : 'FALSE'));
            \Log::info("Zone: {$dnsZone->domain}");

            // Găsește toate nameserver-ele active, similar cu dezactivarea domeniului
            $activeNameservers = \App\Models\Nameserver::where('is_active', true)->where('status', 'online')->get();
            $syncedNameservers = 0;

            foreach ($activeNameservers as $nameserver) {
                try {
                    $powerDNS = new \App\Services\PowerDNSService($nameserver->api_url, $nameserver->api_key);

                    // Verifică dacă nameserver-ul are zona
                    $zoneResult = $powerDNS->getZone($dnsZone->domain . '.');

                    if ($zoneResult['success']) {
                        \Log::info("Sincronizând record către nameserver: {$nameserver->name}");

                        // Construiește numele complet al record-ului
                        $fullRecordName = $localRecord->name === '@'
                            ? $dnsZone->domain . '.'
                            : $localRecord->name . '.' . $dnsZone->domain . '.';

                        // Construiește content-ul pentru PowerDNS
                        $content = $localRecord->content;
                        if ($localRecord->type === 'MX' && $localRecord->priority) {
                            $content = $localRecord->priority . ' ' . $content;
                        }

                        // Actualizează direct record-ul în PowerDNS
                        $updateData = [
                            'rrsets' => [
                                [
                                    'name' => $fullRecordName,
                                    'type' => $localRecord->type,
                                    'changetype' => 'REPLACE',
                                    'ttl' => $localRecord->ttl ?: 86400,
                                    'records' => [
                                        [
                                            'content' => $content,
                                            'disabled' => $disabled
                                        ]
                                    ]
                                ]
                            ]
                        ];

                        $updateResponse = $powerDNS->updateZone($dnsZone->domain . '.', $updateData);

                        if ($updateResponse['success']) {
                            \Log::info("Record sincronizat cu succes către nameserver {$nameserver->name}");
                            $syncedNameservers++;
                        } else {
                            \Log::error("Eroare sincronizare record către {$nameserver->name}: " . ($updateResponse['error'] ?? 'Unknown'));
                        }
                    } else {
                        \Log::info("Nameserver {$nameserver->name} nu are zona {$dnsZone->domain}");
                    }
                } catch (\Exception $e) {
                    \Log::error("Eroare conectare la nameserver {$nameserver->name}: {$e->getMessage()}");
                }
            }

            \Log::info("Sincronizare record completă către {$syncedNameservers} nameserver-e");
            \Log::info("=== SINCRONIZARE RECORD STATUS COMPLETĂ ===");

            return $syncedNameservers;

        } catch (\Exception $e) {
            \Log::error("Eroare sincronizare record status către nameservere: " . $e->getMessage());
            \Log::error("Stack trace: " . $e->getTraceAsString());
            return 0;
        }
    }

    /**
     * Verifică dacă utilizatorul are acces la o zonă PowerDNS
     */
    private function checkZoneAccess($zoneName, $requiredAccessLevels = ['full', 'records_only'])
    {
        $user = Auth::user();

        $assignment = DnsZoneAssignment::where('user_id', $user->id)
            ->where(function ($query) use ($zoneName) {
                $query->where('zone_name', $zoneName)
                      ->orWhere('zone_name', $zoneName . '.')
                      ->orWhere('zone_name', rtrim($zoneName, '.'));
            })
            ->whereIn('access_level', $requiredAccessLevels)
            ->first();

        return $assignment;
    }

    /**
     * Afișează zonele PowerDNS atribuite utilizatorului
     */
    public function index()
    {
        $user = Auth::user();

        // Obține zonele atribuite acestui utilizator
        $assignments = DnsZoneAssignment::where('user_id', $user->id)
            ->with('assignedByUser')
            ->get();

        $assignedZones = collect();

        foreach ($assignments as $assignment) {
            // Cache pentru performanță
            $cacheKey = "powerdns_user_zone_{$assignment->zone_name}";

            $zoneDetails = cache()->remember($cacheKey, 300, function() use ($assignment) {
                $powerDNSService = $this->getPowerDNSForZone($assignment->zone_name);
                return $powerDNSService->getZone($assignment->zone_name);
            });

            if ($zoneDetails['success']) {
                $zone = $zoneDetails['data'];
                $zone['assignment'] = $assignment;
                $zone['records_count'] = count($zone['rrsets'] ?? []);
                $zone['zone_id'] = $assignment->zone_name;
                $assignedZones->push($zone);
            }
        }

        return view('powerdns.user.index', [
            'zones' => $assignedZones,
            'user' => $user
        ]);
    }

    /**
     * Afișează detaliile unei zone PowerDNS
     */
    public function show($zoneId)
    {
        $user = Auth::user();

        // Verifică dacă utilizatorul are acces la această zonă
        $assignment = DnsZoneAssignment::where('user_id', $user->id)
            ->where('zone_name', $zoneId)
            ->first();

        if (!$assignment) {
            return redirect()->route('powerdns.user.index')
                ->with('error', 'Nu ai acces la această zonă DNS');
        }

        // Obține detaliile zonei
        $powerDNSService = $this->getPowerDNSForZone($zoneId);
        $zoneResult = $powerDNSService->getZone($zoneId);

        if (!$zoneResult['success']) {
            return redirect()->route('powerdns.user.index')
                ->with('error', $zoneResult['error'] ?? 'Zona nu a fost găsită');
        }

        $zone = $zoneResult['data'];
        $zone['assignment'] = $assignment;
        $records = $zone['rrsets'] ?? [];

                $changelog = $changes;
        return view('powerdns.records.changelog', compact('zoneName', 'recordName', 'changelog', 'debugRecords'));
    }

    /**
     * Gestionează înregistrările DNS (doar pentru utilizatori cu acces)
     */
    public function records($zoneId)
    {
        $user = Auth::user();

        // Verifică accesul
        $assignment = DnsZoneAssignment::where('user_id', $user->id)
            ->where('zone_name', $zoneId)
            ->first();

        if (!$assignment || !in_array($assignment->access_level, ['full', 'records_only'])) {
            return redirect()->route('powerdns.user.index')
                ->with('error', 'Nu ai permisiunea să gestionezi înregistrările pentru această zonă');
        }

        // Obține zonele și înregistrările
        $powerDNSService = $this->getPowerDNSForZone($zoneId);
        $zoneResult = $powerDNSService->getZone($zoneId);

        if (!$zoneResult['success']) {
            return redirect()->route('powerdns.user.index')
                ->with('error', $zoneResult['error'] ?? 'Zona nu a fost găsită');
        }

        $zone = $zoneResult['data'];
        $zone['assignment'] = $assignment;
        $records = $zone['rrsets'] ?? [];

        return view('powerdns.user.records', compact('zone', 'records', 'zoneId', 'assignment'));
    }

    /**
     * Șterge o înregistrare DNS
     */
    public function deleteRecord(Request $request, $zoneName, $recordName)
    {
        $user = Auth::user();

        // Admin-ii au acces la toate zonăle
        if (!$user->isAdmin()) {
            // Verifică dacă este zonă locală cu PowerDNS
            $localZone = \App\Models\DnsZone::where('domain', rtrim($zoneName, '.'))
                ->where('user_id', $user->id)
                ->first();

            if (!$localZone) {
                // Nu e zonă locală, verifică assignment
                $assignment = $this->checkZoneAccess($zoneName);
                if (!$assignment) {
                    return redirect()->back()
                        ->with('error', 'Nu ai permisiunea să ștergi înregistrări pentru această zonă');
                }
            }
        }

        $request->validate([
            'type' => 'required|string',
            'content' => 'nullable|string',
        ]);

        $recordType = $request->input('type');
        $specificContent = $request->input('content');

        // Nu permite ștergerea înregistrărilor SOA sau NS de către utilizatori non-admin
        if (in_array($recordType, ['SOA', 'NS']) && !$user->isAdmin()) {
            return redirect()->back()
                ->with('error', 'Doar administratorii pot șterge înregistrări ' . $recordType);
        }

        // Obține înregistrare info before deletion fsau logging
        $powerDNSService = $this->getPowerDNSForZone($zoneName);
        $recordsResponse = $powerDNSService->getRecords($zoneName);
        $rrset = null;

        if ($recordsResponse['success']) {
            $records = $recordsResponse['data'];
            $rrset = collect($records)->first(function ($r) use ($recordName, $recordType) {
                $nameMatch = $r['name'] === $recordName || $r['name'] === rtrim($recordName, '.') . '.';
                return $nameMatch && $r['type'] === $recordType;
            });
        }

        if (!$rrset) {
            return redirect()->back()
                ->with('error', 'Înregistrarea nu a fost găsită');
        }

        // Dacă avem content specific și RRset-ul are multiple înregistrări, șterge doar pe cea specifică
        if ($specificContent && isset($rrset['records']) && count($rrset['records']) > 1) {
            \Log::info('Delete record debug', [
                'specificContent' => $specificContent,
                'recordType' => $recordType,
                'rrset_records' => array_map(fn($r) => $r['content'], $rrset['records'])
            ]);

            // Pentru MX, conținut-ul poate include priority
            // Ex: view trimite "mail.back.ro", dar PowerDNS are "3 mail.back.ro"
            $remainingRecords = array_filter($rrset['records'], function($rec) use ($specificContent, $recordType) {
                $recContent = $rec['content'];

                // Pentru MX, compară doar partea de target (fără priority)
                if ($recordType === 'MX') {
                    // Extrage target-ul din "priority target"
                    $parts = explode(' ', $recContent, 2);
                    if (count($parts) === 2) {
                        $recContent = $parts[1];
                    }

                    // Extrage target-ul din specificContent dacă include priority
                    $specParts = explode(' ', $specificContent, 2);
                    $specContent = count($specParts) === 2 ? $specParts[1] : $specificContent;

                    // Normalizează punctele finale
                    $recContent = rtrim($recContent, '.');
                    $specContent = rtrim($specContent, '.');

                    return $recContent !== $specContent;
                }

                // Pentru alte tipuri, normalizează punctele finale
                $recContent = rtrim($recContent, '.');
                $specContent = rtrim($specificContent, '.');

                return $recContent !== $specContent;
            });

            if (count($remainingRecords) === count($rrset['records'])) {
                return redirect()->back()
                    ->with('error', 'Înregistrarea specificată nu a fost găsită în RRset');
            }

            // Actualizează RRset-ul cu înregistrările rămase
            $data = [
                'rrsets' => [
                    [
                        'name' => $rrset['name'],
                        'type' => $recordType,
                        'changetype' => 'REPLACE',
                        'ttl' => $rrset['ttl'] ?? 3600,
                        'records' => array_values($remainingRecords)
                    ]
                ]
            ];

            $result = $powerDNSService->updateZone($zoneName, $data);

            // Log deletion
            $this->logRecordChange($zoneName, $recordName, $recordType, 'delete', [
                'old_content' => $specificContent,
                'old_ttl' => $rrset['ttl'] ?? 3600
            ]);
        } else {
            // Șterge tot RRset-ul (comportament vechi sau ultimă înregistrare)
            $result = $powerDNSService->deleteRecord(
                $zoneName,
                $rrset['name'],
                $recordType
            );

            // Log deletion
            $this->logRecordChange($zoneName, $recordName, $recordType, 'delete', [
                'old_content' => implode(' ', array_column($rrset['records'] ?? [], 'content')),
                'old_ttl' => $rrset['ttl'] ?? 3600
            ]);
        }

        if (!$result || (is_array($result) && !$result['success'])) {
            // Dacă ștergerea de pe nameserverul asignat a eșuat, încearcă pe toate nameserverele
            $this->deleteRecordFromAllNameservers($zoneName, $recordName, $recordType, $specificContent);
        } else {
            // Dacă ștergerea de pe nameserverul asignat a avut succes, șterge și din celelalte
            $this->deleteRecordFromAllNameservers($zoneName, $recordName, $recordType, $specificContent);
        }

        // Șterge și din baza de date locală dacă există
        $this->deleteFromLocalDatabase($zoneName, $recordName, $recordType, $user->id);

        return redirect()->route('dns-zones.show', $zoneName)
            ->with('success', 'Înregistrarea a fost ștearsă cu succes din toate nameserverele disponibile');
    }

    /**
     * Afișează formularul pentru editarea unei înregistrări PowerDNS
     */
    public function editRecord(Request $request, $zoneName, $recordName, $recordType)
    {
        $user = Auth::user();

        // Verifică dacă încearcă să editeze SOA sau NS fără să fie admin
        if (in_array($recordType, ['SOA', 'NS']) && !$user->isAdmin()) {
            abort(403, 'Doar administratorii pot edita înregistrări ' . $recordType);
        }

        // Admin-ii au acces la toate zonăle
        if (!$user->isAdmin()) {
            // Verifică dacă este zonă locală cu PowerDNS
            $localZone = \App\Models\DnsZone::where('domain', rtrim($zoneName, '.'))
                ->where('user_id', $user->id)
                ->first();

            if (!$localZone) {
                // Nu e zonă locală, verifică assignment
                $assignment = $this->checkZoneAccess($zoneName);
                if (!$assignment) {
                    abort(403, 'Nu aveți permisiunea să accesați această zonă');
                }
            }
        }

        // Găsește PowerDNS service-ul corect pentru această zonă
        $powerDNSService = $this->getPowerDNSForZone($zoneName);

        // Obține detaliile înregistrării din PowerDNS
        $zoneResponse = $powerDNSService->getZone($zoneName);
        if (!$zoneResponse['success']) {
            abort(404, 'Zona PowerDNS nu a fost găsită: ' . ($zoneResponse['error'] ?? 'Eroare necunoscută'));
        }

        $zone = $zoneResponse['data'];

        $recordsResponse = $powerDNSService->getRecords($zoneName);

        if (!$recordsResponse['success']) {
            abort(500, 'Eroare la obținerea înregistrărilor din PowerDNS');
        }

        $records = $recordsResponse['data'];

        // Căutare RRset după nume și tip
        $rrset = collect($records)->first(function ($r) use ($recordName, $recordType) {
            // Verifică atât numele cât și tipul
            $nameMatch = $r['name'] === $recordName || $r['name'] === rtrim($recordName, '.') . '.';
            $typeMatch = $r['type'] === $recordType;
            return $nameMatch && $typeMatch;
        });

        if (!$rrset) {
            abort(404, 'Înregistrarea "' . $recordName . '" nu a fost găsită în zona "' . $zoneName . '"');
        }

        // Dacă avem parametrul content, găsește înregistrarea specifică din RRset
        $specificContent = $request->query('content');
        $record = $rrset;

        if ($specificContent && isset($rrset['records']) && count($rrset['records']) > 1) {
            // Găsește înregistrarea specifică din RRset
            $specificRecord = collect($rrset['records'])->first(function($r) use ($specificContent) {
                return $r['content'] === $specificContent;
            });

            if ($specificRecord) {
                // Creează un RRset cu doar această înregistrare pentru editare
                $record = $rrset;
                $record['specific_content'] = $specificContent;
                $record['editing_single'] = true;
            }
        }

        // Încarcă notițele din metadata
        // Normalizează zone_name cu punct la sfârșit pentru consistență
        $normalizedZoneName = rtrim($zoneName, '.') . '.';
        $metadata = PowerDnsRecordMetadata::where('zone_name', $normalizedZoneName)
            ->where('record_name', $record['name'])
            ->where('record_type', $record['type'])
            ->first();

        $record['notes'] = $metadata ? $metadata->notes : null;

        return view('powerdns.records.edit', compact('zone', 'record', 'zoneName'));
    }

    /**
     * Actualizează o înregistrare PowerDNS
     */
    public function updateRecord(Request $request, $zoneName, $recordName, $recordType)
    {
        $user = Auth::user();

        // Verifică dacă încearcă să actualizeze SOA sau NS fără să fie admin
        if (in_array($recordType, ['SOA', 'NS']) && !$user->isAdmin()) {
            abort(403, 'Doar administratorii pot actualiza înregistrări ' . $recordType);
        }

        // Admin-ii au acces la toate zonăle
        if (!$user->isAdmin()) {
            // Verifică dacă este zonă locală cu PowerDNS
            $localZone = \App\Models\DnsZone::where('domain', rtrim($zoneName, '.'))
                ->where('user_id', $user->id)
                ->first();

            if (!$localZone) {
                // Nu e zonă locală, verifică assignment
                $assignment = $this->checkZoneAccess($zoneName);
                if (!$assignment) {
                    abort(403, 'Nu aveți permisiunea să accesați această zonă');
                }
            }
        }

        $request->validate([
            'name' => 'required|string',
            'type' => 'required|string|in:A,AAAA,CNAME,MX,TXT,NS,PTR,SRV',
            'content' => 'required|string',
            'ttl' => 'required|integer|min:1|max:86400',
            'notes' => 'nullable|string|max:1000',
            'old_content' => 'nullable|string',
        ]);

        // Obține RRset-ul existent
        $powerDNSService = $this->getPowerDNSForZone($zoneName);
        $recordsResponse = $powerDNSService->getRecords($zoneName);

        if (!$recordsResponse['success']) {
            return redirect()->back()->with('error', 'Eroare la obținerea înregistrărilor');
        }

        $records = $recordsResponse['data'];
        $rrset = collect($records)->first(function ($r) use ($recordName, $recordType) {
            $nameMatch = $r['name'] === $recordName || $r['name'] === rtrim($recordName, '.') . '.';
            $typeMatch = $r['type'] === $recordType;
            return $nameMatch && $typeMatch;
        });

        if (!$rrset) {
            return redirect()->back()
                ->with('error', 'Înregistrarea nu a fost găsită')
                ->withInput();
        }

        $oldContent = $request->input('old_content');
        $newContent = $request->input('content');
        $newTtl = $request->input('ttl');

        // Construiește lista de înregistrări actualizate
        $updatedRecords = [];

        if ($oldContent && isset($rrset['records'])) {
            // Editează doar înregistrarea specifică din RRset
            foreach ($rrset['records'] as $rec) {
                if ($rec['content'] === $oldContent) {
                    // Înlocuiește cu noua valoare
                    $updatedRecords[] = [
                        'content' => $newContent,
                        'disabled' => $rec['disabled'] ?? false,
                    ];
                } else {
                    // Păstrează înregistrarea neschimbată
                    $updatedRecords[] = $rec;
                }
            }
        } else {
            // Înlocuiește tot RRset-ul (comportament vechi)
            $updatedRecords[] = [
                'content' => $newContent,
                'disabled' => false,
            ];
        }

        // ARHITECTURA CENTRALIZATĂ: Salvează în baza de date locală
        try {
            // Găsește zona locală
            $dnsZone = \App\Models\DnsZone::where('domain', rtrim($zoneName, '.'))->first();

            if (!$dnsZone) {
                return redirect()->back()
                    ->with('error', 'Zona DNS nu a fost găsită în baza de date locală')
                    ->withInput();
            }

            // Normalizează numele pentru căutarea în baza de date
            $localRecordName = rtrim($rrset['name'], '.');
            $domain = rtrim($dnsZone->domain, '.');

            if ($localRecordName === $domain) {
                $localRecordName = '@';
            } elseif (str_ends_with($localRecordName, '.' . $domain)) {
                $localRecordName = substr($localRecordName, 0, -(strlen($domain) + 1));
            }

            // Găsește record-ul local care trebuie actualizat
            $localRecord = \App\Models\DnsRecord::where('dns_zone_id', $dnsZone->id)
                ->where('name', $localRecordName)
                ->where('type', $recordType)
                ->where('content', $oldContent)
                ->first();

            if (!$localRecord) {
                return redirect()->back()
                    ->with('error', 'Record-ul nu a fost găsit în baza de date locală pentru actualizare')
                    ->withInput();
            }

            // Actualizează record-ul local
            $localRecord->content = $newContent;
            $localRecord->ttl = $newTtl;
            if ($request->has('notes')) {
                $localRecord->notes = $request->input('notes');
            }
            $localRecord->save();

            // Trigger sincronizarea către nameservere (implementare ulterioară)
            $this->syncRecordToNameservers($dnsZone, $localRecord);

        } catch (\Exception $e) {
            return redirect()->back()
                ->with('error', 'Eroare la salvarea în baza de date locală: ' . $e->getMessage())
                ->withInput();
        }

        // Salvează notițele în metadata
        if ($request->has('notes')) {
            // Normalizează zone_name cu punct la sfârșit pentru consistență
            $normalizedZoneName = rtrim($zoneName, '.') . '.';
            $metadata = PowerDnsRecordMetadata::getOrCreate($normalizedZoneName, $rrset['name'], $recordType);
            $metadata->notes = $request->input('notes');
            $metadata->save();
        }

        // Log update
        $this->logRecordChange($zoneName, $rrset['name'], $recordType, 'update', [
            'old_content' => $oldContent,
            'new_content' => $newContent,
            'old_ttl' => $rrset['ttl'] ?? 3600,
            'new_ttl' => $newTtl,
            'old_name' => $recordName,
            'new_name' => $request->input('name'),
            'old_type' => $recordType,
            'new_type' => $request->input('type')
        ]);

        return redirect()->route('dns-zones.show', $zoneName)
            ->with('success', 'Înregistrarea a fost actualizată cu succes');
    }

    /**
     * Afișează formularul pentru crearea unei înregistrări PowerDNS
     */
    public function createRecord($zoneName)
    {
        $user = Auth::user();

        // Admin-ii au acces la toate zonăle
        if (!$user->isAdmin()) {
            // Verifică dacă utilizatorul are acces la această zonă
            $assignment = $this->checkZoneAccess($zoneName);

            if (!$assignment) {
                abort(403, 'Nu aveți permisiunea să accesați această zonă');
            }
        }

        $powerDNSService = $this->getPowerDNSForZone($zoneName);
        $zone = $powerDNSService->getZone($zoneName);
        if (!$zone) {
            abort(404, 'Zona PowerDNS nu a fost găsită');
        }

        return view('powerdns.records.create', compact('zone', 'zoneName'));
    }

    /**
     * Salvează o nouă înregistrare PowerDNS
     */
    public function storeRecord(Request $request, $zoneName)
    {
        $user = Auth::user();

        // Admin-ii au acces la toate zonăle
        if (!$user->isAdmin()) {
            // Verifică dacă este zonă locală cu PowerDNS
            $localZone = \App\Models\DnsZone::where('domain', rtrim($zoneName, '.'))
                ->where('user_id', $user->id)
                ->first();

            if (!$localZone) {
                // Nu e zonă locală, verifică assignment
                $assignment = $this->checkZoneAccess($zoneName);
                if (!$assignment) {
                    abort(403, 'Nu aveți permisiunea să accesați această zonă');
                }
            }
        }

        // Verifică limita de subdomenii
        if (!$user->canAddSubdomain()) {
            return redirect()->back()
                ->with('error', 'Ai atins limita de înregistrări DNS pentru planul tău.')
                ->withInput();
        }

        $request->validate([
            'name' => 'required|string',
            'type' => 'required|string|in:A,AAAA,CNAME,MX,TXT,NS,PTR,SRV',
            'content' => 'required|string',
            'ttl' => 'required|integer|min:1|max:86400',
            'notes' => 'nullable|string|max:1000',
        ]);

        // Construiește numele complet pentru PowerDNS (FQDN)
        $recordName = $request->input('name');

        // Dacă numele este '@', folosește zona direct
        if ($recordName === '@') {
            $fullName = rtrim($zoneName, '.') . '.';
        } else {
            // Construiește FQDN: nume.zona.
            $fullName = $recordName . '.' . rtrim($zoneName, '.') . '.';
        }

        // Creează înregistrarea în PowerDNS
        Log::info('Creating PowerDNS record', [
            'zone' => $zoneName,
            'fullName' => $fullName,
            'type' => $request->input('type'),
            'content' => $request->input('content'),
            'ttl' => $request->input('ttl')
        ]);

        $result = $powerDNSService->addRecord(
            $zoneName,
            $fullName,
            $request->input('type'),
            $request->input('content'),
            $request->input('ttl')
        );

        if (!$result || (is_array($result) && !$result['success'])) {
            $errorMessage = 'Eroare la crearea înregistrării în PowerDNS';
            if (is_array($result) && isset($result['error'])) {
                $errorMessage .= ': ' . $result['error'];
            }

            Log::error('Failed to create PowerDNS record', [
                'zone' => $zoneName,
                'fullName' => $fullName,
                'result' => $result
            ]);

            return redirect()->back()
                ->with('error', $errorMessage)
                ->withInput();
        }

        // Salvează notițele în metadata
        if ($request->has('notes')) {
            // Normalizează zone_name cu punct la sfârșit pentru consistență
            $normalizedZoneName = rtrim($zoneName, '.') . '.';
            $metadata = PowerDnsRecordMetadata::getOrCreate($normalizedZoneName, $fullName, $request->input('type'));
            $metadata->notes = $request->input('notes');
            $metadata->save();
        }

        // Log creation
        $this->logRecordChange($zoneName, $fullName, $request->input('type'), 'create', [
            'new_content' => $request->input('content'),
            'new_ttl' => $request->input('ttl'),
            'new_disabled' => false
        ]);

        return redirect()->route('dns-zones.show', $zoneName)
            ->with('success', 'Înregistrarea a fost creată cu succes');
    }

    /**
     * Afișează changelog-ul pentru o înregistrare PowerDNS
     */
    public function recordChangelog(Request $request, $zoneName, $recordName)
    {
        $user = Auth::user();

        // Admin-ii au acces la toate zonăle
        if (!$user->isAdmin()) {
            // Verifică dacă este zonă locală cu PowerDNS
            $localZone = \App\Models\DnsZone::where('domain', rtrim($zoneName, '.'))
                ->where('user_id', $user->id)
                ->first();

            if (!$localZone) {
                // Nu e zonă locală, verifică assignment
                $assignment = $this->checkZoneAccess($zoneName);
                if (!$assignment) {
                    abort(403, 'Nu aveți permisiunea să accesați această zonă');
                }
            }
        }

        // Obține conținutul specific din query string (dacă există)
        $specificContent = $request->query('content');

        $changelogQuery = PowerDnsChangelog::forRecord($zoneName, $recordName);

        // Dacă avem conținut specific, filtrează și după el
        if ($specificContent) {
            $changelogQuery->where(function($q) use ($specificContent) {
                // Filtrează după old_content SAU new_content
                // Pentru a prinde toate modificările legate de acel conținut
                $q->where('old_content', $specificContent)
                  ->orWhere('new_content', $specificContent);
            });
        }

        $changelog = $changelogQuery
            ->with('user')
            ->orderBy('created_at', 'desc')
            ->paginate(20);

        return view('powerdns.records.changelog', compact('zoneName', 'recordName', 'changelog', 'specificContent'));
    }

    /**
     * Afișează jurnalul de activitate complet al utilizatorului
     */
    public function activityLog()
    {
        $user = Auth::user();

        $activities = PowerDnsChangelog::where('user_id', $user->id)
            ->with('user')
            ->orderBy('created_at', 'desc')
            ->paginate(50);

        return view('powerdns.activity-log', compact('activities'));
    }

    /**
     * Toggle status pentru o înregistrare PowerDNS
     */
    public function toggleRecordStatus(Request $request, $zoneName, $recordName)
    {
        $user = Auth::user();

        // Admin-ii au acces la toate zonăle
        if (!$user->isAdmin()) {
            // Verifică dacă este zonă locală cu PowerDNS
            $localZone = \App\Models\DnsZone::where('domain', rtrim($zoneName, '.'))
                ->where('user_id', $user->id)
                ->first();

            if (!$localZone) {
                // Nu e zonă locală, verifică assignment
                $assignment = $this->checkZoneAccess($zoneName);
                if (!$assignment) {
                    return redirect()->back()->with('error', 'Nu aveți permisiunea să modificați această zonă');
                }
            }
        }

        $request->validate([
            'type' => 'required|string',
            'disabled' => 'required|boolean',
            'content' => 'nullable|string'
        ]);

        $recordType = $request->input('type');
        $disabled = $request->boolean('disabled');
        $specificContent = $request->input('content');

        // ARHITECTURA CENTRALIZATĂ: Modifică în baza de date locală
        try {
            // Găsește zona locală
            $dnsZone = \App\Models\DnsZone::where('domain', rtrim($zoneName, '.'))->first();

            if (!$dnsZone) {
                return redirect()->back()->with('error', 'Zona DNS nu a fost găsită în baza de date locală');
            }

            // Normalizează numele pentru căutarea în baza de date
            $localRecordName = rtrim($recordName, '.');
            $domain = rtrim($dnsZone->domain, '.');

            if ($localRecordName === $domain) {
                $localRecordName = '@';
            } elseif (str_ends_with($localRecordName, '.' . $domain)) {
                $localRecordName = substr($localRecordName, 0, -(strlen($domain) + 1));
            }

            // Găsește record-ul local care trebuie modificat
            $query = \App\Models\DnsRecord::where('dns_zone_id', $dnsZone->id)
                ->where('name', $localRecordName)
                ->where('type', $recordType);

            // Dacă e specificat content specific, filtrează și după content
            if ($specificContent) {
                $query->where('content', $specificContent);
            }

            $localRecord = $query->first();

            if (!$localRecord) {
                // Debug info pentru troubleshooting
                $availableRecords = \App\Models\DnsRecord::where('dns_zone_id', $dnsZone->id)
                    ->where('name', $localRecordName)
                    ->get()
                    ->map(function($r) {
                        return $r->name . ' (' . $r->type . ') = ' . $r->content;
                    })->implode(', ');

                return redirect()->back()->with('error',
                    "Record-ul nu a fost găsit în baza de date locală. Căutam: {$localRecordName} ({$recordType})" .
                    ($specificContent ? " cu content: {$specificContent}" : '') .
                    ". Disponibile: " . ($availableRecords ?: 'niciunul')
                );
            }

            // Modifică statusul în baza de date locală
            $oldStatus = $localRecord->is_active;
            $localRecord->is_active = !$disabled; // disabled = true înseamnă is_active = false
            $localRecord->save();

            // SINCRONIZARE DIRECTĂ PE NAMESERVERE (similar cu dezactivarea domeniului)
            $this->syncRecordStatusToAllNameservers($dnsZone, $localRecord, $disabled);

        } catch (\Exception $e) {
            return redirect()->back()->with('error', 'Eroare la modificarea statusului în baza de date locală: ' . $e->getMessage());
        }

        // Log change
        $action = $disabled ? 'deactivate' : 'activate';
        $this->logRecordChange($zoneName, $localRecord->name, $recordType, $action, [
            'old_disabled' => $oldStatus ? false : true, // Inversează pentru că is_active != disabled
            'new_disabled' => $disabled,
            'new_content' => $localRecord->content,
            'new_ttl' => $localRecord->ttl
        ]);

        $statusText = $disabled ? 'dezactivată' : 'activată';
        return redirect()->back()->with('success', "Înregistrarea a fost {$statusText} cu succes");
    }

    /**
     * Restaurează o înregistrare la o versiune anterioară din changelog
     */
    public function restoreRecord($zoneName, $recordName, $changelogId)
    {
        $user = Auth::user();

        // Verifică accesul la zonă
        if (!$user->isAdmin()) {
            $localZone = \App\Models\DnsZone::where('domain', rtrim($zoneName, '.'))
                ->where('user_id', $user->id)
                ->first();

            if (!$localZone) {
                $assignment = $this->checkZoneAccess($zoneName);
                if (!$assignment) {
                    abort(403, 'Nu ai permisiunea să accesezi această zonă DNS.');
                }
            }
        }

        // Găsește intrarea din changelog
        $changelog = PowerDnsChangelog::findOrFail($changelogId);

        // Normalizează numele pentru comparare
        $normalizedZoneName = rtrim($zoneName, '.') . '.';
        $normalizedRecordName = rtrim($recordName, '.');
        $normalizedChangelogZone = rtrim($changelog->zone_name, '.') . '.';
        $normalizedChangelogRecord = rtrim($changelog->record_name, '.');

        // Pentru @ (domeniul principal), record_name poate fi zona completă
        if ($normalizedRecordName === '@' || $normalizedRecordName === rtrim($zoneName, '.')) {
            $normalizedRecordName = rtrim($zoneName, '.');
        }
        if ($normalizedChangelogRecord === '@' || $normalizedChangelogRecord === rtrim($zoneName, '.')) {
            $normalizedChangelogRecord = rtrim($zoneName, '.');
        }

        // Verifică că changelog-ul aparține acestei înregistrări
        if ($normalizedChangelogZone !== $normalizedZoneName ||
            $normalizedChangelogRecord !== $normalizedRecordName) {
            \Log::warning('Changelog mismatch', [
                'changelog_zone' => $normalizedChangelogZone,
                'expected_zone' => $normalizedZoneName,
                'changelog_record' => $normalizedChangelogRecord,
                'expected_record' => $normalizedRecordName,
                'original_record_name' => $recordName,
                'original_changelog_record' => $changelog->record_name
            ]);
            abort(403, 'Changelog-ul nu corespunde înregistrării.');
        }

        // Nu permite restaurarea pentru înregistrări șterse
        if ($changelog->action === 'delete') {
            return redirect()->back()->with('error', 'Nu poți restaura o înregistrare ștearsă.');
        }

        // Verifică că există date vechi pentru restaurare
        if (!$changelog->old_content && !$changelog->old_ttl) {
            return redirect()->back()->with('error', 'Nu există date pentru restaurare.');
        }

        // Construiește numele complet pentru PowerDNS
        $normalizedRecordName = rtrim($recordName, '.');
        $normalizedZoneName = rtrim($zoneName, '.');

        // Verifică dacă recordName conține deja zona
        if (str_ends_with($normalizedRecordName, '.' . $normalizedZoneName)) {
            // înregistrare nume este deja FQDN (ex: mail.118.ro)
            $recordNameForPowerDNS = $normalizedRecordName . '.';
        } elseif ($normalizedRecordName === $normalizedZoneName) {
            // înregistrare nume este zona (pentru @)
            $recordNameForPowerDNS = $normalizedZoneName . '.';
        } else {
            // înregistrare nume este doar subdomeniul (ex: mail)
            $recordNameForPowerDNS = $normalizedRecordName . '.' . $normalizedZoneName . '.';
        }

        \Log::info('Restore record - names', [
            'recordName' => $recordName,
            'zoneName' => $zoneName,
            'recordNameForPowerDNS' => $recordNameForPowerDNS,
            'changelog_type' => $changelog->record_type
        ]);

        // Obține toate înregistrările din zonă
        $powerDNSService = $this->getPowerDNSForZone($normalizedZoneName);
        $allRecords = $powerDNSService->getRecords($normalizedZoneName . '.');

        if (!$allRecords || !isset($allRecords['success']) || !$allRecords['success']) {
            return redirect()->back()->with('error', 'Nu s-au putut obține înregistrările din PowerDNS.');
        }

        // Găsește înregistrarea curentă
        $currentRecord = null;
        foreach ($allRecords['data'] as $rrset) {
            \Log::debug('Checking rrset', [
                'rrset_name' => $rrset['name'],
                'rrset_type' => $rrset['type'],
                'looking_for_name' => $recordNameForPowerDNS,
                'looking_for_type' => $changelog->record_type
            ]);

            if ($rrset['name'] === $recordNameForPowerDNS && $rrset['type'] === $changelog->record_type) {
                $currentRecord = $rrset;
                break;
            }
        }

        if (!$currentRecord) {
            \Log::error('Record not found in PowerDNS', [
                'looking_for' => $recordNameForPowerDNS,
                'type' => $changelog->record_type,
                'available_records' => array_map(function($r) {
                    return $r['name'] . ' (' . $r['type'] . ')';
                }, $allRecords['data'])
            ]);
            return redirect()->back()->with('error', 'Înregistrarea nu a fost găsită în PowerDNS.');
        }

        // Pregătește datele pentru restaurare
        $restoreContent = $changelog->old_content;
        $restoreTtl = $changelog->old_ttl ?? 3600;

        // Pentru MX, verifică dacă content-ul include prioritatea
        if ($changelog->record_type === 'MX' && !preg_match('/^\d+\s/', $restoreContent)) {
            // Dacă nu are prioritate, adaugă una default
            $restoreContent = '10 ' . $restoreContent;
        }

        // Păstrează toate înregistrările existente și modifică doar pe cea curentă
        $allRecords = [];
        $foundAndReplaced = false;

        // Cazul 1: Dacă există doar o înregistrare, restaurăm pe aceea
        if (count($currentRecord['records']) === 1) {
            $allRecords[] = [
                'content' => $restoreContent,
                'disabled' => $changelog->old_disabled ?? false
            ];
            $foundAndReplaced = true;
            \Log::info('Restore: Single record found, replacing it', [
                'old_content' => $currentRecord['records'][0]['content'],
                'new_content' => $restoreContent
            ]);
        } else {
            // Cazul 2: Multiple înregistrări - căutăm după new_content
            foreach ($currentRecord['records'] as $record) {
                // Găsește înregistrarea care trebuie restaurată (pe baza conținutului nou)
                if ($record['content'] === $changelog->new_content) {
                    // Înlocuiește cu conținutul vechi (restaurat)
                    $allRecords[] = [
                        'content' => $restoreContent,
                        'disabled' => $changelog->old_disabled ?? false
                    ];
                    $foundAndReplaced = true;
                    \Log::info('Restore: Found matching record by new_content', [
                        'matched_content' => $record['content'],
                        'restored_to' => $restoreContent
                    ]);
                } else {
                    // Păstrează celelalte înregistrări neschimbate
                    $allRecords[] = [
                        'content' => $record['content'],
                        'disabled' => $record['disabled'] ?? false
                    ];
                }
            }
        }

        // Cazul 3: Dacă nu am găsit înregistrarea (poate a fost ștearsă între timp), adaugă-o
        if (!$foundAndReplaced) {
            $allRecords[] = [
                'content' => $restoreContent,
                'disabled' => $changelog->old_disabled ?? false
            ];
            \Log::info('Restore: Record not found, adding it', [
                'added_content' => $restoreContent
            ]);
        }

        // Actualizează înregistrarea în PowerDNS cu TOATE records
        $rrsets = [
            [
                'name' => $recordNameForPowerDNS,
                'type' => $changelog->record_type,
                'ttl' => $restoreTtl,
                'changetype' => 'REPLACE',
                'records' => $allRecords
            ]
        ];

        $result = $powerDNSService->updateZone(rtrim($zoneName, '.') . '.', ['rrsets' => $rrsets]);

        if (!$result || !isset($result['success']) || !$result['success']) {
            return redirect()->back()->with('error', 'Eroare la restaurarea înregistrării în PowerDNS.');
        }

        // Log restore action
        $this->logRecordChange($zoneName, $recordNameForPowerDNS, $changelog->record_type, 'restore', [
            'old_content' => $currentRecord['records'][0]['content'] ?? null,
            'new_content' => $restoreContent,
            'old_ttl' => $currentRecord['ttl'] ?? null,
            'new_ttl' => $restoreTtl,
            'restored_from' => $changelogId
        ]);

        return redirect()->route('powerdns.records.changelog', [$zoneName, $recordName])
            ->with('success', 'Înregistrarea a fost restaurată cu succes la versiunea din ' . $changelog->created_at->format('d.m.Y H:i:s'));
    }

    /**
     * Helper method pentru logging modificărilor de înregistrări
     */
    private function logRecordChange($zoneName, $recordName, $recordType, $action, $data = [])
    {
        $this->logAction($action, $zoneName, $recordName, $recordType, $data);
    }

    /**
     * Helper method general pentru logging toate acțiunile
     */
    private function logAction($action, $zoneName = null, $recordName = null, $recordType = null, $data = [])
    {
        $user = Auth::user();

        // Detectează IP-ul real, chiar și prin proxy
        $realIp = request()->ip();
        if ($realIp === '::1' || $realIp === '127.0.0.1') {
            // Pentru development local, încearcă să găsească IP-ul real
            $realIp = request()->header('X-Forwarded-For')
                   ?? request()->header('X-Real-IP')
                   ?? request()->server('HTTP_CLIENT_IP')
                   ?? request()->server('HTTP_X_FORWARDED_FOR')
                   ?? $realIp;
        }

        PowerDnsChangelog::create([
            'zone_name' => $zoneName,
            'record_name' => $recordName,
            'record_type' => $recordType,
            'action' => $action,
            'user_id' => $user->id,
            'ip_address' => $realIp,
            'user_agent' => request()->userAgent(),
            'old_content' => $data['old_content'] ?? null,
            'new_content' => $data['new_content'] ?? null,
            'old_ttl' => $data['old_ttl'] ?? null,
            'new_ttl' => $data['new_ttl'] ?? null,
            'old_disabled' => $data['old_disabled'] ?? null,
            'new_disabled' => $data['new_disabled'] ?? null,
        ]);
    }

    /**
     * Șterge înregistrarea din toate nameserverele active
     */
    private function deleteRecordFromAllNameservers($zoneName, $recordName, $recordType, $specificContent = null)
    {
        $activeNameservers = \App\Models\Nameserver::where('is_active', true)->get();
        $results = [];

        foreach ($activeNameservers as $nameserver) {
            try {
                $powerDNS = new \App\Services\PowerDNSService(
                    $nameserver->api_url,
                    $nameserver->api_key
                );

                // Construiește numele complet
                $fullName = $recordName;
                if (!str_ends_with($recordName, '.')) {
                    $fullName = $recordName . '.';
                }

                $result = $powerDNS->deleteRecord($zoneName, $fullName, $recordType);

                if ($result && (!is_array($result) || ($result['success'] ?? false))) {
                    $results[$nameserver->name] = true;
                    \Log::info("Record deleted from {$nameserver->name}", [
                        'zone' => $zoneName,
                        'record' => $recordName,
                        'type' => $recordType
                    ]);
                } else {
                    $results[$nameserver->name] = false;
                    \Log::warning("Failed to delete record from {$nameserver->name}", [
                        'zone' => $zoneName,
                        'record' => $recordName,
                        'type' => $recordType,
                        'error' => is_array($result) ? ($result['error'] ?? 'Unknown') : 'Unknown'
                    ]);
                }

            } catch (\Exception $e) {
                $errorMessage = $e->getMessage();

                // Verifică dacă este eroare de permisiuni
                if (strpos($errorMessage, 'Not Found') !== false ||
                    strpos($errorMessage, '404') !== false ||
                    strpos($errorMessage, '"error": "Not Found"') !== false) {
                    $results[$nameserver->name] = 'no_permission';
                    \Log::warning("No permission to delete record from {$nameserver->name}", [
                        'zone' => $zoneName,
                        'record' => $recordName,
                        'type' => $recordType,
                        'error' => $errorMessage
                    ]);
                } else {
                    $results[$nameserver->name] = false;
                    \Log::error("Exception deleting record from {$nameserver->name}", [
                        'zone' => $zoneName,
                        'record' => $recordName,
                        'type' => $recordType,
                        'error' => $errorMessage
                    ]);
                }
            }
        }

        return $results;
    }

    /**
     * Șterge înregistrarea din baza de date locală dacă există
     */
    private function deleteFromLocalDatabase($zoneName, $recordName, $recordType, $userId)
    {
        // Găsește zona locală
        $localZone = \App\Models\DnsZone::where('domain', rtrim($zoneName, '.'))
            ->where('user_id', $userId)
            ->first();

        if (!$localZone) {
            return; // Nu este zonă locală
        }

        // Găsește înregistrarea
        $localRecord = \App\Models\DnsRecord::where('dns_zone_id', $localZone->id)
            ->where('name', $recordName)
            ->where('type', $recordType)
            ->first();

        if ($localRecord) {
            // Creează log pentru ștergere
            \App\Models\DnsRecordChange::create([
                'dns_record_id' => null,
                'dns_zone_id' => $localZone->id,
                'user_id' => $userId,
                'ip_address' => request()->ip() ?? '127.0.0.1',
                'action' => 'delete',
                'record_name' => $localRecord->name,
                'record_type' => $localRecord->type,
                'old_values' => [
                    'content' => $localRecord->content,
                    'ttl' => $localRecord->ttl,
                    'priority' => $localRecord->priority,
                    'is_active' => $localRecord->is_active,
                    'notes' => $localRecord->notes,
                ],
                'description' => 'Ștergere înregistrare DNS via PowerDNS Controller',
            ]);

            // Șterge înregistrarea
            $localRecord->delete();

            \Log::info("Local record deleted from database", [
                'zone' => $zoneName,
                'record' => $recordName,
                'type' => $recordType,
                'local_zone_id' => $localZone->id
            ]);
        }
    }
}
