<?php

namespace MGModule\DNSManager2\mgLibs\custom\helpers;
use MGModule\DNSManager2\mgLibs\custom\manager\LogHelper;
use MGModule\DNSManager2\mgLibs\custom\manager\RecordHelper;
use MGModule\DNSManager2 as main;
use MGModule\DNSManager2\models\custom\set;
use MGModule\DNSManager2\mgLibs\custom\helpers\ZoneLogger\Manager as ZoneLoggerManager;


/**
 * Helps to manage record sets
 *
 * @author slawomir@modulesgarden.com
 */
class RecordSetHelper
{
    /**
     * @var main\models\custom\zone\Zone
     */
    protected $zone;
    protected $package;

    /**
     * @var ZoneLoggerManager
     */
    private $zoneLoggerManager;
    
    public function __construct(\MGModule\DNSManager2\models\custom\zone\Zone $zone, ZoneLoggerManager $zoneLoggerManager)
    {
        $this->zone = $zone;
        $this->zoneLoggerManager = $zoneLoggerManager;
    }
    
    
    function getPackage()
    {
        if(empty($this->package))
        {
            $this->package = $this->zone->getPackage();
        }
        
        return $this->package;
    }

    public function addRecordSet($setId = false,$force = false,$alreadyExists = false)
    {
        if($force)
        {
            $set = new main\models\custom\set\Set($setId);
            $this->addRecords($set,$alreadyExists);
            return true;
        }
        
        $package = $this->getPackage();
         
        if($setId == 'none')
        {
            return true;
        }
        
        if($this->zone->clientid)
        {
            $checkUserSet = $this->getSpecificSet($setId);
                     
            if(!$checkUserSet )
            {
                $checkUserSet = $this->getDefaultUserSet();
            }
            
            if($checkUserSet && is_numeric($checkUserSet))
            {
                
                if($set = new main\models\custom\set\Set($checkUserSet))
                {
                    $this->addRecords($set);
                    return true;
                }
            }
        } 
        if(!$package || is_null($package))
        {
            return true;
        }
        if($set = $package->getDefaultSet())
        {
            $this->addRecords($set);

            return true;
        }
    }
    
    private function getSpecificSet($setId)
    {
        if(  is_null($setId) || $setId == 0)
        {
            return false;
        }
        
        $checkUserSet = main\mgLibs\MySQL\query::select(
                array('id','name','idu','default'), 
                'dns_manager2_set', 
                array('id' => $setId)
            )->fetch();

        if($checkUserSet['idu'] && $checkUserSet['idu'] != $this->zone->clientid)
        {
            return false;
        }
        
        $defaultSets = $this->getPackage()->getAdminSets();
        if(empty($checkUserSet['idu']) &&  !in_array( $checkUserSet['id'], $defaultSets ))
        {
            return false;
        }
        
        
        return $checkUserSet['id'];
    }
    
    private function getDefaultUserSet()
    {
        $checkUserSet = main\mgLibs\MySQL\query::select(
                array('id','name','idu','default'), 
                'dns_manager2_set', 
                array('idu' => $this->zone->clientid, 'default' => '1')
            )->fetchColumn('id');

        return $checkUserSet;
    }    
 
    private function addRecords(main\models\custom\set\Set $set,$checkIfAlreadyExists = false)
    {
        $module = $this->zone->getModule();
        $rSet = array();
        foreach($set->getRecords() as $record)
        {
            try
            {
                $zoneRecords = $this->zone->getModule()->getRecords();
                $rec = new RecordHelper($record, $this->zone,$this->getNameServers());
                if(empty($this->zone->ip)){
                    $this->zone->ip = $this->getDefaultIP();
                }
                $tempRec = $rec->toDNSRecord($this->zone->name, $this->zone->ip);   
                
                if($tempRec->type == 'SOA')
                {
                    $soaRecord = $this->getSOARecord($zoneRecords);

                    if($soaRecord)
                    {
                        $tempRec->line = $soaRecord->line;
                        $module->editRecord($tempRec);

                        $editRecords = new main\mgLibs\custom\helpers\ZoneLogger\Actions\EditRecord($tempRec, $soaRecord);
                        $this->zoneLoggerManager->logEditRecordsInZone($this->zone, $editRecords);
                        continue;
                    }
                }
                
                if($checkIfAlreadyExists)
                {
                    $alreadyExists = $this->checkIfRecordAlreadyExists($zoneRecords, $tempRec);
                    if($alreadyExists)
                    {
                        continue;
                    }
                }
                $tempRec->nameToAbsolute($this->zone->name);
                $module->addRecord($tempRec);
                $this->zoneLoggerManager->logAddRecordToZone($this->zone, $tempRec);
                $rSet[] = $tempRec;
            } 
            catch(\Exception $exc)
            {
                main\mgLibs\error\register::register($exc);
                LogHelper::addFailLogUsingZone('Add Record', $exc->getMessage(), $this->zone->id);
            }
        }
        
        if(count($rSet) > 0)
        {
            $module->removeDefaultServerRecords($rSet);
        }        
    }
    private function getDefaultIP()
    {
        $server        = new \MGModule\DNSManager2\models\custom\server\Server($this->zone->serverid);
        $configuration = $server->getModuleConfiguration();
        if (is_array($configuration))
        {
            return $configuration['default_ip'];
        }
    }
    
    private function getSOARecord(array $zoneRecords)
    {
        foreach($zoneRecords as $zoneRecord)
        {
            if($zoneRecord->type == 'SOA')
            {
                return $zoneRecord;
            }
        }
        
        return false;
    }

    private function checkIfRecordAlreadyExists(array $zoneRecords, main\mgLibs\custom\dns\record\Record $record)
    {
        foreach($zoneRecords as $zoneRecord)
        {
            if($zoneRecord->name == $record->name . '.' && $zoneRecord->type == $record->type)
            {
                $zoneRecordRDATA = get_object_vars($zoneRecord->rdata);
                $recordRDATA     = get_object_vars($record->rdata);
                if($zoneRecordRDATA == $recordRDATA)
                {
                    return true;
                }
            }
        }
        
        return false;
    }
    
    public static function checkAllowedRecordsLimits($packageID,$recordSetID,$currentRecords = NULL)
    {   
        $packageSettings    = main\models\custom\package\setting\PackageSetting::byPackageAndKey($packageID, 'allowed_record_types');
        $limits             = unserialize($packageSettings->value);
        $rep                = set\record\Repository::factory()->setFilter('setid',$recordSetID)->get();
        
        foreach($limits as $type => $value)
        {
            $count = 0;
            foreach($rep as $record)
            {
                if($record->type == $type)
                {
                    $count++;
                }
            }  
            
            if($currentRecords != NULL)
            {
                foreach($currentRecords as $currRecord)
                {
                    if($currRecord->type == $type)
                    {
                        $count++;
                    }
                }
            }

            if((int)$count > (int)$value && (int)$value !== -1)
            { 
                return false;
            }
        }
        
        return true;
    }

    public static function formatRecordsToIndexById($records = [])
    {
        $out = [];
        foreach ($records as $record)
        {
            $out[$record->line] = $record;
        }
        return $out;
    }

    private function getNameServers()
    {
        global $CONFIG;
        foreach ( range(1, 5) as $i )
        {
            if ( isset($CONFIG['DefaultNameserver' . $i]) )
            {
                $nameServers[] = $CONFIG['DefaultNameserver' . $i];
            }
        }
        return $nameServers;
    }
}