<?php

namespace CmtsBundle\Command;

use BaseStatsBundle\Command\BaseCmtsCommand;
use Symfony\Bundle\FrameworkBundle\Command\ContainerAwareCommand;
use Symfony\Component\Console\Input\InputOption;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Output\OutputInterface;
use CmtsBundle\SNMP\SNMP as SNMP;
use Symfony\Component\Yaml\Parser;

class CmtsInterfaceStatsCommand extends BaseCmtsCommand
{

    protected function configure()
    {
        $this
            ->setName('cmts:interface:stats')
            ->setDescription('Obtener Stats de Interfaces')
            ->setHelp('Se requieren parámetros para poder realizar la correcta consulta. El comando requiere Redis.')
            ->setDefinition(array(
                new InputOption('cmts-device-id', null, InputOption::VALUE_OPTIONAL, "DeviceId del CMTS",1),
                new InputOption('cmts-server-id', null, InputOption::VALUE_OPTIONAL, "ServerDevice del CMTS",1),
                new InputOption('cmts-ip', false, InputOption::VALUE_OPTIONAL, "IP del CMTS"),
                new InputOption('cmts-community', false, InputOption::VALUE_OPTIONAL, "Community del CMTS"),
                new InputOption('cmts-snmp-library', false, InputOption::VALUE_OPTIONAL, "Versión de librería SNMP"),
                new InputOption('save-historic', null, InputOption::VALUE_OPTIONAL, "Send data to StatsD",1)
            ))
        ;
    }

    /**
     * @param InputInterface $input
     * @param OutputInterface $output
     */
    protected function execute(InputInterface $input, OutputInterface $output)
    {
        parent::execute($input, $output);
        
        $key_cmts_scan = "cmts_scan_ifs_{$this->d_s}";
        $key_cm_scan = "cmts_scan_{$this->d_s}";
        $saveHistoric = (int) $input->getOption('save-historic');
        $inicio = microtime(true);
        
        $SNMP = new SNMP($this->cmtsIp, $this->cmtsCommunity);
        $library = "use".$this->cmtsSnmpLibrary;
        $this->apiSNMP = $SNMP->$library();

        $dataCached = $this->getData($key_cmts_scan, true);
        
        if(empty($dataCached)) {
            $this->output->writeln("Se requiere {$key_cmts_scan}.");
            $this->removeLock($this->flag);
            return true;
        }
        
        
        $_utilization = $this->getSNMP("docsIfCmtsChannelUtilization","cmtsIfUtilization");
        $ifStatsCached = $sendData = $utilization = array();

        foreach($_utilization as $compIndex => $value) {
            $params = explode(".",$compIndex);
            if($params > 1) {
                $index = $params[0];
                $aux = implode(".", array_slice($params,1));
            } else {
                $index = $compIndex;
                $aux = 0;
            }

            $utilization[$index] = array($aux => $value);
        }

        $microreflection = $this->getSNMP("docsIfSigQMicroreflections","cmtsIfMicroreflection");
        $signal = $this->getSNMP("docsIfSigQSignalNoise","cmtsIfSignal");

        
        $cmCached = $this->getData($key_cm_scan, true);
        $states = array();
        
        if(empty($cmCached)) {
            $this->output->writeln("Se requiere {$key_cm_scan} para obtener cantidad de CM por Interface.");
        } else {
            foreach($cmCached as $index => $value) {
                $up = $value['upInterface'];
                $down = $value['downInterface'];
                $state = $value['status'];

                if(!isset($states[$up])) $states[$up] = array(0 => 0, 1 => 0);
                if(!isset($states[$down])) $states[$down] = array(0 => 0, 1 => 0);

                $states[$up][$state]++;
                $states[$down][$state]++;

                $mac = strtolower($value['mac']);
                $sendData["cm_status_{$mac}"] = "{$state}|g";
            }
        }

        $subId = $this->d_s;
        $metrics = array("utilization" => "{$subId}_if_utilization_", "microreflection" => "{$subId}_if_microreflection_", "signal" => "{$subId}_if_signal_", "states" => "{$subId}_if_state_");
        $countIfs = 0;

        foreach($dataCached as $index => $interface) {
            $countIfs++;
            $stats = array();
            
            foreach($metrics as $data => $metric) {

                if(!isset($$data[$index])) continue;

                $m = "{$metric}{$index}";

                if($data == "signal") {
                    $v = $$data[$index] * 0.1;
                    $sendData[$m] = "{$v}|g";
                } elseif($data == "utilization") {
                    foreach($$data[$index] as $aux => $v) {
                        $sendData["{$m}.{$aux}"] = "{$v}|g";
                    }
                    $v = $$data[$index];
                } elseif($data == "states") {
                    $v = $$data[$index];
                    $on = "{$subId}_if_state_on_{$index}";
                    $off = "{$subId}_if_state_off_{$index}";
                    
                    $sendData[$on] = "{$v[1]}|g";
                    $sendData[$off] = "{$v[0]}|g";
                } else {
                    $v = $$data[$index];
                }
                
                $stats[$data] = $v;
            }
            $ifStatsCached[$index] = $stats;
        }

        $this->octets($ifStatsCached, $dataCached, $saveHistoric);

        if($ifStatsCached) {
            $key_ifs_stats = "cmts_stats_ifs_{$this->d_s}";
            $this->setData($key_ifs_stats, $ifStatsCached, true);
        }

        if($sendData && $saveHistoric) {
            $t_start_script = microtime(true); 
            $statsdService = $this->getContainer()->get('statsd');
            $statsdService->send($sendData);
            $t_end_script = microtime(true); 
            $time = $t_end_script - $t_start_script;
            print_r("Tiempo de envío al StatsD: {$time} ms / Cantidad: ".count($sendData).PHP_EOL);
        }
        

        /* Fin de bloqueo */
        $this->removeLock($this->flag);

        $fin = microtime(true);
        $time = $fin - $inicio;
        $this->output->writeln("Tiempo: $time segundos / Cantidad Interfaces: {$countIfs}");
    }

