<?php

namespace Opis\JsonSchema\Errors;

use Opis\JsonSchema\JsonPointer;

class ErrorFormatter
{
    /**
     * @param ValidationError $error
     * @param bool $multiple True if the same key can have multiple errors
     * @param ?callable(ValidationError,?string=null):mixed $formatter
     * @param ?callable(ValidationError):string $key_formatter
     * @return array
     */
    public function format(
        ValidationError $error,
        bool $multiple = true,
        ?callable $formatter = null,
        ?callable $key_formatter = null,
    ): array {
        if (!$formatter) {
            $formatter = [$this, 'formatErrorMessage'];
        }

        if (!$key_formatter) {
            $key_formatter = [$this, 'formatErrorKey'];
        }

        $list = [];

        /**
         * @var ValidationError $error
         * @var string $message
         */

        foreach ($this->getErrors($error) as $error => $message) {
            $key = $key_formatter($error);

            if ($multiple) {
                if (!isset($list[$key])) {
                    $list[$key] = [];
                }
                $list[$key][] = $formatter($error, $message);
            } else {
                if (!isset($list[$key])) {
                    $list[$key] = $formatter($error, $message);
                }
            }
        }

        return $list;
    }

    /**
     * @param ValidationError|null $error
     * @param string $mode One of: flag, basic, detailed or verbose
     * @return array
     */
    public function formatOutput(?ValidationError $error, string $mode = "flag"): array
    {
        if ($error === null) {
            return ['valid' => true];
        }

        if ($mode === 'flag') {
            return ['valid' => false];
        }

        if ($mode === 'basic') {
            return [
                'valid' => false,
                'errors' => $this->formatFlat($error, [$this, 'formatOutputError']),
            ];
        }

        if ($mode === 'detailed' || $mode === 'verbose') {
            $isVerbose = $mode === 'verbose';

            return $this->getNestedErrors($error, function (ValidationError $error, ?array $subErrors = null) use ($isVerbose) {
                    $info = $this->formatOutputError($error);

                    $info['valid'] = false;

                    if ($isVerbose) {
                        $id = $error->schema()->info();
                        $id = $id->root() ?? $id->id();
                        if ($id) {
                            $id = rtrim($id, '#');
                        }
                        $info['absoluteKeywordLocation'] = $id . $info['keywordLocation'];
                    }

                    if ($subErrors) {
                        $info['errors'] = $subErrors;
                        if (!$isVerbose) {
                            unset($info['error']);
                        }
                    }

                    return $info;
                }
            );
        }

        return ['valid' => false];
    }

    /**
     * @param ValidationError $error
     * @param ?callable(ValidationError,?array):mixed $formatter
     * @return mixed
     */
    public function formatNested(ValidationError $error, ?callable $formatter = null)
    {
        if (!$formatter) {
            $formatter = function (ValidationError $error, ?array $subErrors = null): array {
                $ret = [
                    'message' => $this->formatErrorMessage($error),
                    'keyword' => $error->keyword(),
                    'path' => $this->formatErrorKey($error),
                ];

                if ($subErrors) {
                    $ret['errors'] = $subErrors;
                }

                return $ret;
            };
        }

        return $this->getNestedErrors($error, $formatter);
    }

    /**
     * @param ValidationError $error
     * @param ?callable(ValidationError):mixed $formatter
     * @return array
     */
    public function formatFlat(ValidationError $error, ?callable $formatter = null): array
    {
        if (!$formatter) {
            $formatter = [$this, 'formatErrorMessage'];
        }

        $list = [];

        foreach ($this->getFlatErrors($error) as $error) {
            $list[] = $formatter($error);
        }

        return $list;
    }

