<?php

namespace App\Http\Controllers;

use App\Models\DnsRecord;
use App\Models\DnsRecordChange;
use App\Models\DnsZone;
use App\Models\CloudflareZone;
use App\Models\CloudflareRecordSetting;
use App\Services\CloudflareService;
use App\Notifications\DnsRecordChangedNotification;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Auth;
use Illuminate\Support\Facades\Log;

class DnsRecordController extends Controller
{
    /**
     * Sincronizează un record cu Cloudflare (create/update/delete)
     */
    private function syncRecordToCloudflare(DnsZone $dnsZone, DnsRecord $record, string $action, ?array $oldRecordData = null): ?string
    {
        try {
            // Verifică dacă zona este conectată la Cloudflare
            $cfZone = CloudflareZone::where('dns_zone_id', $dnsZone->id)->first();

            if (!$cfZone || !$cfZone->auto_sync) {
                return null; // Nu este conectată sau auto-sync dezactivat
            }

            // Verifică direcția de sincronizare
            if ($cfZone->sync_direction === 'from_cloudflare') {
                return null; // Sincronizare doar din Cloudflare, nu către
            }

            $cloudflareService = app(CloudflareService::class);
            $cloudflareService->setCredential($cfZone->credential);

            $cfZoneId = $cfZone->cloudflare_zone_id;

            // Pregătește datele recordului pentru Cloudflare
            $recordData = [
                'type' => $record->type,
                'name' => $record->name,
                'content' => $record->content,
                'ttl' => $record->ttl == 3600 ? 1 : $record->ttl, // 1 = auto în Cloudflare
                'proxied' => false, // Default fără proxy
            ];

            // Pentru MX, adaugă priority
            if ($record->type === 'MX' && $record->priority) {
                $recordData['priority'] = $record->priority;
            }

            // Verifică dacă există deja setări CF pentru acest record
            $cfSetting = CloudflareRecordSetting::where('dns_record_id', $record->id)
                ->where('cloudflare_zone_id', $cfZone->id)
                ->first();

            switch ($action) {
                case 'create':
                    // Creează în Cloudflare
                    $result = $cloudflareService->createRecord($cfZoneId, $recordData);

                    if ($result && isset($result['id'])) {
                        // Salvează legătura
                        CloudflareRecordSetting::create([
                            'dns_record_id' => $record->id,
                            'cloudflare_zone_id' => $cfZone->id,
                            'cloudflare_record_id' => $result['id'],
                            'proxied' => $result['proxied'] ?? false,
                            'sync_enabled' => true,
                            'last_synced_at' => now(),
                        ]);
                        return 'Sincronizat cu Cloudflare.';
                    }
                    break;

                case 'update':
                    if ($cfSetting && $cfSetting->cloudflare_record_id) {
                        // Actualizează în Cloudflare
                        $result = $cloudflareService->updateRecord($cfZoneId, $cfSetting->cloudflare_record_id, $recordData);

                        if ($result) {
                            $cfSetting->update(['last_synced_at' => now()]);
                            return 'Sincronizat cu Cloudflare.';
                        }
                    } else {
                        // Nu există în CF, creează-l
                        return $this->syncRecordToCloudflare($dnsZone, $record, 'create');
                    }
                    break;

                case 'delete':
                    if ($cfSetting && $cfSetting->cloudflare_record_id) {
                        // Șterge din Cloudflare
                        $result = $cloudflareService->deleteRecord($cfZoneId, $cfSetting->cloudflare_record_id);

                        if ($result) {
                            $cfSetting->delete();
                            return 'Șters și din Cloudflare.';
                        }
                    }
                    break;
            }
        } catch (\Exception $e) {
            Log::error('Cloudflare sync error: ' . $e->getMessage(), [
                'zone' => $dnsZone->domain,
                'record' => $record->name,
                'action' => $action,
            ]);
            return 'Eroare sincronizare Cloudflare: ' . $e->getMessage();
        }

        return null;
    }

