<?php

namespace App\Console\Commands;

use Illuminate\Console\Command;
use App\Models\DnsZone;
use App\Models\DnsStatistic;
use App\Models\DnsQueryUsage;
use App\Services\PowerDnsService;
use Carbon\Carbon;

class SyncPowerDnsStatistics extends Command
{
    /**
     * The name and signature of the console command.
     *
     * @var string
     */
    protected $signature = 'dns:sync-powerdns-stats {--days=7 : Number of days to sync} {--zone= : Specific zone to sync}';

    /**
     * The console command description.
     *
     * @var string
     */
    protected $description = 'Sincronizează statisticile PowerDNS în baza de date locală';

    protected $powerDnsService;

    public function __construct(PowerDnsService $powerDnsService)
    {
        parent::__construct();
        $this->powerDnsService = $powerDnsService;
    }

    /**
     * Execute the console command.
     */
    public function handle()
    {
        $this->info('🔄 Sincronizare Statistici PowerDNS...');
        
        $days = $this->option('days');
        $zoneName = $this->option('zone');
        
        // Obține zonele de sincronizat
        if ($zoneName) {
            $zones = DnsZone::where('domain', $zoneName)
                ->where('sync_to_powerdns', true)
                ->get();
        } else {
            $zones = DnsZone::where('sync_to_powerdns', true)->get();
        }
        
        if ($zones->isEmpty()) {
            $this->warn('⚠️  Nu există zone DNS sincronizate cu PowerDNS!');
            return 1;
        }
        
        $this->info("📊 Procesare {$zones->count()} zone DNS...\n");
        
        $bar = $this->output->createProgressBar($zones->count());
        $bar->start();
        
        $totalSynced = 0;
        $totalQueries = 0;
        
        foreach ($zones as $zone) {
            try {
                // Obține statistici din PowerDNS pentru ultimele X zile
                $stats = $this->powerDnsService->getZoneStats($zone->domain);
                
                if (!$stats || !isset($stats['statistics'])) {
                    $bar->advance();
                    continue;
                }
                
                // Procesează statisticile pentru fiecare zi
                $startDate = Carbon::now()->subDays($days);
                
                for ($i = 0; $i < $days; $i++) {
                    $date = $startDate->copy()->addDays($i);
                    
                    // Simulare: în realitate ar trebui să obții statistici pe zi din PowerDNS
                    // PowerDNS nu oferă statistici istorice detaliate, deci vom folosi datele curente
                    $dailyQueries = isset($stats['statistics']['query-count']) 
                        ? intval($stats['statistics']['query-count'] / $days) 
                        : 0;
                    
                    if ($dailyQueries > 0) {
                        // Salvează sau actualizează statisticile
                        $statistic = DnsStatistic::updateOrCreate(
                            [
                                'dns_zone_id' => $zone->id,
                                'date' => $date->format('Y-m-d'),
                            ],
                            [
                                'query_count' => $dailyQueries,
                                'query_types' => $this->extractQueryTypes($stats),
                                'response_codes' => $this->extractResponseCodes($stats),
                                'top_clients' => [],
                            ]
                        );
                        
                        $totalQueries += $dailyQueries;
                        $totalSynced++;
                    }
                }
                
                // Actualizează și usage-ul utilizatorului pentru luna curentă
                $this->updateUserQueryUsage($zone);
                
            } catch (\Exception $e) {
                $this->error("\n❌ Eroare la sincronizarea {$zone->domain}: " . $e->getMessage());
            }
            
            $bar->advance();
        }
        
        $bar->finish();
        
        $this->newLine(2);
        $this->info("✅ Sincronizare completă!");
        $this->info("📈 Total înregistrări sincronizate: {$totalSynced}");
        $this->info("🔢 Total query-uri: " . number_format($totalQueries));
        
        return 0;
    }

    /**
     * Actualizează usage-ul de query-uri pentru utilizator
     */
    protected function updateUserQueryUsage($zone)
    {
        $user = $zone->user;
        
        // Sari peste admins
        if ($user->isAdmin()) {
            return;
        }
        
        // Calculează total query-uri pentru luna curentă
        $totalQueries = DnsStatistic::where('dns_zone_id', $zone->id)
            ->forMonth(date('Y'), date('n'))
            ->sum('query_count');
        
        if ($totalQueries > 0) {
            // Obține toate zonele utilizatorului
            $allZones = $user->dnsZones()->pluck('id');
            
            // Calculează total pentru toate zonele
            $userTotalQueries = DnsStatistic::whereIn('dns_zone_id', $allZones)
                ->forMonth(date('Y'), date('n'))
                ->sum('query_count');
            
            // Actualizează usage
            DnsQueryUsage::updateOrCreate(
                [
                    'user_id' => $user->id,
                    'year' => date('Y'),
                    'month' => date('n'),
                ],
                [
                    'query_count' => $userTotalQueries,
                ]
            );
        }
    }

    /**
     * Extrage tipurile de query-uri din statistici
     */
    protected function extractQueryTypes($stats)
    {
        // PowerDNS oferă statistici pe tipuri de query
        // Aici ar trebui să extragi datele reale
        return [
            'A' => 0,
            'AAAA' => 0,
            'MX' => 0,
            'TXT' => 0,
            'NS' => 0,
        ];
    }

    /**
     * Extrage codurile de răspuns din statistici
     */
    protected function extractResponseCodes($stats)
    {
        return [
            'NOERROR' => 0,
            'NXDOMAIN' => 0,
            'SERVFAIL' => 0,
        ];
    }
}