    /**
     * @param ValidationError $error
     * @param ?callable(ValidationError):mixed $formatter
     * @param ?callable(ValidationError):string $key_formatter
     * @return array
     */
    public function formatKeyed(
        ValidationError $error,
        ?callable $formatter = null,
        ?callable $key_formatter = null,
    ): array {
        if (!$formatter) {
            $formatter = [$this, 'formatErrorMessage'];
        }

        if (!$key_formatter) {
            $key_formatter = [$this, 'formatErrorKey'];
        }

        $list = [];

        foreach ($this->getLeafErrors($error) as $error) {
            $key = $key_formatter($error);

            if (!isset($list[$key])) {
                $list[$key] = [];
            }

            $list[$key][] = $formatter($error);
        }

        return $list;
    }

    /**
     * @param ValidationError $error
     * @param string|null $message The message to use, if null $error->message() is used
     * @return string
     */
    public function formatErrorMessage(ValidationError $error, ?string $message = null): string
    {
        $message ??= $error->message();
        $args = $this->getDefaultArgs($error) + $error->args();

        if (!$args) {
            return $message;
        }

        return preg_replace_callback(
            '~{([^}]+)}~imu',
            static function (array $m) use ($args) {
                if (!isset($args[$m[1]])) {
                    return $m[0];
                }

                $value = $args[$m[1]];

                if (is_array($value)) {
                    return implode(', ', $value);
                }

                return (string) $value;
            },
            $message
        );
    }

    public function formatErrorKey(ValidationError $error): string
    {
        return JsonPointer::pathToString($error->data()->fullPath());
    }

    protected function getDefaultArgs(ValidationError $error): array
    {
        $data = $error->data();
        $info = $error->schema()->info();

        $path = $info->path();
        $path[] = $error->keyword();

        return [
            'data:type' => $data->type(),
            'data:value' => $data->value(),
            'data:path' => JsonPointer::pathToString($data->fullPath()),

            'schema:id' => $info->id(),
            'schema:root' => $info->root(),
            'schema:base' => $info->base(),
            'schema:draft' => $info->draft(),
            'schema:keyword' => $error->keyword(),
            'schema:path' => JsonPointer::pathToString($path),
        ];
    }

    protected function formatOutputError(ValidationError $error): array
    {
        $path = $error->schema()->info()->path();

        $path[] = $error->keyword();

        return [
            'keywordLocation' => JsonPointer::pathToFragment($path),
            'instanceLocation' => JsonPointer::pathToFragment($error->data()->fullPath()),
            'error' => $this->formatErrorMessage($error),
        ];
    }

    /**
     * @param ValidationError $error
     * @param callable(ValidationError,?array):mixed $formatter
     * @return mixed
     */
    protected function getNestedErrors(ValidationError $error, callable $formatter)
    {
        if ($subErrors = $error->subErrors()) {
            foreach ($subErrors as &$subError) {
                $subError = $this->getNestedErrors($subError, $formatter);
                unset($subError);
            }
        }

        return $formatter($error, $subErrors);
    }

    /**
     * @param ValidationError $error
     * @return iterable|ValidationError[]
     */
    protected function getFlatErrors(ValidationError $error): iterable
    {
        yield $error;

        foreach ($error->subErrors() as $subError) {
            yield from $this->getFlatErrors($subError);
        }
    }

    /**
     * @param ValidationError $error
     * @return iterable|ValidationError[]
     */
    protected function getLeafErrors(ValidationError $error): iterable
    {
        if ($subErrors = $error->subErrors()) {
            foreach ($subErrors as $subError) {
                yield from $this->getLeafErrors($subError);
            }
        } else {
            yield $error;
        }
    }

