<?php

declare (strict_types=1);
namespace DynamicOOOS\PHPHtmlParser;

use DynamicOOOS\GuzzleHttp\Psr7\Request;
use DynamicOOOS\GuzzleHttp\Client;
use DynamicOOOS\PHPHtmlParser\Contracts\Dom\CleanerInterface;
use DynamicOOOS\PHPHtmlParser\Contracts\Dom\ParserInterface;
use DynamicOOOS\PHPHtmlParser\Contracts\DomInterface;
use DynamicOOOS\PHPHtmlParser\Discovery\CleanerDiscovery;
use DynamicOOOS\PHPHtmlParser\Discovery\DomParserDiscovery;
use DynamicOOOS\PHPHtmlParser\Dom\Node\Collection;
use DynamicOOOS\PHPHtmlParser\Dom\RootAccessTrait;
use DynamicOOOS\PHPHtmlParser\Exceptions\ChildNotFoundException;
use DynamicOOOS\PHPHtmlParser\Exceptions\CircularException;
use DynamicOOOS\PHPHtmlParser\Exceptions\LogicalException;
use DynamicOOOS\PHPHtmlParser\Exceptions\NotLoadedException;
use DynamicOOOS\PHPHtmlParser\Exceptions\StrictException;
use DynamicOOOS\PHPHtmlParser\Exceptions\UnknownChildTypeException;
use DynamicOOOS\Psr\Http\Client\ClientExceptionInterface;
use DynamicOOOS\Psr\Http\Client\ClientInterface;
use DynamicOOOS\Psr\Http\Message\RequestInterface;
/**
 * Class Dom.
 */
class Dom implements DomInterface
{
    use RootAccessTrait;
    /**
     * The charset we would like the output to be in.
     *
     * @var string
     */
    private $defaultCharset = 'UTF-8';
    /**
     * The document string.
     *
     * @var Content
     */
    private $content;
    /**
     * A global options array to be used by all load calls.
     *
     * @var ?Options
     */
    private $globalOptions;
    /**
     * @var ParserInterface
     */
    private $domParser;
    /**
     * @var CleanerInterface
     */
    private $domCleaner;
    public function __construct(?ParserInterface $domParser = null, ?CleanerInterface $domCleaner = null)
    {
        if ($domParser === null) {
            $domParser = DomParserDiscovery::find();
        }
        if ($domCleaner === null) {
            $domCleaner = CleanerDiscovery::find();
        }
        $this->domParser = $domParser;
        $this->domCleaner = $domCleaner;
    }
    /**
     * Returns the inner html of the root node.
     *
     * @throws ChildNotFoundException
     * @throws UnknownChildTypeException
     * @throws NotLoadedException
     */
    public function __toString() : string
    {
        $this->isLoaded();
        return $this->root->innerHtml();
    }
    /**
     * Loads the dom from a document file/url.
     *
     * @throws ChildNotFoundException
     * @throws CircularException
     * @throws Exceptions\ContentLengthException
     * @throws LogicalException
     * @throws StrictException
     */
    public function loadFromFile(string $file, ?Options $options = null) : Dom
    {
        $content = @\file_get_contents($file);
        if ($content === \false) {
            throw new LogicalException('file_get_contents failed and returned false when trying to read "' . $file . '".');
        }
        return $this->loadStr($content, $options);
    }
    /**
     * Use a curl interface implementation to attempt to load
     * the content from a url.
     *
     * @throws ChildNotFoundException
     * @throws CircularException
     * @throws Exceptions\ContentLengthException
     * @throws LogicalException
     * @throws StrictException
     * @throws ClientExceptionInterface
     */
    public function loadFromUrl(string $url, ?Options $options = null, ?ClientInterface $client = null, ?RequestInterface $request = null) : Dom
    {
        if ($client === null) {
            $client = new Client();
        }
        if ($request === null) {
            $request = new Request('GET', $url);
        }
        $response = $client->sendRequest($request);
        $content = $response->getBody()->getContents();
        return $this->loadStr($content, $options);
    }
    /**
     * Parsers the html of the given string. Used for load(), loadFromFile(),
     * and loadFromUrl().
     *
     * @throws ChildNotFoundException
     * @throws CircularException
     * @throws Exceptions\ContentLengthException
     * @throws LogicalException
     * @throws StrictException
     */
    public function loadStr(string $str, ?Options $options = null) : Dom
    {
        $localOptions = new Options();
        if ($this->globalOptions !== null) {
            $localOptions = $localOptions->setFromOptions($this->globalOptions);
        }
        if ($options !== null) {
            $localOptions = $localOptions->setFromOptions($options);
        }
        $html = $this->domCleaner->clean($str, $localOptions, $this->defaultCharset);
        $this->content = new Content($html);
        $this->root = $this->domParser->parse($localOptions, $this->content, \strlen($str));
        $this->domParser->detectCharset($localOptions, $this->defaultCharset, $this->root);
        return $this;
    }
    /**
     * Sets a global options array to be used by all load calls.
     */
    public function setOptions(Options $options) : Dom
    {
        $this->globalOptions = $options;
        return $this;
    }
    /**
     * Find elements by css selector on the root node.
     *
     * @throws NotLoadedException
     * @throws ChildNotFoundException
     *
     * @return mixed|Collection|null
     */
    public function find(string $selector, int $nth = null)
    {
        $this->isLoaded();
        return $this->root->find($selector, $nth);
    }
    /**
     * Simple wrapper function that returns an element by the
     * id.
     *
     * @param $id
     *
     * @throws NotLoadedException
     * @throws ChildNotFoundException
     *
     * @return mixed|Collection|null
     */
    public function getElementById($id)
    {
        $this->isLoaded();
        return $this->find('#' . $id, 0);
    }
    /**
     * Simple wrapper function that returns all elements by
     * tag name.
     *
     * @throws NotLoadedException
     * @throws ChildNotFoundException
     *
     * @return mixed|Collection|null
     */
    public function getElementsByTag(string $name)
    {
        $this->isLoaded();
        return $this->find($name);
    }
    /**
     * Simple wrapper function that returns all elements by
     * class name.
     *
     * @throws NotLoadedException
     * @throws ChildNotFoundException
     *
     * @return mixed|Collection|null
     */
    public function getElementsByClass(string $class)
    {
        $this->isLoaded();
        return $this->find('.' . $class);
    }
    /**
     * Checks if the load methods have been called.
     *
     * @throws NotLoadedException
     */
    private function isLoaded() : void
    {
        if (\is_null($this->content)) {
            throw new NotLoadedException('Content is not loaded!');
        }
    }
}
