<?php

namespace MGModule\DNSManager2\mgLibs\custom\dns\submodules\AWSRoute53;
use \MGModule\DNSManager2\mgLibs\custom\dns;

class AWSRoute53ResponseParseHelper
{
    public static function zoneListXmlToArray($xmlList)
    {
        $zonesList = array();
        
        foreach($xmlList->HostedZones->children() as $zone)
        {
            $zonesList[$zone->Name->__toString()] = '';
        }

        return $zonesList;
    }
    
    public static function findZoneOnZoneList($xmlList, $domain)
    {
        foreach($xmlList->HostedZones->children() as $zone)
        {
            $zoneName = $zone->Name->__toString();
            if($zoneName === $domain || trim($zoneName, '.') === $domain)
            {   
                return $zone->Id->__toString();
            }
        }

        return false;
    }
    
    public static function checkResponseForErrors($xmlResponse)
    {
        if($xmlResponse->Error)
        {
            return array(
                'code' => $xmlResponse->Error->Code->__toString(), 
                'message' => $xmlResponse->Error->Message->__toString(), 
                'type' => $xmlResponse->Error->Type->__toString()
            );
        }
        
        return false;
    }
    
    public static function prepareRecordList($xmlRecordsList, $availableRecordTypes = array(), $editSoa = false)
    { 
        $recordList = array();
        foreach($xmlRecordsList->ResourceRecordSets->children() as $aRecord)
        {
            $rType = self::getRecordType($aRecord);
            if(!$editSoa && $rType == 'SOA')
            {
                continue;
            }

            if(in_array($rType, $availableRecordTypes))
            {
                $record = new dns\record\Record();
                $record->name = $aRecord->Name->__toString();
                $record->type = $rType;
                $record->ttl  = $aRecord->TTL->__toString();
                $record->createRDATAObject();

                switch($rType)
                {
                    case 'ALIAS':
                            $record->rdata->fromString(self::parseRDataForALIASRecords($aRecord->AliasTarget)); 
                            $recordList[] = $record;
                        break;
                    case 'MX':
                            self::parseMultihostRecords($recordList, $record, $aRecord);
                        break;
                    case 'NS':   
                            self::parseMultihostRecords($recordList, $record, $aRecord); 
                        break;
                    case 'A':   
                            self::parseMultihostRecords($recordList, $record, $aRecord);
                        break;
                    case 'AAAA':   
                            self::parseMultihostRecords($recordList, $record, $aRecord);
                        break;                    
                    default:
                            $record->rdata->fromString(self::parseRData($aRecord->ResourceRecords));
                            $recordList[] = $record;
                        break;
                }
            }   
        }
        
        return $recordList;
    }
    
    public static function parseRData($xmlRData)
    {
        $parsed = '';
        foreach($xmlRData->children() as $rdata)
        {
            $parsed .= ($parsed === '' ? '' : ' ').$rdata->Value->__toString();
        }

        return $parsed;
    }
    
    public static function getZoneIdFromCreateConfirmation($xmlRData)
    {
        return $xmlRData->HostedZone->Id->__toString();
    }
    
    public static function findPtrRecordByName($xmlRecordsList, $recordName)
    {
        foreach($xmlRecordsList->ResourceRecordSets->children() as $aRecord)
        {
            $rType = $aRecord->Type->__toString();
            if($rType !== 'PTR')
            {
                continue;
            }
            
            $rName = $aRecord->Name->__toString();
            $trName = trim($rName, '.');
            if($rName === $recordName || $trName === $recordName)
            {
                $record = new dns\record\Record();
                $record->name = $rName;
                $record->type = $rType;
                $record->ttl  = $aRecord->TTL->__toString();
                $record->createRDATAObject();
                $record->rdata->fromString(self::parseRData($aRecord->ResourceRecords));
                
                return $record;
            }
        }
        
        return false;
    }
    
    public static function parseRDataForALIASRecords($xmlRData)
    {
        return $xmlRData->DNSName->__toString();
    }
    
    public static function getRecordType($xmlRecord)
    {
        $rType = $xmlRecord->Type->__toString();
        if(($rType === 'A' || $rType === 'AAAA') && $xmlRecord->AliasTarget)
        {
            $rType = 'ALIAS';
        }
        
        return $rType;
    }
    