    private function octets(&$ifStatsCached, $dataCached, $saveHistoric) {

        $inOctets = $this->getSNMP("inOctets","cmtsIfInOctets");
        $outOctets = $this->getSNMP("outOctets","cmtsIfOutOctets");

        $key_cmts_ifs_bandwidth = "cmts_bandwidth_ifs_{$this->d_s}";
        $bandwidthCached = $this->getData($key_cmts_ifs_bandwidth, true);
        if(empty($bandwidthCached)) $bandwidthCached = array();

        $t1 = time();
        $totalConsOut = $totalConsIn = $totalIn = $totalOut = 0;
        $sendData = array(); $subId = $this->d_s;

        foreach($dataCached as $index => $data) {
            
            (isset($inOctets[$index]))? $in1 = $inOctets[$index] : $in1 = 0;
            (isset($outOctets[$index]))? $out1 = $outOctets[$index] : $out1 = 0;

            if(isset($ifStatsCached[$index])) {
                $ifStatsCached[$index]['inOctets'] = 0;
                $ifStatsCached[$index]['outOctets'] = 0;
            }

            if(isset($bandwidthCached[$index])) {
                $t0 = $bandwidthCached[$index]['t'];
                $in0 = $bandwidthCached[$index]['inOct'];
                $out0 = $bandwidthCached[$index]['outOct'];
                $inAcc = $bandwidthCached[$index]['inAcc'];
                $outAcc = $bandwidthCached[$index]['outAcc'];

                $inBandwidth = $outBandwidth = 0; 
                 
                if(($in1 >= $in0) && ($t1 > $t0)) {
                    $diff = $in1 - $in0;
                    $inAcc += $diff;
                    $inBandwidth = ($diff / ($t1 - $t0)) * 8;
                }

                if(($out1 >= $out0) && ($t1 > $t0)) {
                    $diff = $out1 - $out0;
                    $outAcc += $diff;
                    $outBandwidth = ($diff / ($t1 - $t0)) * 8;
                }

                $totalIn += $inBandwidth;
                $totalOut += $outBandwidth;

                $sendData["{$subId}_inbandwidth_if_{$index}"] = "{$inBandwidth}|g";
                $sendData["{$subId}_outbandwidth_if_{$index}"] = "{$outBandwidth}|g";

                if(date("d",$t0) != date("d",$t1)) {
                    $inAcc = $outAcc = 0;
                }

                $totalConsOut += $outAcc;
                $totalConsIn += $inAcc;
                
                $bandwidthCached[$index] = array('t' => $t1, 'inOct' => $in1, 'outOct' => $out1, 'inAcc' => $inAcc, 'outAcc' => $outAcc, 'inBand' => $inBandwidth, 'outBand' => $outBandwidth);

                if(isset($ifStatsCached[$index])) {
                    $ifStatsCached[$index]['inOctets'] = $inBandwidth;
                    $ifStatsCached[$index]['outOctets'] = $outBandwidth;
                }
            } else {
                $bandwidthCached[$index] = array('t' => $t1, 'inOct' => $in1, 'outOct' => $out1, 'inAcc' => 0, 'outAcc' => 0, 'inBand' => 0, 'outBand' => 0);
            }
        }

        $this->setData($key_cmts_ifs_bandwidth, $bandwidthCached, true);
        
        $cmtsBandwidth = array();
        $cmtsBandwidth["{$subId}_inbandwidth_cmts"] = "{$totalIn}|g";
        $cmtsBandwidth["{$subId}_outbandwidth_cmts"] = "{$totalOut}|g";
        
        $div = 1073741824; //bytes => giga
        $consIn = number_format(($totalConsIn / $div),3);
        $consOut = number_format(($totalConsOut / $div),3);
        $cmtsConsumption = array();
        $cmtsConsumption["{$subId}_inconsumption_cmts"] = "{$consIn}|g";
        $cmtsConsumption["{$subId}_outconsumption_cmts"] = "{$consOut}|g";

        $statsdService = $this->getContainer()->get('statsd');
        $statsdService->send($cmtsBandwidth);
        $statsdService->send($cmtsConsumption);
        
        if($sendData && $saveHistoric) {
            $t_start_script = microtime(true); 
            $statsdService->send($sendData);
            $t_end_script = microtime(true); 
            $time = $t_end_script - $t_start_script;
            print_r("Tiempo de envío de Octets al StatsD: {$time} ms / Cantidad: ".count($sendData).PHP_EOL);
        }
        
    }

}