<?php

declare(strict_types=1);

namespace org\wplake\advanced_views;

use DateTime;
use org\wplake\advanced_views\Common\SafeArrayArguments;

defined('ABSPATH') || exit;

class Settings
{
    use SafeArrayArguments;

    protected Options $options;

    protected string $version;
    protected string $license;
    protected string $licenseExpiration;
    /**
     * @var array<string, mixed>
     */
    protected array $demoImport;
    protected string $licenseUsedDomains;
    protected string $licenseUsedDevDomains;
    protected bool $isDevMode;
    /**
     * @var array<int, array{id:string,accessToken:string, name:string}>
     */
    protected array $gitRepositories;

    public function __construct(Options $options)
    {
        $this->options = $options;

        $this->version = '';
        $this->license = '';
        $this->licenseExpiration = '';
        $this->licenseUsedDomains = '';
        $this->licenseUsedDevDomains = '';
        $this->demoImport = [];
        $this->isDevMode = false;
        $this->gitRepositories = [];
    }

    /**
     * @param array<int, mixed> $gitRepositories
     * @return array<int, array{id:string,accessToken:string, name:string}>
     */
    protected function validateGitRepositoryArray(array $gitRepositories): array
    {
        $validGitRepositories = [];

        foreach ($gitRepositories as $gitRepository) {
            if (false === is_array($gitRepository) ||
                false === key_exists('id', $gitRepository) ||
                false === key_exists('accessToken', $gitRepository) ||
                false === key_exists('name', $gitRepository)) {
                continue;
            }

            $validGitRepositories[] = [
                'id' => $this->getStringArg('id', $gitRepository),
                'accessToken' => $this->getStringArg('accessToken', $gitRepository),
                'name' => $this->getStringArg('name', $gitRepository),
            ];
        }

        return $validGitRepositories;
    }

    public function load(): void
    {
        $optionSettings = $this->options->getOption(Options::OPTION_SETTINGS);
        $settings = is_array($optionSettings) ?
            $optionSettings :
            [];

        if (true === isset($settings['version'])) {
            $this->version = (string)$settings['version'];
        }

        if (true === isset($settings['license'])) {
            $this->license = (string)$settings['license'];
        }

        if (true === isset($settings['licenseExpiration'])) {
            $this->licenseExpiration = (string)$settings['licenseExpiration'];
        }

        if (true === isset($settings['licenseUsedDomains'])) {
            $this->licenseUsedDomains = (string)$settings['licenseUsedDomains'];
        }

        if (true === isset($settings['licenseUsedDevDomains'])) {
            $this->licenseUsedDevDomains = (string)$settings['licenseUsedDevDomains'];
        }

        if (true === isset($settings['demoImport'])) {
            $this->demoImport = (array)$settings['demoImport'];
        }

        if (true === isset($settings['isDevMode'])) {
            $this->isDevMode = (bool)$settings['isDevMode'];
        }

        if (true === isset($settings['gitRepositories'])) {
            $this->gitRepositories = true === is_array($settings['gitRepositories']) ?
                $this->validateGitRepositoryArray($settings['gitRepositories']) :
                [];
        }
    }

    public function save(): void
    {
        $settings = [
            'version' => $this->version,
            'license' => $this->license,
            'licenseExpiration' => $this->licenseExpiration,
            'licenseUsedDomains' => $this->licenseUsedDomains,
            'licenseUsedDevDomains' => $this->licenseUsedDevDomains,
            'demoImport' => $this->demoImport,
            'isDevMode' => $this->isDevMode,
            'gitRepositories' => $this->gitRepositories,
        ];

        $this->options->updateOption(Options::OPTION_SETTINGS, $settings);
    }

    //// setters / getters

    public function setVersion(string $version): void
    {
        $this->version = $version;
    }

    public function getVersion(): string
    {
        return $this->version;
    }

    public function setLicense(string $license): void
    {
        $this->license = $license;
    }

    public function getLicense(): string
    {
        return $this->license;
    }

    public function isLicenseExpired(): bool
    {
        if ('' === $this->licenseExpiration) {
            return false;
        }

        $expirationDate = DateTime::createFromFormat('Ymd', $this->licenseExpiration);

        if (false === $expirationDate) {
            return false;
        }

        return $expirationDate < new DateTime();
    }

    public function isLicenseExpiresWithinMonth(): bool
    {
        if ('' === $this->licenseExpiration) {
            return false;
        }

        $expirationDate = DateTime::createFromFormat('Ymd', $this->licenseExpiration);

        if (false === $expirationDate) {
            return false;
        }

        $month = new DateTime();
        $month->modify('+1 month');

        return $expirationDate < $month;
    }

    public function isActiveLicense(): bool
    {
        return '' !== $this->license &&
            '' !== $this->licenseExpiration &&
            !$this->isLicenseExpired();
    }

    public function setLicenseExpiration(string $licenseExpiration): void
    {
        $this->licenseExpiration = $licenseExpiration;
    }

    public function getLicenseExpiration(string $format = ''): string
    {
        if ('' === $format ||
            '' === $this->licenseExpiration) {
            return $this->licenseExpiration;
        }

        $expiration = DateTime::createFromFormat('Ymd', $this->licenseExpiration);

        if (false === $expiration) {
            return '';
        }

        return $expiration->format($format);
    }

    public function setLicenseUsedDomains(string $licenseUsedDomains): void
    {
        $this->licenseUsedDomains = $licenseUsedDomains;
    }

    public function getLicenseUsedDomains(): string
    {
        return $this->licenseUsedDomains;
    }

    public function setLicenseUsedDevDomains(string $licenseUsedDevDomains): void
    {
        $this->licenseUsedDevDomains = $licenseUsedDevDomains;
    }

    public function getLicenseUsedDevDomains(): string
    {
        return $this->licenseUsedDevDomains;
    }

    /**
     * @return  array<int, array{id:string, accessToken:string, name:string}>
     */
    public function getGitRepositories(): array
    {
        return $this->gitRepositories;
    }

    /**
     * @return array{id:string, accessToken:string, name:string}
     */
    public function getGitRepositoryInfoById(string $repositoryId): ?array
    {
        foreach ($this->getGitRepositories() as $gitRepository) {
            if ($gitRepository['id'] !== $repositoryId) {
                continue;
            }

            return $gitRepository;
        }

        return null;
    }

    ////

    /**
     * @param array<string,mixed> $demoImport
     */
    public function setDemoImport(array $demoImport): void
    {
        $this->demoImport = $demoImport;
    }

    /**
     * @return array<string,mixed>
     */
    public function getDemoImport(): array
    {
        return $this->demoImport;
    }

    public function isDevMode(): bool
    {
        return $this->isDevMode;
    }

    public function setIsDevMode(bool $isDevMode): void
    {
        $this->isDevMode = $isDevMode;
    }

    /**
     * @param array<int, array{id:string, accessToken:string, name:string}> $gitRepositories
     */
    public function setGitRepositories(array $gitRepositories): void
    {
        $this->gitRepositories = $this->validateGitRepositoryArray($gitRepositories);
    }
}