Интерфейсы

<?php

require_once 'vendor/autoload.php';

use NotKinopoisk\Interfaces\ModelInterface;
use NotKinopoisk\Models\Film;
use NotKinopoisk\Models\Person;

// Проверка, что модель реализует интерфейс
if (Film::class instanceof ModelInterface) {
    echo "Film реализует ModelInterface\n";
}

// Создание модели из массива данных
$filmData = [
    'kinopoiskId' => 301,
    'nameRu' => 'Матрица',
    'nameEn' => 'The Matrix',
    'rating' => 8.7,
    'year' => 1999
];

$film = Film::fromArray($filmData);

// Использование методов интерфейса
echo "Отображаемое имя: {$film->getDisplayName()}\n";

$filmArray = $film->toArray();
echo "Массив данных:\n";
print_r($filmArray);

// Работа с другой моделью
$personData = [
    'kinopoiskId' => 123,
    'nameRu' => 'Киану Ривз',
    'nameEn' => 'Keanu Reeves',
    'sex' => 'MALE'
];

$person = Person::fromArray($personData);
echo "Персона: {$person->getDisplayName()}\n";

use NotKinopoisk\Interfaces\ResponseInterface;
use NotKinopoisk\Responses\DefaultResponse;
use NotKinopoisk\Responses\PaginatedResponse;

// Проверка, что ответ реализует интерфейс
if (DefaultResponse::class instanceof ResponseInterface) {
    echo "DefaultResponse реализует ResponseInterface\n";
}

// Создание ответа из массива данных
$responseData = [
    'total' => 2,
    'items' => [
        ['kinopoiskId' => 301, 'nameRu' => 'Матрица'],
        ['kinopoiskId' => 302, 'nameRu' => 'Матрица: Перезагрузка']
    ]
];

$response = DefaultResponse::fromArray($responseData, Film::class);

echo "Создан ответ с {$response->total} элементами\n";

// Работа с пагинированным ответом
$paginatedData = [
    'total' => 100,
    'items' => $responseData['items'],
    'currentPage' => 1,
    'totalPages' => 10
];

$paginatedResponse = PaginatedResponse::fromArray($paginatedData, Film::class);

echo "Страница {$paginatedResponse->currentPage} из {$paginatedResponse->totalPages}\n";

// Функция для создания любой модели из массива данных
function createModelFromArray(string $modelClass, array $data): object {
    if (!is_subclass_of($modelClass, ModelInterface::class)) {
        throw new InvalidArgumentException("Класс {$modelClass} должен реализовывать ModelInterface");
    }

    return $modelClass::fromArray($data);
}

// Функция для создания массива моделей
function createModelsFromArray(string $modelClass, array $dataArray): array {
    return array_map(
        fn($data) => createModelFromArray($modelClass, $data),
        $dataArray
    );
}

// Функция для получения отображаемых имен
function getDisplayNames(array $models): array {
    return array_map(
        fn($model) => $model->getDisplayName(),
        $models
    );
}

// Использование
$filmData = [
    'kinopoiskId' => 301,
    'nameRu' => 'Матрица',
    'nameEn' => 'The Matrix'
];

$personData = [
    'kinopoiskId' => 123,
    'nameRu' => 'Киану Ривз',
    'nameEn' => 'Keanu Reeves'
];

// Создание моделей
$film = createModelFromArray(Film::class, $filmData);
$person = createModelFromArray(Person::class, $personData);

echo "Фильм: {$film->getDisplayName()}\n";
echo "Персона: {$person->getDisplayName()}\n";

// Создание массива моделей
$filmsData = [
    ['kinopoiskId' => 301, 'nameRu' => 'Матрица'],
    ['kinopoiskId' => 302, 'nameRu' => 'Матрица: Перезагрузка']
];

$films = createModelsFromArray(Film::class, $filmsData);
$names = getDisplayNames($films);

echo "Фильмы: " . implode(', ', $names) . "\n";

