<?php

namespace MGModule\DNSManager2\mgLibs\custom\task;

use \MGModule\DNSManager2 as main;
use \MGModule\DNSManager2\mgLibs\custom\manager\GlobalSettingHelper;
use \MGModule\DNSManager2\models\custom\globalsetting\GlobalSettingEnum;
use \MGModule\DNSManager2\mgLibs\custom\manager\LogHelper;
use \MGModule\DNSManager2\models\custom\task;
use \MGModule\DNSManager2\mgLibs\custom;
use \MGModule\DNSManager2\mgLibs\custom\manager;
use MGModule\DNSManager2\helpers\WHMCS\Client;
use MGModule\DNSManager2\helpers\custom\ClientFilesManage;
use MGModule\DNSManager2\models\custom\clientfiles\Repository as ClientFilesRepository;

class Backupper extends TaskAbstract
{
    protected $abort_after_repeats = array('main' => 0);
    protected $taskTypeCode = TaskTypeCodesCodes::BACKUPPER;

    public function mainDescription()
    {
        return 'Automatic Backupper';
    }

    public function main($params)
    {
        $cron_backupper_run_each = GlobalSettingHelper::getSetting(GlobalSettingEnum::CRON_BACKUP_RUN_EACH ?: 5);

        if (!$this->isReadyToRun($cron_backupper_run_each)) {
            return true;
        }

        LogHelper::addSuccessLog('Cron Backupper', 'Cron Backupper Started');

        if ($this->getStatus() == task\TaskStatusEnum::START) {
            $this->setStatus(task\TaskStatusEnum::IN_PROGRESS);
        }

        foreach (Client::getClientsAsIdKey() as $clientID => $status) {
            if ($status['status'] == 'Active') {
                $this->deleteOldBackups($clientID);

                if($this->canCronBackup($clientID)) {
                    $this->createZoneTask($clientID);
                }
                else {
                    $cronFilesList = $this->getCronBackupList($clientID);
                    //Deleting the oldest cron backup due to the limit set - we are deleting that files to make space for newest one.
                    $this->deleteOldestCronBackupsDueLimit($clientID, $cronFilesList);
                    $this->createZoneTask($clientID);
                }

            }
        }

//        $this->setStatus(task\TaskStatusEnum::FINISHED);
        LogHelper::addSuccessLog('Cron Backupper', 'End Of Cron Backupper Run');
    }

    public function deleteOldBackups($clientID){
        $cron_backup_delete_run_after = manager\GlobalSettingHelper::getSetting(GlobalSettingEnum::CRON_BACKUP_DELETE_AFTER ?: 5);

        $fileManager = new custom\FileManager('zonesFilesStorage' . DIRECTORY_SEPARATOR . 'bulkZones');
        $filesList = ClientFilesManage::getClientFiles($clientID, 'backup');

        foreach ($filesList as $file) {
            if($file->createdby != 'client') {
                $calculations = $this->dateCalculations($file->date);
                $minutesAfter = $this->minutesFormat($calculations);

                if ($minutesAfter >= $cron_backup_delete_run_after) {
                    $task = custom\TaskManager::addTask('DeleteOldBackups:main', array('file' => $file->file, 'clientID' => $clientID), 0, $clientID);

                    ClientFilesManage::delete($clientID, $file->file);
                    $fileManager->deleteFile($file->file);

                    $task->status = task\TaskStatusEnum::FINISHED;
                    $task->save();
                }
            }
        }
    }

    public function createZoneTask($clientID){
        $fileName = custom\helpers\ImportExportFileHelper::generateClientFileName($clientID);

        $task = custom\TaskManager::addTask('ImportToFileWHMCS:main', array('from' => 'WHMCS', 'toFile' => $fileName, 'createdBy' => 'cron'), 0, $clientID);
        custom\TaskManager::getTaskObjectByID($task->id)->run(true);

        $pRep = task\Repository::factory()->byParentID((int)$task->id)->one();
        $pRepName = explode(':', $pRep->name);

        $taskZone = custom\TaskManager::getXTasks(1, $pRepName[0] . ':fetchZonesList', (int)$task->id, false);
        $taskZone = end($taskZone);

        $rep = task\result\Repository::factory()->byTaskID((int)$taskZone->id);
        $input['limit'] = $rep->count();

        $helper = new main\mgLibs\custom\RepoTableHelper($rep, $input, array('data'));

        $this->backupZonesTask($helper->get());

        $task->status = task\TaskStatusEnum::FINISHED;
        $task->save();
    }

    public function backupZonesTask($zones){
        foreach($zones as $zone){
            $task = new task\Task($zone->taskid);
            $task->status = task\TaskStatusEnum::IN_PROGRESS;
            $task->save();

            $result = new task\result\TaskResult($zone->id);
            $task = custom\TaskManager::getTaskObjectByID($result->taskid);

            $main_task = $task->getParent();

            $result->data['resultid'] = $zone->id;
            $result->data['domain']   =  $result->data['name'];
            $child = $main_task->addChild('import', $result->data);

            $result->data['status'] = 'importing';
            $result->data['taskid'] = $child->obj()->id;

            $result->save();
            $child->run();
        }
    }

    private function getCronBackupList($clientID){
        return ClientFilesRepository::factory()->byClientId($clientID)->byType('backup')->byCreatedBy('cron')->get();
    }

    private function canCronBackup($clientID){
        $cronBackupsLimit = GlobalSettingHelper::getSetting(GlobalSettingEnum::CRON_BACKUP_LIMIT);

        $cronFilesList = $this->getCronBackupList($clientID);
        $amountOfCronBackups = count($cronFilesList);

        if($amountOfCronBackups >= $cronBackupsLimit)
            return false;
        else
            return true;

    }

    private function deleteOldestCronBackupsDueLimit($clientID, $cronFilesList){
        usort($cronFilesList, function($a, $b) {
            return strtotime($a->date) - strtotime($b->date);
        });

        $fileManager = new custom\FileManager('zonesFilesStorage' . DIRECTORY_SEPARATOR . 'bulkZones');

        ClientFilesManage::delete($clientID, $cronFilesList[0]->file);
        $fileManager->deleteFile($cronFilesList[0]->file);
    }

    private function dateCalculations($backupDate){
        $now = new \DateTime(date('Y-m-d H:i:s'));
        return $now->diff(new \DateTime($backupDate));
    }

    private function minutesFormat($dateInterval){
        $minutes = $dateInterval->days * 24 * 60;
        $minutes += $dateInterval->h * 60;
        $minutes += $dateInterval->i;
        return $minutes;
    }

}