Darksky\Darksky

Complexity

Total Complexity

22

Size/Duplication

Total Lines	225
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Test Coverage

Coverage

100%

Importance

Changes

0

12 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	11	1
A	forecast()	0	8	2
A	timeMachine()	0	16	2
A	getKey()	0	4	1
A	setKey()	0	4	1
A	generateRequestUrl()	0	14	2
A	generateUrlQueryString()	0	21	4
A	validateExcludes()	0	14	4
A	getLanguage()	0	4	1
A	setLanguage()	0	4	1
A	getUnits()	0	4	1
A	setUnits()	0	10	2

<?php

namespace Darksky;

/**
 * Class Darksky.
 */
class Darksky
{
    const API_BASE_URL = 'https://api.darksky.net/forecast';
    const VALID_UNITS = [
        'auto',
        'ca',
        'uk2',
        'us',
        'si',
    ];

    const VALID_EXCLUDE = [
        'currently',
        'minutely',
        'hourly',
        'daily',
        'alerts',
        'flags',
    ];

    private $key;
    private $language;
    private $units;
    private $requestMethod;

    /**
     * Darksky constructor.
     *
     * @param string $key
     * @param string $lang
     * @param string $units
     * @param RequestMethod $requestMethod
     *
     * @throws \Exception
     */
    public function __construct(
        string $key,
        string $lang = 'en',
        string $units = 'auto',
        RequestMethod $requestMethod = null
    ) {
        $this->setKey($key);
        $this->setLanguage($lang);
        $this->setUnits($units);
        $this->requestMethod = $requestMethod ?? new Get();
    }

    /**
     * @param       $latitude
     * @param       $longitude
     * @param array $exclude
     * @param bool  $extend
     *
     * @throws \Exception
     *
     * @return string
     */
    public function forecast($latitude, $longitude, array $exclude = [], $extend = false)
    {
        try {
            return $this->requestMethod->submit($this->generateRequestUrl($latitude, $longitude, $exclude, $extend));
        } catch (\Exception $e) {
            throw $e;
        }
    }

    /**
     * @param $latitude
     * @param $longitude
     * @param $time
     * @param array $exclude
     *
     * @throws \Exception
     *
     * @return bool|string
     */
    public function timeMachine($latitude, $longitude, string $time, array $exclude = [])
    {
        try {
            return $this->requestMethod->submit(
                $this->generateRequestUrl(
                    $latitude,
                    $longitude,
                    $exclude,
                    false,
                    $time
                )
            );
        } catch (\Exception $e) {
            throw $e;
        }
    }

    /**
     * @return string
     */
    public function getKey(): string
    {
        return $this->key;
    }

    /**
     * @param string $key
     */
    public function setKey(string $key)
    {
        $this->key = $key;
    }

    /**
     * @param $latitude
     * @param $longitude
     * @param array  $exclude
     * @param bool   $extend
     * @param string $time
     *
     * @throws \Exception
     *
     * @return string
     */
    private function generateRequestUrl(
        $latitude,
        $longitude,
        array $exclude = [],
        $extend = false,
        string $time = ''
    ): string {
        if (!empty($time)) {
            $time = ",{$time}";
        }

        return self::API_BASE_URL.'/'.$this->getKey().'/'.$latitude.','.$longitude.$time
            .'?'.$this->generateUrlQueryString($exclude, $extend);
    }

    /**
     * @param array $exclude
     * @param bool  $extend
     *
     * @throws \Exception
     *
     * @return string
     */
    private function generateUrlQueryString(array $exclude = [], $extend = false): string
    {
        $queryString = ['lang' => $this->getLanguage(), 'units' => $this->getUnits()];

        // validate $exclude
        if ($this->validateExcludes($exclude) !== true) {
            $validExcludes = implode(',', self::VALID_EXCLUDE);

            throw new DarkskyException("Invalid excludes. Provide valid excludes: {$validExcludes}'");
        }

        if (!empty($exclude)) {
            $queryString['exclude'] = implode(',', $exclude);
        }

        if ($extend === true) {
            $queryString['extend'] = 'hourly';
        }

        return http_build_query($queryString);
    }

    /**
     * @param $exclude
     *
     * @return bool
     */
    private function validateExcludes(array $exclude): bool
    {
        if (empty($exclude)) {
            return true;
        }

        foreach ($exclude as $anExclude) {
            if (!in_array($anExclude, self::VALID_EXCLUDE)) {
                return false;
            }
        }

        return true;
    }

    /**
     * @return string
     */
    public function getLanguage(): string
    {
        return $this->language;
    }

    /**
     * @param string $language
     */
    public function setLanguage(string $language)
    {
        $this->language = $language;
    }

    /**
     * @return string
     */
    public function getUnits(): string
    {
        return $this->units;
    }

    /**
     * @param $units
     *
     * @throws \Exception
     */
    public function setUnits(string $units)
    {
        if (!in_array($units, self::VALID_UNITS)) {
            $validUnits = implode(',', self::VALID_UNITS);

            throw new DarkskyException("'{$units}' is not a valid unit. Valid units: {$validUnits}");
        }

        $this->units = $units;
    }
}