<?php

declare(strict_types=1);

namespace WordPress\PerplexityAiProvider\Provider;

use Exception;
use WordPress\AiClient\Messages\DTO\Message;
use WordPress\AiClient\Messages\DTO\MessagePart;
use WordPress\AiClient\Messages\Enums\MessageRoleEnum;
use WordPress\AiClient\Providers\Contracts\ProviderAvailabilityInterface;
use WordPress\AiClient\Providers\Http\Contracts\HttpTransporterInterface;
use WordPress\AiClient\Providers\Http\Contracts\RequestAuthenticationInterface;
use WordPress\AiClient\Providers\Http\Contracts\WithHttpTransporterInterface;
use WordPress\AiClient\Providers\Http\Contracts\WithRequestAuthenticationInterface;
use WordPress\AiClient\Providers\Models\Contracts\ModelInterface;
use WordPress\AiClient\Providers\Models\DTO\ModelConfig;
use WordPress\AiClient\Providers\Models\TextGeneration\Contracts\TextGenerationModelInterface;

/**
 * Provider availability for Perplexity, verified via a minimal text generation request.
 *
 * Perplexity does not offer a model listing endpoint for its Sonar chat models, so the
 * standard list-models availability check cannot be used. Instead, a minimal text
 * generation request validates that the provider is configured with a working API key.
 *
 * The model used for the test is created before the registry injects the HTTP transporter
 * and request authentication, so this class implements the corresponding interfaces and
 * forwards those dependencies to the inner model when the registry sets them.
 *
 * @since 1.0.0
 */
class PerplexityProviderAvailability implements
    ProviderAvailabilityInterface,
    WithHttpTransporterInterface,
    WithRequestAuthenticationInterface
{
    /**
     * @var ModelInterface&TextGenerationModelInterface The model used for the availability check.
     */
    private ModelInterface $model;

    /**
     * @var HttpTransporterInterface|null The HTTP transporter, once set by the registry.
     */
    private ?HttpTransporterInterface $httpTransporter = null;

    /**
     * @var RequestAuthenticationInterface|null The request authentication, once set by the registry.
     */
    private ?RequestAuthenticationInterface $requestAuthentication = null;

    /**
     * Constructor.
     *
     * @since 1.0.0
     *
     * @param ModelInterface $model The text generation model to use for the availability check.
     * @throws Exception If the model does not support text generation.
     */
    public function __construct(ModelInterface $model)
    {
        if (!$model instanceof TextGenerationModelInterface) {
            throw new Exception('The model used to check Perplexity availability must support text generation.');
        }
        $this->model = $model;
    }

    /**
     * {@inheritDoc}
     *
     * Forwards the transporter to the inner model so the test request can be sent.
     *
     * @since 1.0.0
     */
    public function setHttpTransporter(HttpTransporterInterface $transporter): void
    {
        $this->httpTransporter = $transporter;
        if ($this->model instanceof WithHttpTransporterInterface) {
            $this->model->setHttpTransporter($transporter);
        }
    }

    /**
     * {@inheritDoc}
     *
     * @since 1.0.0
     */
    public function getHttpTransporter(): HttpTransporterInterface
    {
        return $this->httpTransporter;
    }

    /**
     * {@inheritDoc}
     *
     * Forwards the authentication to the inner model so the test request is authenticated.
     *
     * @since 1.0.0
     */
    public function setRequestAuthentication(RequestAuthenticationInterface $authentication): void
    {
        $this->requestAuthentication = $authentication;
        if ($this->model instanceof WithRequestAuthenticationInterface) {
            $this->model->setRequestAuthentication($authentication);
        }
    }

    /**
     * {@inheritDoc}
     *
     * @since 1.0.0
     */
    public function getRequestAuthentication(): RequestAuthenticationInterface
    {
        return $this->requestAuthentication;
    }

    /**
     * {@inheritDoc}
     *
     * Sends a minimal (single token) text generation request to verify the credentials.
     *
     * @since 1.0.0
     */
    public function isConfigured(): bool
    {
        $modelConfig = ModelConfig::fromArray([ModelConfig::KEY_MAX_TOKENS => 1]);
        $this->model->setConfig($modelConfig);

        try {
            $this->model->generateTextResult([new Message(MessageRoleEnum::user(), [new MessagePart('a')])]);
            return true;
        } catch (Exception $e) {
            return false;
        }
    }
}