// Функция для создания любого ответа из массива данных
function createResponseFromArray(string $responseClass, array $data, string $modelClass): object {
    if (!is_subclass_of($responseClass, ResponseInterface::class)) {
        throw new InvalidArgumentException("Класс {$responseClass} должен реализовывать ResponseInterface");
    }

    return $responseClass::fromArray($data, $modelClass);
}

// Функция для обработки ответов
function processResponse(object $response): array {
    $result = [
        'total' => $response->total,
        'count' => $response->getCount(),
        'isEmpty' => $response->isEmpty(),
        'items' => []
    ];

    // Добавляем информацию о пагинации, если есть
    if (property_exists($response, 'currentPage')) {
        $result['pagination'] = [
            'currentPage' => $response->currentPage,
            'totalPages' => $response->totalPages,
            'hasNextPage' => $response->hasNextPage(),
            'hasPreviousPage' => $response->hasPreviousPage()
        ];
    }

    // Добавляем информацию о поиске, если есть
    if (property_exists($response, 'keyword')) {
        $result['search'] = [
            'keyword' => $response->keyword,
            'pagesCount' => $response->pagesCount,
            'searchFilmsCountResult' => $response->searchFilmsCountResult
        ];
    }

    // Обрабатываем элементы
    foreach ($response->items as $item) {
        $result['items'][] = [
            'displayName' => $item->getDisplayName(),
            'data' => $item->toArray()
        ];
    }

    return $result;
}

// Использование
$responseData = [
    'total' => 2,
    'items' => [
        ['kinopoiskId' => 301, 'nameRu' => 'Матрица'],
        ['kinopoiskId' => 302, 'nameRu' => 'Матрица: Перезагрузка']
    ]
];

$response = createResponseFromArray(DefaultResponse::class, $responseData, Film::class);
$processed = processResponse($response);

echo "Обработанный ответ:\n";
print_r($processed);

// Функция для проверки, что объект реализует интерфейс
function implementsInterface(object $object, string $interface): bool {
    $reflection = new ReflectionClass($object);
    return $reflection->implementsInterface($interface);
}

// Функция для валидации модели
function validateModel(object $model): array {
    $errors = [];

    if (!implementsInterface($model, ModelInterface::class)) {
        $errors[] = "Объект должен реализовывать ModelInterface";
        return $errors;
    }

    // Проверяем обязательные методы
    $requiredMethods = ['fromArray', 'toArray', 'getDisplayName'];

    foreach ($requiredMethods as $method) {
        if (!method_exists($model, $method)) {
            $errors[] = "Отсутствует обязательный метод: {$method}";
        }
    }

    // Проверяем, что getDisplayName возвращает строку
    try {
        $displayName = $model->getDisplayName();
        if (!is_string($displayName)) {
            $errors[] = "Метод getDisplayName должен возвращать строку";
        }
    } catch (Exception $e) {
        $errors[] = "Ошибка при вызове getDisplayName: " . $e->getMessage();
    }

    // Проверяем, что toArray возвращает массив
    try {
        $array = $model->toArray();
        if (!is_array($array)) {
            $errors[] = "Метод toArray должен возвращать массив";
        }
    } catch (Exception $e) {
        $errors[] = "Ошибка при вызове toArray: " . $e->getMessage();
    }

    return $errors;
}

// Использование
$film = Film::fromArray(['kinopoiskId' => 301, 'nameRu' => 'Матрица']);

if (implementsInterface($film, ModelInterface::class)) {
    echo "Film реализует ModelInterface\n";
}

$validationErrors = validateModel($film);
if (empty($validationErrors)) {
    echo "Модель валидна\n";
} else {
    echo "Ошибки валидации:\n";
    foreach ($validationErrors as $error) {
        echo "- {$error}\n";
    }
}

public static function fromArray(array $data): object

public function toArray(): array

public function getDisplayName(): string

public static function fromArray(array $data, string $cls): object