    /**
     * Sincronizează un record cu toate nameserverele active pentru o zonă
     */
    private function syncRecordToAllNameservers(DnsZone $dnsZone, $action, $recordData = null, $oldRecordData = null)
    {
        if (!$dnsZone->sync_to_powerdns) {
            return [];
        }

        // Obține nameserverele permise conform planului utilizatorului
        $user = $dnsZone->user;
        $plan = $user->plan ?? $user->resellerPlan;
        $allowedNameServers = $plan ? $plan->getAllowedNameServers() : [];

        // Obține nameserverele active care sunt permise în plan
        $activeNameservers = \App\Models\Nameserver::where('is_active', true)
            ->when(!empty($allowedNameServers), function($query) use ($allowedNameServers) {
                return $query->whereIn('id', $allowedNameServers);
            })
            ->get();
        $results = [];

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

                $zoneName = $dnsZone->domain . '.';

                switch ($action) {
                    case 'create':
                        $result = $this->createRecordOnNameserver($powerDNS, $zoneName, $dnsZone, $recordData);
                        break;
                    case 'update':
                        $result = $this->updateRecordOnNameserver($powerDNS, $zoneName, $dnsZone, $recordData, $oldRecordData);
                        break;
                    case 'delete':
                        $result = $this->deleteRecordOnNameserver($powerDNS, $zoneName, $dnsZone, $recordData);
                        break;
                    case 'toggle':
                        $result = $this->toggleRecordOnNameserver($powerDNS, $zoneName, $dnsZone, $recordData);
                        break;
                    default:
                        $result = false;
                }

                $results[$nameServer->name] = $result;

                \Log::info("Record {$action} on {$nameServer->name}", [
                    'zone' => $dnsZone->domain,
                    'result' => $result ? 'success' : 'failed'
                ]);

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

                // Verifică dacă este eroare de permisiuni (Not Found pentru zone care nu sunt accesibile)
                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 for {$action} record on {$nameServer->name}", [
                        'zone' => $dnsZone->domain,
                        'error' => $errorMessage
                    ]);
                } else {
                    $results[$nameServer->name] = false;
                    \Log::error("Failed to {$action} record on {$nameServer->name}", [
                        'zone' => $dnsZone->domain,
                        'error' => $errorMessage
                    ]);
                }
            }
        }

        return $results;
    }

    private function createRecordOnNameserver($powerDNS, $zoneName, $dnsZone, $recordData)
    {
        // Construiește numele complet pentru PowerDNS
        $recordName = $recordData['name'];
        if ($recordName === '@') {
            $fullName = rtrim($dnsZone->domain, '.') . '.';
        } else {
            $fullName = $recordName . '.' . rtrim($dnsZone->domain, '.') . '.';
        }

        // Construiește content-ul (pentru MX include priority)
        $content = $recordData['content'];
        if ($recordData['type'] === 'MX' && isset($recordData['priority'])) {
            $content = $recordData['priority'] . ' ' . $content;
        }

        // Adaugă punct final pentru FQDN dacă este necesar
        if (in_array($recordData['type'], ['CNAME', 'NS', 'PTR', 'SRV', 'MX']) &&
            !str_ends_with($content, '.') &&
            !filter_var($content, FILTER_VALIDATE_IP)) {
            $content .= '.';
        }

        $result = $powerDNS->addRecord(
            $zoneName,
            $fullName,
            $recordData['type'],
            $content,
            $recordData['ttl']
        );

        return $result && (is_array($result) ? $result['success'] : true);
    }

    private function updateRecordOnNameserver($powerDNS, $zoneName, $dnsZone, $recordData, $oldRecordData)
    {
        // Pentru update, șterge vechiul record și adaugă noul record
        $deleteResult = $this->deleteRecordOnNameserver($powerDNS, $zoneName, $dnsZone, $oldRecordData);
        if ($deleteResult) {
            return $this->createRecordOnNameserver($powerDNS, $zoneName, $dnsZone, $recordData);
        }
        return false;
    }

    private function deleteRecordOnNameserver($powerDNS, $zoneName, $dnsZone, $recordData)
    {
        // Construiește numele complet pentru PowerDNS
        $recordName = $recordData['name'];
        if ($recordName === '@') {
            $fullName = rtrim($dnsZone->domain, '.') . '.';
        } else {
            $fullName = $recordName . '.' . rtrim($dnsZone->domain, '.') . '.';
        }

        $result = $powerDNS->deleteRecord($zoneName, $fullName, $recordData['type']);
        return $result && (is_array($result) ? $result['success'] : true);
    }

    private function toggleRecordOnNameserver($powerDNS, $zoneName, $dnsZone, $recordData)
    {
        // Construiește numele complet pentru PowerDNS
        $recordName = $recordData['name'];
        if ($recordName === '@') {
            $fullName = rtrim($dnsZone->domain, '.') . '.';
        } else {
            $fullName = $recordName . '.' . rtrim($dnsZone->domain, '.') . '.';
        }

        // Construiește content-ul (pentru MX include priority)
        $content = $recordData['content'];
        if ($recordData['type'] === 'MX' && isset($recordData['priority'])) {
            $content = $recordData['priority'] . ' ' . $content;
        }

        // Adaugă punct final pentru FQDN dacă este necesar
        if (in_array($recordData['type'], ['CNAME', 'NS', 'PTR', 'SRV', 'MX']) &&
            !str_ends_with($content, '.') &&
            !filter_var($content, FILTER_VALIDATE_IP)) {
            $content .= '.';
        }

        // disabled = true dacă record-ul e inactiv (is_active = false)
        $disabled = !$recordData['is_active'];

        $result = $powerDNS->toggleRecordStatus(
            $zoneName,
            $fullName,
            $recordData['type'],
            $disabled,
            $content
        );

        return $result && (is_array($result) ? $result['success'] : true);
    }

    /**
     * Display a listing of the resource.
     */
    public function index(DnsZone $dnsZone)
    {
        $user = Auth::user();

        if (!$user->isAdmin() && $dnsZone->user_id !== $user->id) {
            abort(403, 'Nu ai permisiunea să accesezi această zonă DNS.');
        }

        $records = $dnsZone->records()->latest()->paginate(20);

        return view('dns-records.index', compact('dnsZone', 'records'));
    }

    /**
     * Show the form for creating a new resource.
     */
    public function create(DnsZone $dnsZone)
    {
        $user = Auth::user();

        if (!$user->isAdmin() && $dnsZone->user_id !== $user->id) {
            abort(403, 'Nu ai permisiunea să accesezi această zonă DNS.');
        }

        if (!$user->canAddSubdomain()) {
            return redirect()->route('dns-zones.show', $dnsZone)
                ->with('error', 'Ai atins limita de subdomenii pentru planul tău.');
        }

        // Obține tipurile de înregistrări permise (toate pentru admin sau din plan)
        if ($user->isAdmin()) {
            $allowedTypes = ['A', 'AAAA', 'CNAME', 'MX', 'TXT', 'NS', 'SRV', 'CAA', 'PTR', 'DNSKEY', 'DS', 'TLSA', 'SSHFP', 'NAPTR', 'CERT', 'DNAME', 'LOC', 'HINFO', 'RP', 'AFSDB', 'KEY', 'NSEC', 'NSEC3', 'NSEC3PARAM', 'RRSIG', 'CDNSKEY', 'CDS', 'OPENPGPKEY', 'TKEY', 'TSIG', 'URI', 'ALIAS'];
        } else {
            $allowedTypes = $user->plan ? $user->plan->getAllowedRecordTypes() : ['A', 'AAAA', 'CNAME', 'MX', 'TXT', 'NS'];
        }

        // Verifică dacă se dorește duplicarea unui record existent
        $duplicateRecord = null;
        if (request()->has('duplicate')) {
            $duplicateId = request()->get('duplicate');
            $duplicateRecord = \App\Models\DnsRecord::where('id', $duplicateId)
                ->where('dns_zone_id', $dnsZone->id)
                ->first();
        }

        return view('dns-records.create', compact('dnsZone', 'allowedTypes', 'duplicateRecord'));
    }

    /**
     * Store a newly created resource in storage.
     */
    public function store(Request $request, DnsZone $dnsZone)
    {
        $user = Auth::user();

        if (!$user->isAdmin() && $dnsZone->user_id !== $user->id) {
            abort(403, 'Nu ai permisiunea să accesezi această zonă DNS.');
        }

        if (!$user->canAddSubdomain()) {
            return redirect()->route('dns-zones.show', $dnsZone)
                ->with('error', 'Ai atins limita de subdomenii pentru planul tău.');
        }

        // Verifică tipurile de înregistrări permise
        if ($user->isAdmin()) {
            // Admin are acces la toate tipurile de înregistrări
            $allowedTypes = ['A', 'AAAA', 'CNAME', 'MX', 'TXT', 'NS', 'SRV', 'CAA', 'PTR', 'SOA'];
        } elseif ($user->plan) {
            $allowedTypes = $user->plan->getAllowedRecordTypes();
        } else {
            // User fără plan - tipuri de bază
            $allowedTypes = ['A', 'AAAA', 'CNAME', 'MX', 'TXT'];
        }

        // Validare de bază
        $validationRules = [
            'name' => [
                'required',
                'string',
                'max:255',
                'not_regex:/[#]/'
            ],
            'type' => ['required', 'in:' . implode(',', $allowedTypes)],
            'content' => ['required', 'string', 'max:500'],
            'ttl' => ['required', 'integer', 'min:60', 'max:86400'],
            'priority' => ['nullable', 'integer', 'min:0', 'max:65535'],
            'notes' => ['nullable', 'string', 'max:1000'],
        ];

        // Adaugă validare pentru SRV
        if ($request->type === 'SRV') {
            $validationRules['priority'] = ['required', 'integer', 'min:0', 'max:65535'];
            $validationRules['weight'] = ['required', 'integer', 'min:0', 'max:65535'];
            $validationRules['port'] = ['required', 'integer', 'min:1', 'max:65535'];
        }

        $request->validate($validationRules, [
            'name.not_regex' => 'Caracterul "#" nu este permis în numele înregistrării DNS deoarece cauzează probleme în URL-uri.',
            'type.in' => 'Tipul de înregistrare selectat nu este permis pentru planul tău. Tipuri permise: ' . implode(', ', $allowedTypes),
            'weight.required' => 'Weight este obligatoriu pentru înregistrările SRV.',
            'port.required' => 'Port este obligatoriu pentru înregistrările SRV.',
        ]);

        // Verifică dublu dacă tipul este permis (skip pentru admin)
        if (!$user->isAdmin() && $user->plan && !$user->plan->isRecordTypeAllowed($request->type)) {
            return redirect()->route('dns-zones.show', $dnsZone)
                ->with('error', 'Tipul de înregistrare ' . $request->type . ' nu este permis pentru planul tău.');
        }

        // Pentru SRV, construiește content-ul în formatul corect
        $content = $request->content;
        if ($request->type === 'SRV') {
            // Format SRV: priority weight port target
            // Exemplu: 10 60 5060 sipserver.example.com.
            $content = $request->priority . ' ' . $request->weight . ' ' . $request->port . ' ' . rtrim($request->content, '.') . '.';
        }

        $record = $dnsZone->records()->create([
            'name' => strtolower($request->name),
            'type' => $request->type,
            'content' => $content,
            'ttl' => $request->ttl,
            'priority' => $request->priority,
            'is_active' => true,
            'notes' => $request->notes,
        ]);

        // Sincronizare cu TOATE numeserverele Activ
        $recordData = [
            'name' => strtolower($request->name),
            'type' => $request->type,
            'content' => $content, // Folosește content-ul formatat pentru SRV
            'ttl' => $request->ttl,
            'priority' => $request->priority,
        ];

        $syncResults = $this->syncRecordToAllNameservers($dnsZone, 'create', $recordData);

        if ($syncResults) {
            $successCount = count(array_filter($syncResults, function($result) {
                return $result === true;
            }));
            $noPermissionCount = count(array_filter($syncResults, function($result) {
                return $result === 'no_permission';
            }));
            $totalCount = count($syncResults) - $noPermissionCount; // Exclud nameserverele fără permisiuni

            if ($successCount === $totalCount) {
                $syncMessage = " Sincronizat pe toate {$totalCount} nameserverele disponibile.";
            } else {
                $syncMessage = " Sincronizat pe {$successCount} din {$totalCount} nameservere disponibile.";
                if ($noPermissionCount > 0) {
                    $syncMessage .= " ({$noPermissionCount} nameservere fără permisiuni)";
                }
            }
        } else {
            $syncMessage = '';
        }

        // Sincronizare cu Cloudflare (dacă este conectat)
        $cfSyncMessage = $this->syncRecordToCloudflare($dnsZone, $record, 'create');
        if ($cfSyncMessage) {
            $syncMessage .= ' ' . $cfSyncMessage;
        }

        // Log crearea înregistrării
        DnsRecordChange::create([
            'dns_record_id' => $record->id,
            'dns_zone_id' => $dnsZone->id,
            'user_id' => $user->id,
            'ip_address' => $request->ip(),
            'action' => 'create',
            'record_name' => $record->name,
            'record_type' => $record->type,
            'new_values' => [
                'content' => $record->content,
                'ttl' => $record->ttl,
                'priority' => $record->priority,
                'is_active' => $record->is_active,
                'notes' => $record->notes,
            ],
            'description' => 'Creare înregistrare DNS',
        ]);

        // Notificările pentru ștergerea înregistrărilor sunt dezactivate
        // $utilizator->notify(new DnsînregistrareChangednotificare($dnszonă, $înregistraretip, 'deleted', $înregistrarenume));

        return redirect()->route('dns-zones.show', $dnsZone)
            ->with('success', 'Înregistrarea DNS a fost adăugată cu succes.' . ($syncMessage ?? ''));
    }

    /**
     * Display the specified resource.
     */
    public function show(DnsZone $dnsZone, DnsRecord $record)
    {
        $user = Auth::user();

        // Verifică dacă recordul aparține zonei specificate
        if ($record->dns_zone_id !== $dnsZone->id) {
            abort(404, 'Înregistrarea DNS nu aparține acestei zone.');
        }

        if (!$user->isAdmin() && $dnsZone->user_id !== $user->id) {
            abort(403, 'Nu ai permisiunea să accesezi această înregistrare.');
        }

        return view('dns-records.show', compact('dnsZone', 'record'));
    }

    /**
     * Show the form for editing the specified resource.
     */
    public function edit(DnsZone $dnsZone, DnsRecord $record)
    {
        $user = Auth::user();

        // Verifică dacă recordul aparține zonei specificate
        if ($record->dns_zone_id !== $dnsZone->id) {
            abort(404, 'Înregistrarea DNS nu aparține acestei zone.');
        }

        if (!$user->isAdmin() && $dnsZone->user_id !== $user->id) {
            abort(403, 'Nu ai permisiunea să editezi această înregistrare.');
        }

        // Obține tipurile de înregistrări permise
        if ($user->isAdmin()) {
            $allowedTypes = ['A', 'AAAA', 'CNAME', 'MX', 'TXT', 'NS', 'SRV', 'CAA', 'PTR', 'DNSKEY', 'DS', 'TLSA', 'SSHFP', 'NAPTR', 'CERT', 'DNAME', 'LOC', 'HINFO', 'RP', 'AFSDB', 'KEY', 'NSEC', 'NSEC3', 'NSEC3PARAM', 'RRSIG', 'CDNSKEY', 'CDS', 'OPENPGPKEY', 'TKEY', 'TSIG', 'URI', 'ALIAS', 'SOA'];
        } else {
            $allowedTypes = $user->plan ? $user->plan->getAllowedRecordTypes() : ['A', 'AAAA', 'CNAME', 'MX', 'TXT', 'NS'];
        }

        return view('dns-records.edit', compact('dnsZone', 'record', 'allowedTypes'));
    }

    /**
     * Update the specified resource in storage.
     */
    public function update(Request $request, DnsZone $dnsZone, DnsRecord $record)
    {
        $user = Auth::user();

        // Verifică dacă recordul aparține zonei specificate
        if ($record->dns_zone_id !== $dnsZone->id) {
            abort(404, 'Înregistrarea DNS nu aparține acestei zone.');
        }

        if (!$user->isAdmin() && $dnsZone->user_id !== $user->id) {
            abort(403, 'Nu ai permisiunea să editezi această înregistrare.');
        }

        // Verifică tipurile de înregistrări permise
        if ($user->isAdmin()) {
            $allowedTypes = ['A', 'AAAA', 'CNAME', 'MX', 'TXT', 'NS', 'SRV', 'CAA', 'PTR', 'DNSKEY', 'DS', 'TLSA', 'SSHFP', 'NAPTR', 'CERT', 'DNAME', 'LOC', 'HINFO', 'RP', 'AFSDB', 'KEY', 'NSEC', 'NSEC3', 'NSEC3PARAM', 'RRSIG', 'CDNSKEY', 'CDS', 'OPENPGPKEY', 'TKEY', 'TSIG', 'URI', 'ALIAS', 'SOA'];
        } else {
            $allowedTypes = $user->plan ? $user->plan->getAllowedRecordTypes() : ['A', 'AAAA', 'CNAME', 'MX', 'TXT', 'NS'];
        }

        $request->validate([
            'name' => [
                'required',
                'string',
                'max:255',
                'not_regex:/[#]/'
            ],
            'type' => ['required', 'string', 'in:' . implode(',', $allowedTypes)],
            'content' => ['required', 'string', 'max:500'],
            'ttl' => ['required', 'integer', 'min:60', 'max:86400'],
            'priority' => ['nullable', 'integer', 'min:0', 'max:65535'],
            'is_active' => ['boolean'],
            'notes' => ['nullable', 'string', 'max:1000'],
        ], [
            'name.not_regex' => 'Caracterul "#" nu este permis în numele înregistrării DNS deoarece cauzează probleme în URL-uri.',
            'type.in' => 'Tipul de înregistrare selectat nu este permis pentru planul tău. Tipuri permise: ' . implode(', ', $allowedTypes),
        ]);

        // Salvează valorile vechi pentru logging
        $oldValues = [
            'name' => $record->name,
            'type' => $record->type,
            'content' => $record->content,
            'ttl' => $record->ttl,
            'priority' => $record->priority,
            'is_active' => $record->is_active,
            'notes' => $record->notes,
        ];

        $record->update($request->only(['name', 'type', 'content', 'ttl', 'priority', 'is_active', 'notes']));

        // Sincronizare cu TOATE numeserverele Activ
        $recordData = [
            'name' => strtolower($request->name),
            'type' => $request->type,
            'content' => $request->content,
            'ttl' => $request->ttl,
            'priority' => $request->priority,
            'is_active' => $request->boolean('is_active', true),
        ];

        $syncResults = $this->syncRecordToAllNameservers($dnsZone, 'update', $recordData, $oldValues);

        if ($syncResults) {
            $successCount = count(array_filter($syncResults, function($result) {
                return $result === true;
            }));
            $noPermissionCount = count(array_filter($syncResults, function($result) {
                return $result === 'no_permission';
            }));
            $totalCount = count($syncResults) - $noPermissionCount; // Exclud nameserverele fără permisiuni

            if ($successCount === $totalCount) {
                $syncMessage = " Actualizat pe toate {$totalCount} nameserverele disponibile.";
            } else {
                $syncMessage = " Actualizat pe {$successCount} din {$totalCount} nameservere disponibile.";
                if ($noPermissionCount > 0) {
                    $syncMessage .= " ({$noPermissionCount} nameservere fără permisiuni)";
                }
            }
        } else {
            $syncMessage = '';
        }

        // Sincronizare cu Cloudflare (dacă este conectat)
        $cfSyncMessage = $this->syncRecordToCloudflare($dnsZone, $record, 'update');
        if ($cfSyncMessage) {
            $syncMessage .= ' ' . $cfSyncMessage;
        }

        // Log actualizarea
        DnsRecordChange::create([
            'dns_record_id' => $record->id,
            'dns_zone_id' => $dnsZone->id,
            'user_id' => $user->id,
            'ip_address' => $request->ip(),
            'action' => 'update',
            'record_name' => $record->name,
            'record_type' => $record->type,
            'old_values' => $oldValues,
            'new_values' => [
                'content' => $record->content,
                'ttl' => $record->ttl,
                'priority' => $record->priority,
                'is_active' => $record->is_active,
                'notes' => $record->notes,
            ],
            'description' => 'Actualizare înregistrare DNS',
        ]);

        // Notificările pentru modificarea înregistrărilor sunt dezactivate
        // $utilizator->notify(new DnsînregistrareChangednotificare($dnszonă, $înregistrare->tip, 'updated', $înregistrare->nume));

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

    /**
     * Remove the specified resource from storage.
     */
    public function destroy(DnsZone $dnsZone, DnsRecord $record)
    {
        $user = Auth::user();

        // Verifică dacă recordul aparține zonei specificate
        if ($record->dns_zone_id !== $dnsZone->id) {
            abort(404, 'Înregistrarea DNS nu aparține acestei zone.');
        }

        if (!$user->isAdmin() && $dnsZone->user_id !== $user->id) {
            abort(403, 'Nu ai permisiunea să ștergi această înregistrare.');
        }

        // Salvează datele pentru sincronizare înainte de ștergere
        $recordName = $record->name;
        $recordType = $record->type;
        $recordContent = $record->content;
        $recordPriority = $record->priority;

        // Log ștergerea înainte de a șterge înregistrarea
        DnsRecordChange::create([
            'dns_record_id' => null, // Înregistrarea va fi ștearsă
            'dns_zone_id' => $dnsZone->id,
            'user_id' => $user->id,
            'ip_address' => request()->ip(),
            'action' => 'delete',
            'record_name' => $record->name,
            'record_type' => $record->type,
            'old_values' => [
                'content' => $record->content,
                'ttl' => $record->ttl,
                'priority' => $record->priority,
                'is_active' => $record->is_active,
                'notes' => $record->notes,
            ],
            'description' => 'Ștergere înregistrare DNS',
        ]);

        // Sincronizare cu Cloudflare ÎNAINTE de ștergere din DB
        $cfSyncMessage = $this->syncRecordToCloudflare($dnsZone, $record, 'delete');

        $record->delete();

                // Sincronizare cu TOATE numeserverele Activ
        $recordData = [
            'name' => strtolower($recordName),
            'type' => $recordType,
            'content' => $recordContent,
            'priority' => $recordPriority,
        ];

        $syncResults = $this->syncRecordToAllNameservers($dnsZone, 'delete', $recordData);

        if ($syncResults) {
            $successCount = count(array_filter($syncResults, function($result) {
                return $result === true;
            }));
            $noPermissionCount = count(array_filter($syncResults, function($result) {
                return $result === 'no_permission';
            }));
            $totalCount = count($syncResults) - $noPermissionCount; // Exclud nameserverele fără permisiuni

            if ($successCount === $totalCount) {
                $syncMessage = " Șters de pe toate {$totalCount} nameserverele disponibile.";
            } else {
                $syncMessage = " Șters de pe {$successCount} din {$totalCount} nameservere disponibile.";
                if ($noPermissionCount > 0) {
                    $syncMessage .= " ({$noPermissionCount} nameservere fără permisiuni)";
                }
            }
        } else {
            $syncMessage = '';
        }

        // Adaugă mesajul Cloudflare
        if (isset($cfSyncMessage) && $cfSyncMessage) {
            $syncMessage .= ' ' . $cfSyncMessage;
        }

        // Trimite notificare utilizatorului
        $user->notify(new DnsRecordChangedNotification($dnsZone, $recordType, 'deleted', $recordName));

        return redirect()->route('dns-zones.show', $dnsZone)
            ->with('success', 'Înregistrarea DNS a fost ștearsă cu succes.' . ($syncMessage ?? ''));
    }

    /**
     * Toggle status pentru o înregistrare DNS locală
     */
    public function toggleStatus(DnsZone $dnsZone, DnsRecord $record)
    {
        $user = Auth::user();

        // Verifică dacă recordul aparține zonei specificate
        if ($record->dns_zone_id !== $dnsZone->id) {
            abort(404, 'Înregistrarea DNS nu aparține acestei zone.');
        }

        if (!$user->isAdmin() && $dnsZone->user_id !== $user->id) {
            abort(403, 'Nu ai permisiunea să modifici această înregistrare.');
        }

        // Salvează statusul vechi
        $oldStatus = $record->is_active;

        // Comută status
        $record->is_active = !$record->is_active;
        $record->save();

        // SINCRONIZARE CĂTRE NAMESERVERE
        try {
            $recordData = [
                'name' => $record->name,
                'type' => $record->type,
                'content' => $record->content,
                'ttl' => $record->ttl,
                'priority' => $record->priority,
                'is_active' => $record->is_active,
            ];

            $results = $this->syncRecordToAllNameservers($dnsZone, 'toggle', $recordData);
            $successCount = count(array_filter($results, function($result) { return $result === true; }));
            $syncMessage = " și sincronizată către {$successCount} nameservere";
        } catch (\Exception $e) {
            $syncMessage = " (eroare sincronizare către nameservere)";
        }

        // Log schimbarea de status
        DnsRecordChange::create([
            'dns_record_id' => $record->id,
            'dns_zone_id' => $dnsZone->id,
            'user_id' => $user->id,
            'ip_address' => request()->ip(),
            'action' => 'toggle_status',
            'record_name' => $record->name,
            'record_type' => $record->type,
            'old_values' => ['is_active' => $oldStatus],
            'new_values' => ['is_active' => $record->is_active],
            'description' => $record->is_active ? 'Activare înregistrare' : 'Dezactivare înregistrare',
        ]);

        $statusText = $record->is_active ? 'activată' : 'dezactivată';

        return redirect()->route('dns-zones.show', $dnsZone)
            ->with('success', "Înregistrarea a fost {$statusText} cu succes{$syncMessage}.");
    }

    /**
     * Afișează istoricul modificărilor pentru o înregistrare DNS locală
     */
    public function changelog(DnsZone $dnsZone, DnsRecord $record)
    {
        $user = Auth::user();

        if (!$user->isAdmin() && $dnsZone->user_id !== $user->id) {
            abort(403, 'Nu ai permisiunea să accesezi această înregistrare.');
        }

        // Încarcă istoricul modificărilor cu relațiile
        $changes = $record->changes()->with('user')->paginate(20);

        return view('dns-records.changelog', compact('dnsZone', 'record', 'changes'));
    }

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

        if (!$user->isAdmin() && $dnsZone->user_id !== $user->id) {
            abort(403, 'Nu ai permisiunea să modifici această înregistrare.');
        }

        // Găsește intrarea din changelog
        $changelog = \App\Models\DnsRecordChange::findOrFail($changelogId);

        // Verifică că changelog-ul aparține acestei înregistrări
        if ($changelog->dns_record_id !== $record->id) {
            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_values) {
            return redirect()->back()->with('error', 'Nu există date pentru restaurare.');
        }

        $oldValues = $changelog->old_values;

        // Salvează valorile curente pentru log
        $currentValues = [
            'name' => $record->name,
            'type' => $record->type,
            'content' => $record->content,
            'ttl' => $record->ttl,
            'priority' => $record->priority,
            'is_active' => $record->is_active,
        ];

        // Restaurează valorile vechi
        if (isset($oldValues['name'])) $record->name = $oldValues['name'];
        if (isset($oldValues['type'])) $record->type = $oldValues['type'];
        if (isset($oldValues['content'])) $record->content = $oldValues['content'];
        if (isset($oldValues['ttl'])) $record->ttl = $oldValues['ttl'];
        if (isset($oldValues['priority'])) $record->priority = $oldValues['priority'];
        if (isset($oldValues['is_active'])) $record->is_active = $oldValues['is_active'];

        $record->save();

        // SINCRONIZARE CĂTRE NAMESERVERE după restore
        try {
            $recordData = [
                'name' => $record->name,
                'type' => $record->type,
                'content' => $record->content,
                'ttl' => $record->ttl,
                'priority' => $record->priority,
                'is_active' => $record->is_active,
            ];

            $results = $this->syncRecordToAllNameservers($dnsZone, 'update', $recordData, $currentValues);
            $successCount = count(array_filter($results, function($result) { return $result === true; }));
            $syncMessage = " și sincronizată către {$successCount} nameservere";
        } catch (\Exception $e) {
            $syncMessage = " (eroare sincronizare către nameservere)";
        }

        // Log restaurarea
        \App\Models\DnsRecordChange::create([
            'dns_record_id' => $record->id,
            'dns_zone_id' => $dnsZone->id,
            'user_id' => $user->id,
            'ip_address' => request()->ip(),
            'action' => 'restore',
            'record_name' => $record->name,
            'record_type' => $record->type,
            'old_values' => $currentValues,
            'new_values' => [
                'name' => $record->name,
                'type' => $record->type,
                'content' => $record->content,
                'ttl' => $record->ttl,
                'priority' => $record->priority,
                'is_active' => $record->is_active,
            ],
            'description' => "Restaurare din changelog #{$changelogId}",
        ]);

        return redirect()->route('dns-records.changelog', [$dnsZone, $record])
            ->with('success', "Înregistrarea a fost restaurată cu succes{$syncMessage}.");
    }

    /**
     * Toggle status pentru mai multe înregistrări (bulk action)
     */
    public function bulkToggle(Request $request, DnsZone $dnsZone)
    {
        $user = Auth::user();

        if (!$user->isAdmin() && $dnsZone->user_id !== $user->id) {
            return response()->json(['success' => false, 'message' => 'Nu ai permisiunea să modifici această zonă.'], 403);
        }

        $ids = $request->input('ids', []);
        if (empty($ids)) {
            return response()->json(['success' => false, 'message' => 'Nicio înregistrare selectată.']);
        }

        $updated = 0;
        foreach ($ids as $id) {
            $record = DnsRecord::where('id', $id)->where('dns_zone_id', $dnsZone->id)->first();
            if ($record && !in_array($record->type, ['SOA', 'NS'])) {
                $record->is_active = !$record->is_active;
                $record->save();
                $updated++;

                // Log schimbarea
                DnsRecordChange::create([
                    'dns_record_id' => $record->id,
                    'dns_zone_id' => $dnsZone->id,
                    'user_id' => $user->id,
                    'ip_address' => $request->ip(),
                    'action' => 'toggle_status',
                    'record_name' => $record->name,
                    'record_type' => $record->type,
                    'old_values' => ['is_active' => !$record->is_active],
                    'new_values' => ['is_active' => $record->is_active],
                    'description' => 'Bulk toggle status',
                ]);
            }
        }

        return response()->json([
            'success' => true,
            'message' => "{$updated} înregistrări au fost actualizate.",
            'updated' => $updated
        ]);
    }

    /**
     * Șterge mai multe înregistrări (bulk action)
     */
    public function bulkDelete(Request $request, DnsZone $dnsZone)
    {
        $user = Auth::user();

        if (!$user->isAdmin() && $dnsZone->user_id !== $user->id) {
            return response()->json(['success' => false, 'message' => 'Nu ai permisiunea să modifici această zonă.'], 403);
        }

        $ids = $request->input('ids', []);
        if (empty($ids)) {
            return response()->json(['success' => false, 'message' => 'Nicio înregistrare selectată.']);
        }

        $deleted = 0;
        foreach ($ids as $id) {
            $record = DnsRecord::where('id', $id)->where('dns_zone_id', $dnsZone->id)->first();
            if ($record && !in_array($record->type, ['SOA', 'NS'])) {
                // Log ștergerea
                DnsRecordChange::create([
                    'dns_record_id' => $record->id,
                    'dns_zone_id' => $dnsZone->id,
                    'user_id' => $user->id,
                    'ip_address' => $request->ip(),
                    'action' => 'delete',
                    'record_name' => $record->name,
                    'record_type' => $record->type,
                    'old_values' => [
                        'name' => $record->name,
                        'type' => $record->type,
                        'content' => $record->content,
                        'ttl' => $record->ttl,
                        'is_active' => $record->is_active,
                    ],
                    'new_values' => null,
                    'description' => 'Bulk delete',
                ]);

                $record->delete();
                $deleted++;
            }
        }

        return response()->json([
            'success' => true,
            'message' => "{$deleted} înregistrări au fost șterse.",
            'deleted' => $deleted
        ]);
    }
}
