<?php


namespace AcyChecker\Services;


use AcyChecker\Classes\TestClass;
use AcyChecker\Libraries\AcycObject;
use AcyCheckerCmsServices\Language;
use AcyCheckerCmsServices\Message;
use AcyCheckerCmsServices\Url;


class ApiService extends AcycObject
{
    private $apiBaseUrl;
    private $apiKey;
    public $errors = [];

    public function __construct()
    {
        parent::__construct();

        $this->apiKey = $this->config->get('license_key');
        $this->apiBaseUrl = ACYC_API_URL;
    }

    private function processRequest($url, $header, $data = [], $type = 'GET', $options = [])
    {
        if (ACYC_CMS === 'joomla') {
            require_once ACYC_BACK.'vendor'.DS.'rmccue'.DS.'requests'.DS.'library'.DS.'Requests.php';
            \Requests::register_autoloader();
        }

        try {
            $request = \Requests::request($url, $header, $type == 'GET' ? $data : json_encode($data), $type, $options);
        } catch (\Requests_Exception $exception) {
            $this->errors[] = $exception->getMessage();

            return false;
        }

        $request->body = json_decode($request->body, true);

        return $request;
    }

    private function getDefaultHeaders()
    {
        return [
            'Accept' => 'application/json',
            'Content-Type' => 'application/json',
            'API-KEY' => $this->apiKey,
            'Source' => 'plugin',
            'Source-Version' => '1.0.1',
        ];
    }

    public function getCredits()
    {
        $url = $this->apiBaseUrl.'api/v1/licenses/credits';

        $request = $this->processRequest($url, $this->getDefaultHeaders());
        if (!empty($this->errors)) {
            Message::enqueueMessage(implode(', ', $this->errors), 'error');
        }

        if (!$request) {
            return $this->returnResponse(__('Could not call the api', 'acychecker'), [], false);
        }

        if ($request->status_code !== 200) {
            if (isset($request->body['message'])) {
                return $this->returnResponse($request->body['message'], [], false);
            } else {
                return $this->returnResponse(
                    sprintf(__('Error while calling the API (code %s)', 'acychecker'), $request->status_code),
                    [],
                    false
                );
            }
        }


        return $this->returnResponse('', $request->body);
    }

    public function dispatchBatch($emails)
    {
        if (empty($emails)) {
            return $this->returnResponse(__('Invalid email address', 'acychecker'), [], false);
        }

        $url = $this->apiBaseUrl.'api/v1/bulk_verify/';

        $data = [
            'emails' => $emails,
            'callbackUrl' => Url::frontendLink('callbackController'),
        ];

        $request = $this->processRequest($url, $this->getDefaultHeaders(), $data, 'POST');

        if (!$request) {
            return $this->returnResponse(__('Could not call the api', 'acychecker'), [], false);
        }

        //Not enough credits
        if ($request->status_code === 403) {
            return $this->returnResponse(__('Not enough credits to run this test', 'acychecker'), [], false);
        } elseif ($request->status_code !== 201) {
            return $this->returnResponse($request->body['detail'], [], false);
        }

        return $this->returnResponse('', $request->body);
    }

    private function returnResponse($message = '', $data = [], $success = true)
    {
        return [
            'message' => $message,
            'data' => $data,
            'success' => $success,
        ];
    }

    public function testEmail($email, $conditions)
    {
        $result = $this->getEmailResult($email);

        if ($result['success'] === false) {
            // An error occurred while testing the email address, no credits left for example, don't block the subscription
            return true;
        }

        $conditions = explode(',', $conditions);

        $emailOk = $this->isEmailAccepted($result['data'], $conditions);

        $this->saveTest($result['data'], $emailOk);

        return $emailOk;
    }

    public function isEmailAccepted($emailResult, $conditions)
    {
        if (in_array('domain_not_exists', $conditions) && !$emailResult['domain_exists']) {
            return 'domain_not_exists';
        }

        if (in_array('invalid_smtp', $conditions) && $emailResult['email_exists'] === 'not_existing') {
            return 'invalid_smtp';
        }

        foreach (
            [
                'disposable' => 'disposable',
                'accept_all' => 'accept_all',
                'free_domain' => 'free_mailbox',
                'role_based' => 'role_based_address',
            ] as $acycName => $apiName
        ) {
            if (in_array($acycName, $conditions) && $emailResult[$apiName]) {
                return $acycName;
            }
        }

        return true;
    }

    private function getEmailResult($email)
    {
        $url = $this->apiBaseUrl.'api/v1/email_verify/'.$email;

        $request = $this->processRequest($url, $this->getDefaultHeaders());

        if (!$request) {
            $message = __('Could not call the api', 'acychecker');
            if (!empty($this->errors)) $message = implode(', ', $this->errors);
            DebugService::logMessage('individual_tests.log', $email.' - '.$message);

            return [
                'success' => false,
                'message' => __('Could not call the api', 'acychecker'),
            ];
        }

        if ($request->status_code !== 200) {
            if (isset($request->body['message'])) {
                $message = $request->body['message'];
            } else {
                $message = sprintf(__('Error while calling the API (code %s)', 'acychecker'), $request->status_code);
            }
            DebugService::logMessage('individual_tests.log', $email.' - '.$message);

            return [
                'success' => false,
                'message' => $message,
            ];
        }

        return [
            'success' => true,
            'data' => $request->body['data'],
        ];
    }

    private function saveTest($result, $emailOk)
    {
        $dateTimeNow = new \DateTime('NOW');
        $dateTimeNow->setTimezone(new \DateTimeZone('UTC'));

        $test = new \stdClass();

        $test->email = $result['email'];
        $test->date = $dateTimeNow->format('Y-m-d H:i:s');
        $test->raw_result = json_encode($result);
        $test->final_status = $result['email_exists'];
        $test->disposable = $result['disposable'] ? 1 : 0;
        $test->free = $result['free_mailbox'] ? 1 : 0;
        $test->accept_all = $result['accept_all'] ? 1 : 0;
        $test->role_email = $result['role_based_address'] ? 1 : 0;
        $test->status = 1;
        $test->block_reason = $emailOk === true ? 'NULL' : $emailOk;

        $testClass = new TestClass();
        $testClass->save($test);
    }

    public function refreshCreditsUsed()
    {
        $result = $this->getCredits();

        if ($result['success']) {
            $newConfig = [
                'credits_used_batch' => $result['data']['credits_used_batch'],
                'remaining_credits_batch' => $result['data']['remaining_credits_batch'],
                'credits_used_simple' => $result['data']['credits_used_simple'],
                'remaining_credits_simple' => $result['data']['remaining_credits_simple'],
                'license_last_check' => time(),
                'license_end_date' => $result['data']['end_date'],
            ];
            $this->config->save($newConfig);
        } else {
            Message::enqueueMessage($result['message'], 'error');
        }
    }
}