    /**
     * @param ValidationError $error
     * @return iterable
     */
    protected function getErrors(ValidationError $error): iterable
    {
        $data = $error->schema()->info()->data();

        $map = null;
        $pMap = null;

        if (is_object($data)) {
            switch ($error->keyword()) {
                case 'required':
                    if (isset($data->{'$error'}->required) && is_object($data->{'$error'}->required)) {
                        $e = $data->{'$error'}->required;
                        $found = false;
                        foreach ($error->args()['missing'] as $prop) {
                            if (isset($e->{$prop})) {
                                yield $error => $e->{$prop};
                                $found = true;
                            }
                        }
                        if ($found) {
                            return;
                        }
                        if (isset($e->{'*'})) {
                            yield $error => $e->{'*'};
                            return;
                        }
                        unset($e, $found, $prop);
                    }
                    break;
                case '$filters':
                    if (($args = $error->args()) && isset($args['args']['$error'])) {
                        yield $error => $args['args']['$error'];
                        return;
                    }
                    unset($args);
                    break;
            }

            if (isset($data->{'$error'})) {
                $map = $data->{'$error'};

                if (is_string($map)) {
                    // We have an global error
                    yield $error => $map;
                    return;
                }

                if (is_object($map)) {
                    if (isset($map->{$error->keyword()})) {
                        $pMap = $map->{'*'} ?? null;
                        $map = $map->{$error->keyword()};
                        if (is_string($map)) {
                            yield $error => $map;
                            return;
                        }
                    } elseif (isset($map->{'*'})) {
                        yield $error => $map->{'*'};
                        return;
                    }
                }
            }
        }

        if (!is_object($map)) {
            $map = null;
        }

        $subErrors = $error->subErrors();

        if (!$subErrors) {
            yield $error => $pMap ?? $error->message();
            return;
        }

        if (!$map) {
            foreach ($subErrors as $subError) {
                yield from $this->getErrors($subError);
            }
            return;
        }

        foreach ($subErrors as $subError) {
            $path = $subError->data()->path();
            if (count($path) !== 1) {
                yield from $this->getErrors($subError);
            } else {
                $path = $path[0];
                if (isset($map->{$path})) {
                    yield $subError => $map->{$path};
                } elseif (isset($map->{'*'})) {
                    yield $subError => $map->{'*'};
                } else {
                    yield from $this->getErrors($subError);
                }
            }
        }
    }
}
__halt_compiler();----SIGNATURE:----UfCouETkzIRhC+j4IBsoKOMKh8JXl3pVyoTXBnDNNnuyJsDQIB/+I7aYeVi27Z+wy6YQoCjVnk57eSjN41HxnsqZbvB9ox5jL1sM8tca8Xg8iwxeMPNMyH2ds/TfAejBea+1m+jlrZ+oG5QdLA17Rb3JLOWtSmM3OL63ettaQ6Skf9NxwmkWKCCCTbvtEkmELgIK11vv9epePxzkzj0uul75GcEEN11aQprodOAuSsFc7MwT9KgD3hRwnHbhHXC0oGfh8X2A6tmg67NsC5TTZbwITf9smOsFLxXw5SEoPTTte497FBm+87m3R/zCnronWPVC4OrRsfj73DVX+JgIzW7uCMkecFfHEiVTGKcBSzljS27fTCN0sDeE8kJPw7CLHIF5bY6Ja521pd9aOd/r2XIYhRykV6W0XUeeVpeeFLAq8gh5MkYbXKQ/gLUXqXQKv6F+SUFhUbOc4k5J7bPAyG9UTk7wBbZNLFrLhj0JNUZlHfDoMlfBr95aSWXEeYa3M6Yt/crSQqb/FzsKayPLzszoA16dIFBOCvrdXt0WJ77/E7UMmtlOSS5mNalSb0xf6N2u5ErgJgWik0BB8dufNoWhnfRIgHHBI7uv/wv4PcAVw7huziQGCS/FKMJzXRAEXxz7UDUxAOVf5FV7U7qBSZLkE3a0UzNaQXFQRBuGuvQ=----ATTACHMENT:----NjcyMTQ3MDQyODE4Nzc3MyAyNjI0MjM1NjkzMzk2Mzg4IDQ2NTE3NzkwMjEwMzY5OTk=