    public static function parseMultihostRecords(&$recordList, $record, $xmlData)
    {
        foreach($xmlData->ResourceRecords->children() as $host)
        {
            $cRecord = clone $record;
            $cRecord->createRDATAObject($cRecord->type);

            self::parseHostValueToRdata($cRecord, $host->Value->__toString());

            $recordList[] = $cRecord;             
        }   
    }
    
    public static function parseHostValueToRdata(&$cRecord, $hostValue)
    {
        switch($cRecord->type)
        {
            case 'MX':
                $hData = explode(' ', $hostValue);
                $cRecord->rdata->setDataFromArray(array(
                    'preference' => $hData[0],
                    'exchange' => $hData[1]                
                ));
                break;
            
            default:
                $cRecord->rdata->setFirstProperty($hostValue);
                break;
        }
    }
    
    public static function convertInputFormData(&$input)
    {
        foreach($input['edit_record'] as &$editedRec)
        {
            $toEdit = self::findRecordsByName($input['edit_record'], $editedRec, true);
            self::mergeRecords($editedRec, $toEdit, $edit);
            $toEdit = self::findRecordsByName($input['record'], $editedRec, true);
            self::mergeRecords($editedRec, $toEdit);
        }
    }
    
    public static function findRecordsByName(&$records, $editedRec, $edit = false)
    {
        $foundRecords = array();
        foreach($records as $key => $record)
        {
            if($record['name'] === $editedRec['name'] && $record['type'] === $editedRec['type'] && $record['field'] !== $editedRec['field'])
            {
                $foundRecords[] = $record;
                if($edit)
                {
                    unset($records[$key]);
                }
            }
        }
        
        return $foundRecords;
    }
    
    public static function mergeRecords(&$editRecord, $toEditList)
    {
        foreach($toEditList as $editValue)
        {
            self::mergeHostsRecords($editRecord['field'], $editValue['field'], $editRecord['type']);
        }   
    }
    
    public static function mergeHostsRecords(&$editRecord, $addToEdit, $type)
    {
        switch($type)
        {
            case 'MX':
                if($editRecord['preference'])
                {
                    $editRecord['exchange'] = $editRecord['preference'].' '.$editRecord['exchange'];
                    $editRecord['preference'] = false;
                }
                $editRecord['exchange'] .= PHP_EOL.$addToEdit['preference'].' '.$addToEdit['exchange'];
                break;
            case 'NS':   
                    $editRecord['nsdname'] .= PHP_EOL.$addToEdit['nsdname'];
                break;
            case 'A':   
                    $editRecord['address'] .= PHP_EOL.$addToEdit['address'];
                break;
            case 'AAAA':   
                    $editRecord['address'] .= PHP_EOL.$addToEdit['address'];
                break;
        }
    }   
    
    public static function mergeHostsRecordsForRdata(&$editRecord, $addToEdit, $type)
    {
        if($editRecord->rdata == null)
        {
            $editRecord->createRDATAObject($editRecord->type);
        }
        
        switch($type)
        {
            case 'MX':
                
                if($editRecord->rdata->preference)
                {
                    $editRecord->rdata->exchange = $editRecord->rdata->preference.' '.$editRecord->rdata->exchange;
                    $editRecord->rdata->preference = false;
                }
                $editRecord->rdata->exchange = $editRecord->rdata->exchange ?  $editRecord->rdata->exchange.PHP_EOL.$addToEdit->rdata->preference.' '.$addToEdit->rdata->exchange
                    : $addToEdit->rdata->preference.' '.$addToEdit->rdata->exchange;
                break;
            case 'NS':   
                    $editRecord->rdata->nsdname = $editRecord->rdata->nsdname ? $editRecord->rdata->nsdname.PHP_EOL.$addToEdit->rdata->nsdname
                    : $addToEdit->rdata->nsdname;
                break;
            case 'A':   
                    $editRecord->rdata->address = $editRecord->rdata->address ? $editRecord->rdata->address.PHP_EOL.$addToEdit->rdata->address
                    : $addToEdit->rdata->address;
                break;
            case 'AAAA':   
                    $editRecord->rdata->address = $editRecord->rdata->address ? $editRecord->rdata->address.PHP_EOL.$addToEdit->rdata->address
                    : $addToEdit->rdata->address;
                break;
        }
    }     
}