<?php

/**
 * webtrees: online genealogy
 * Copyright (C) 2026 webtrees development team
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 */

declare(strict_types=1);

namespace Fisharebest\Webtrees;

use Closure;
use Fisharebest\Webtrees\Contracts\TimestampInterface;
use Fisharebest\Webtrees\Contracts\UserInterface;
use Fisharebest\Webtrees\Elements\RestrictionNotice;
use Fisharebest\Webtrees\Http\RequestHandlers\GedcomRecordPage;
use Fisharebest\Webtrees\Services\PendingChangesService;
use Illuminate\Support\Collection;
use InvalidArgumentException;
use LogicException;

use function array_combine;
use function array_keys;
use function array_map;
use function array_search;
use function array_shift;
use function count;
use function date;
use function e;
use function explode;
use function implode;
use function in_array;
use function md5;
use function preg_match;
use function preg_match_all;
use function preg_replace;
use function preg_replace_callback;
use function preg_split;
use function range;
use function route;
use function str_contains;
use function str_ends_with;
use function str_pad;
use function str_starts_with;
use function strtoupper;
use function strtr;
use function trigger_error;
use function trim;
use function view;

use const E_USER_DEPRECATED;
use const PHP_INT_MAX;
use const PREG_SET_ORDER;
use const STR_PAD_LEFT;

class GedcomRecord
{
    public const string RECORD_TYPE = 'UNKNOWN';

    protected const string ROUTE_NAME = GedcomRecordPage::class;

    protected string $xref;

    protected Tree $tree;

    // GEDCOM data (before any pending edits)
    protected string $gedcom;

    // GEDCOM data (after any pending edits)
    protected string|null $pending;

    /** @var array<Fact> Facts extracted from $gedcom/$pending */
    protected array $facts;

    /** @var array<array<string>> All the names of this individual */
    protected array $getAllNames = [];

    /** @var int|null Cached result */
    private int|null $getPrimaryName = null;

    /** @var int|null Cached result */
    private int|null $getSecondaryName = null;

    /**
     * Create a GedcomRecord object from raw GEDCOM data.
     *
     * @param string      $xref
     * @param string      $gedcom  an empty string for new/pending records
     * @param string|null $pending null for a record with no pending edits,
     *                             empty string for records with pending deletions
     * @param Tree        $tree
     */
    public function __construct(string $xref, string $gedcom, string|null $pending, Tree $tree)
    {
        $this->xref    = $xref;
        $this->gedcom  = $gedcom;
        $this->pending = $pending;
        $this->tree    = $tree;
        $this->facts   = $this->parseFacts();
    }

    /**
     * A closure which will filter out private records.
     *
     * @return Closure(GedcomRecord):bool
     */
    public static function accessFilter(): Closure
    {
        return static fn (GedcomRecord $record): bool => $record->canShow();
    }

    /**
     * A closure which will compare records by name.
     *
     * @return Closure(GedcomRecord,GedcomRecord):int
     */
    public static function nameComparator(): Closure
    {
        return static function (GedcomRecord $x, GedcomRecord $y): int {
            if ($x->canShowName()) {
                if ($y->canShowName()) {
                    return I18N::comparator()($x->sortName(), $y->sortName());
                }

                return -1; // only $y is private
            }

            if ($y->canShowName()) {
                return 1; // only $x is private
            }

            return 0; // both $x and $y private
        };
    }

    /**
     * A closure which will compare records by change time.
     *
     * @param int $direction +1 to sort ascending, -1 to sort descending
     *
     * @return Closure(GedcomRecord,GedcomRecord):int
     */
    public static function lastChangeComparator(int $direction = 1): Closure
    {
        return static fn (GedcomRecord $x, GedcomRecord $y): int => $direction * ($x->lastChangeTimestamp() <=> $y->lastChangeTimestamp());
    }

    /**
     * Get the GEDCOM tag for this record.
     *
     * @return string
     */
    public function tag(): string
    {
        preg_match('/^0 @[^@]*@ (\w+)/', $this->gedcom(), $match);

        return $match[1] ?? static::RECORD_TYPE;
    }

    /**
     * Get the XREF for this record
     *
     * @return string
     */
    public function xref(): string
    {
        return $this->xref;
    }

    /**
     * Get the tree to which this record belongs
     *
     * @return Tree
     */
    public function tree(): Tree
    {
        return $this->tree;
    }

    /**
     * Application code should access data via Fact objects.
     * This function exists to support old code.
     *
     * @return string
     */
    public function gedcom(): string
    {
        return $this->pending ?? $this->gedcom;
    }

    /**
     * Does this record have a pending change?
     *
     * @return bool
     */
    public function isPendingAddition(): bool
    {
        return $this->pending !== null;
    }

    /**
     * Does this record have a pending deletion?
     *
     * @return bool
     */
    public function isPendingDeletion(): bool
    {
        return $this->pending === '';
    }

    /**
     * Generate a URL to this record.
     *
     * @return string
     */
    public function url(): string
    {
        return route(static::ROUTE_NAME, [
            'xref' => $this->xref(),
            'tree' => $this->tree->name(),
            'slug' => Registry::slugFactory()->make($this),
        ]);
    }

    /**
     * Can the details of this record be shown?
     *
     * @param int|null $access_level
     *
     * @return bool
     */
    public function canShow(int|null $access_level = null): bool
    {
        $access_level ??= Auth::accessLevel($this->tree);

        // We use this value to bypass privacy checks. For example,
        // when downloading data or when calculating privacy itself.
        if ($access_level === Auth::PRIV_HIDE) {
            return true;
        }

        $cache_key = 'show-' . $this->xref . '-' . $this->tree->id() . '-' . $access_level;

        return Registry::cache()->array()->remember($cache_key, fn () => $this->canShowRecord($access_level));
    }

    /**
     * Can the name of this record be shown?
     *
     * @param int|null $access_level
     *
     * @return bool
     */
    public function canShowName(int|null $access_level = null): bool
    {
        return $this->canShow($access_level);
    }

    /**
     * Can we edit this record?
     *
     * @return bool
     */
    public function canEdit(): bool
    {
        if ($this->isPendingDeletion()) {
            return false;
        }

        if (Auth::isManager($this->tree)) {
            return true;
        }

        $fact   = $this->facts(['RESN'])->first();
        $locked = $fact instanceof Fact && str_ends_with($fact->value(), RestrictionNotice::VALUE_LOCKED);

        return Auth::isEditor($this->tree) && !$locked;
    }

    /**
     * Remove private data from the raw gedcom record.
     */
    public function privatizeGedcom(int $access_level): string
    {
        if ($access_level === Auth::PRIV_HIDE) {
            return $this->gedcom;
        }

        if (!$this->canShow($access_level)) {
            return '';
        }

        // The record is not private, but parts of it may be.

        // Include the entire first line (for NOTE records)
        [$gedcom] = explode("\n", $this->gedcom . $this->pending, 2);

        // Check each of the facts for access
        foreach ($this->facts([], false, $access_level) as $fact) {
            $gedcom .= "\n" . $fact->gedcom();
        }

        // Remove links to missing and private records
        $pattern =  '/\n(\d) ' . Gedcom::REGEX_TAG . ' @(' . Gedcom::REGEX_XREF . ')@/';
        preg_match_all($pattern, $gedcom, $matches, PREG_SET_ORDER);

        foreach ($matches as $match) {
            $xref = $match[2];
            $record = Registry::gedcomRecordFactory()->make($xref, $this->tree);

            if ($record === null || !$record->canShow($access_level)) {
                $level   = $match[1];
                $next    = 1 + (int) $level;
                $pattern = '/\n' . $level . ' ' . Gedcom::REGEX_TAG . ' @' . $xref . '@(\n[' . $next . '-9].*)*/';
                $gedcom  = preg_replace($pattern, '', $gedcom);
            }
        }

        return $gedcom;
    }

    /**
     * Default for "other" object types
     *
     * @return void
     */
    public function extractNames(): void
    {
        $this->addName(static::RECORD_TYPE, $this->getFallBackName(), '');
    }

    /**
     * Derived classes should redefine this function, otherwise the object will have no name
     *
     * @return array<int,array<string,string>>
     */
    public function getAllNames(): array
    {
        if ($this->getAllNames === []) {
            if ($this->canShowName()) {
                // Ask the record to extract its names
                $this->extractNames();
                // No name found? Use a fallback.
                if ($this->getAllNames === []) {
                    $this->addName(static::RECORD_TYPE, $this->getFallBackName(), '');
                }
            } else {
                $this->addName(static::RECORD_TYPE, I18N::translate('Private'), '');
            }
        }

        return $this->getAllNames;
    }

    /**
     * If this object has no name, what do we call it?
     *
     * @return string
     */
    public function getFallBackName(): string
    {
        return e($this->xref());
    }

    /**
     * Which of the (possibly several) names of this record is the primary one.
     *
     * @return int
     */
    public function getPrimaryName(): int
    {
        static $language_script;

        $language_script ??= I18N::locale()->script()->code();

        if ($this->getPrimaryName === null) {
            // Generally, the first name is the primary one....
            $this->getPrimaryName = 0;
            // ...except when the language/name use different character sets
            foreach ($this->getAllNames() as $n => $name) {
                if (I18N::textScript($name['sort']) === $language_script) {
                    $this->getPrimaryName = $n;
                    break;
                }
            }
        }

        return $this->getPrimaryName;
    }

    /**
     * Which of the (possibly several) names of this record is the secondary one.
     *
     * @return int
     */
    public function getSecondaryName(): int
    {
        if ($this->getSecondaryName === null) {
            // Generally, the primary and secondary names are the same
            $this->getSecondaryName = $this->getPrimaryName();
            // ....except when there are names with different character sets
            $all_names = $this->getAllNames();
            if (count($all_names) > 1) {
                $primary_script = I18N::textScript($all_names[$this->getPrimaryName()]['sort']);
                foreach ($all_names as $n => $name) {
                    if ($n !== $this->getPrimaryName() && $name['type'] !== '_MARNM' && I18N::textScript($name['sort']) !== $primary_script) {
                        $this->getSecondaryName = $n;
                        break;
                    }
                }
            }
        }

        return $this->getSecondaryName;
    }

    /**
     * Allow the choice of primary name to be overridden, e.g. in a search result
     *
     * @param int|null $n
     *
     * @return void
     */
    public function setPrimaryName(int|null $n = null): void
    {
        $this->getPrimaryName   = $n;
        $this->getSecondaryName = null;
    }

    /**
     * Allow native PHP functions such as array_unique() to work with objects
     *
     * @return string
     */
    public function __toString(): string
    {
        return $this->xref . '@' . $this->tree->id();
    }

    /**
     * /**
     * Get variants of the name
     *
     * @return string
     */
    public function fullName(): string
    {
        if ($this->canShowName()) {
            $tmp = $this->getAllNames();

            return $tmp[$this->getPrimaryName()]['full'];
        }

        return I18N::translate('Private');
    }

    /**
     * Get a sortable version of the name. Do not display this!
     *
     * @return string
     */
    public function sortName(): string
    {
        // The sortable name is never displayed, no need to call canShowName()
        $tmp = $this->getAllNames();

        return $tmp[$this->getPrimaryName()]['sort'];
    }

    /**
     * Get the full name in an alternative character set
     *
     * @return string|null
     */
    public function alternateName(): string|null
    {
        if ($this->canShowName() && $this->getPrimaryName() !== $this->getSecondaryName()) {
            $all_names = $this->getAllNames();

            return $all_names[$this->getSecondaryName()]['full'];
        }

        return null;
    }

    /**
     * Format this object for display in a list
     *
     * @return string
     */
    public function formatList(): string
    {
        $html = '<a href="' . e($this->url()) . '">';
        $html .= '<b>' . $this->fullName() . '</b>';
        $html .= '</a>';
        $html .= $this->formatListDetails();

        return $html;
    }

    /**
     * This function should be redefined in derived classes to show any major
     * identifying characteristics of this record.
     *
     * @return string
     */
    public function formatListDetails(): string
    {
        return '';
    }

    /**
     * Extract/format the first fact from a list of facts.
     *
     * @param array<string> $facts
     * @param int           $style
     *
     * @return string
     */
    public function formatFirstMajorFact(array $facts, int $style): string
    {
        $fact = $this->facts($facts, true)->first();

        if ($fact === null) {
            return '';
        }

        // Only display if it has a date or place (or both)
        $attributes = [];

        if ($fact->date()->isOK()) {
            $attributes[] = view('fact-date', ['cal_link' => 'false', 'fact' => $fact, 'record' => $fact->record(), 'time' => false]);
        }

        if ($fact->place()->gedcomName() !== '' && $style === 2) {
            $attributes[] = $fact->place()->shortName();
        }

        if ($attributes === []) {
            return '';
        }

        return '<div><em>' . I18N::translate('%1$s: %2$s', $fact->label(), implode(' — ', $attributes)) . '</em></div>';
    }

    /**
     * Get all attributes (e.g. DATE or PLAC) from an event (e.g. BIRT or MARR).
     * This is used to display multiple events on the individual/family lists.
     * Multiple events can exist because of uncertainty in dates, dates in different
     * calendars, place-names in both latin and hebrew character sets, etc.
     * It also allows us to combine dates/places from different events in the summaries.
     *
     * @param array<string> $events
     *
     * @return array<Date>
     */
    public function getAllEventDates(array $events): array
    {
        $dates = [];
        foreach ($this->facts($events, false, null, true) as $event) {
            if ($event->date()->isOK()) {
                $dates[] = $event->date();
            }
        }

        return $dates;
    }

    /**
     * Get all the places for a particular type of event
     *
     * @param array<string> $events
     *
     * @return array<Place>
     */
    public function getAllEventPlaces(array $events): array
    {
        $places = [];
        foreach ($this->facts($events) as $event) {
            if (preg_match_all('/\n(?:2 PLAC|3 (?:ROMN|FONE|_HEB)) +(.+)/', $event->gedcom(), $ged_places)) {
                foreach ($ged_places[1] as $ged_place) {
                    $places[] = new Place($ged_place, $this->tree);
                }
            }
        }

        return $places;
    }

    /**
     * The facts and events for this record.
     *
     * @param array<string> $filter
     * @param bool          $sort
     * @param int|null      $access_level
     * @param bool          $ignore_deleted
     *
     * @return Collection<int,Fact>
     */
    public function facts(
        array $filter = [],
        bool $sort = false,
        int|null $access_level = null,
        bool $ignore_deleted = false
    ): Collection {
        $access_level ??= Auth::accessLevel($this->tree);

        // Convert BIRT into INDI:BIRT, etc.
        $filter = array_map(fn (string $tag): string => $this->tag() . ':' . $tag, $filter);

        $facts = new Collection();
        if ($this->canShow($access_level)) {
            foreach ($this->facts as $fact) {
                if (($filter === [] || in_array($fact->tag(), $filter, true)) && $fact->canShow($access_level)) {
                    $facts->push($fact);
                }
            }
        }

        if ($sort) {
            switch ($this->tag()) {
                case Family::RECORD_TYPE:
                case Individual::RECORD_TYPE:
                    $facts = Fact::sortFacts($facts);
                    break;

                default:
                    $subtags = Registry::elementFactory()->make($this->tag())->subtags();
                    $subtags = array_map(fn (string $tag): string => $this->tag() . ':' . $tag, array_keys($subtags));

                    if ($subtags !== []) {
                        // Renumber keys from 1.
                        $subtags = array_combine(range(1, count($subtags)), $subtags);
                    }

                    $facts = $facts
                        ->sort(static function (Fact $x, Fact $y) use ($subtags): int {
                            $sort_x = array_search($x->tag(), $subtags, true) ?: PHP_INT_MAX;
                            $sort_y = array_search($y->tag(), $subtags, true) ?: PHP_INT_MAX;

                            return $sort_x <=> $sort_y;
                        });
                    break;
            }
        }

        if ($ignore_deleted) {
            $facts = $facts->filter(static fn (Fact $fact): bool => !$fact->isPendingDeletion());
        }

        return $facts;
    }

    /**
     * @return array<string,string>
     */
    public function missingFacts(): array
    {
        $missing_facts = [];

        foreach (Registry::elementFactory()->make($this->tag())->subtags() as $subtag => $repeat) {
            [, $max] = explode(':', $repeat);
            $max = $max === 'M' ? PHP_INT_MAX : (int) $max;

            if ($this->facts([$subtag], false, null, true)->count() < $max) {
                $missing_facts[$subtag] = $subtag;
                $missing_facts[$subtag] = Registry::elementFactory()->make($this->tag() . ':' . $subtag)->label();
            }
        }

        uasort($missing_facts, I18N::comparator());

        if (!Auth::canUploadMedia($this->tree, Auth::user())) {
            unset($missing_facts['OBJE']);
        }

        // We have special code for this.
        unset($missing_facts['FILE']);

        return $missing_facts;
    }

    /**
     * Get the last-change timestamp for this record
     *
     * @return TimestampInterface
     */
    public function lastChangeTimestamp(): TimestampInterface
    {
        $chan = $this->facts(['CHAN'])->first();

        if ($chan instanceof Fact) {
            // The record has a CHAN event.
            $date = $chan->date()->minimumDate();
            $ymd = sprintf('%04d-%02d-%02d', $date->year(), $date->month(), $date->day());

            if ($ymd !== '') {
                // The CHAN event has a valid DATE.
                if (preg_match('/\n3 TIME (([01]\d|2[0-3]):([0-5]\d):([0-5]\d))/', $chan->gedcom(), $match) === 1) {
                    return Registry::timestampFactory()->fromString($ymd . $match[1], 'Y-m-d H:i:s');
                }

                if (preg_match('/\n3 TIME (([01]\d|2[0-3]):([0-5]\d))/', $chan->gedcom(), $match) === 1) {
                    return Registry::timestampFactory()->fromString($ymd . $match[1], 'Y-m-d H:i');
                }

                return Registry::timestampFactory()->fromString($ymd, 'Y-m-d');
            }
        }

        // The record does not have a CHAN event
        return Registry::timestampFactory()->make(0);
    }

    /**
     * Get the last-change user for this record
     *
     * @return string
     */
    public function lastChangeUser(): string
    {
        $chan = $this->facts(['CHAN'])->first();

        if ($chan === null) {
            return I18N::translate('Unknown');
        }

        $chan_user = $chan->attribute('_WT_USER');
        if ($chan_user === '') {
            return I18N::translate('Unknown');
        }

        return $chan_user;
    }

    public function createFact(string $gedcom, bool $update_chan, Fact|null $before = null): void
    {
        if (!preg_match('/^1 ' . Gedcom::REGEX_TAG . '/', $gedcom) || str_contains($gedcom, "\r")) {
            throw new InvalidArgumentException('Invalid GEDCOM passed to GedcomRecord::createFact(' . $gedcom . ')');
        }

        // The first line of the record - 0 @XREF@ TAG [VALUE]
        [$new_gedcom] = explode("\n", $this->pending ?? $this->gedcom, 2);

        $inserted = false;

        foreach ($this->facts([], false, Auth::PRIV_HIDE, true) as $fact) {
            if (!$inserted && $fact->id() === $before?->id()) {
                $new_gedcom .= "\n" . $gedcom;
                $inserted = true;
            }

            $new_gedcom .= "\n" . $fact->gedcom();
        }

        if (!$inserted) {
            $new_gedcom .= "\n" . $gedcom;
        }

        $this->updateRecord($new_gedcom, $update_chan);
    }

    public function deleteFact(string $fact_id, bool $update_chan): void
    {
        // The first line of the record - 0 @XREF@ TAG [VALUE]
        [$new_gedcom] = explode("\n", $this->pending ?? $this->gedcom, 2);

        $deleted = false;

        foreach ($this->facts([], false, Auth::PRIV_HIDE, true) as $fact) {
            if (!$deleted && $fact->id() === $fact_id) {
                $deleted = true;
            } else {
                $new_gedcom .= "\n" . $fact->gedcom();
            }
        }

        $this->updateRecord($new_gedcom, $update_chan);
    }

    public function updateFact(string $fact_id, string $gedcom, bool $update_chan): void
    {
        if ($fact_id === '') {
            trigger_error(I18N::translate('$fact_id cannot be empty.  Use createFact() instead.'), E_USER_DEPRECATED);
            $this->createFact($gedcom, $update_chan);

            return;
        }

        if ($gedcom === '') {
            trigger_error(I18N::translate('$gedcom cannot be empty.  Use deleteFact() instead.'), E_USER_DEPRECATED);
            $this->deleteFact($fact_id, $update_chan);

            return;
        }

        if (!preg_match('/^1 ' . Gedcom::REGEX_TAG . '/', $gedcom) || str_contains($gedcom, "\r")) {
            throw new InvalidArgumentException('Invalid GEDCOM passed to GedcomRecord::updateFact(' . $gedcom . ')');
        }

        // The first line of the record - 0 @XREF@ TAG [VALUE]
        [$new_gedcom] = explode("\n", $this->pending ?? $this->gedcom, 2);

        $updated = false;

        foreach ($this->facts([], false, Auth::PRIV_HIDE, true) as $fact) {
            if (!$updated && $fact->id() === $fact_id) {
                $new_gedcom .= "\n" . $gedcom;
                $updated    = true;
            } else {
                $new_gedcom .= "\n" . $fact->gedcom();
            }
        }

        $this->updateRecord($new_gedcom, $update_chan);
    }

    public function updateRecord(string $gedcom, bool $update_chan): void
    {
        if ($this->pending === '') {
            throw new LogicException('Cannot edit a deleted record');
        }

        // Not all record types allow a CHAN event.
        $update_chan = $update_chan && in_array(static::RECORD_TYPE, Gedcom::RECORDS_WITH_CHAN, true);

        // MSDOS line endings will break things in horrible ways
        $gedcom = preg_replace('/[\r\n]+/', "\n", $gedcom);
        $gedcom = trim($gedcom);

        // Update the CHAN record
        if ($update_chan) {
            if (preg_match('/\n1 CHAN(\n[2-9].*)*/', $gedcom, $match)) {
                $gedcom = strtr($gedcom, [$match[0] => $this->updateChange($match[0])]);
            } else {
                $gedcom .= $this->updateChange("\n1 CHAN");
            }
        }

        // Create a pending change
        DB::table('change')->insert([
            'gedcom_id'  => $this->tree->id(),
            'xref'       => $this->xref,
            'old_gedcom' => $this->gedcom(),
            'new_gedcom' => $gedcom,
            'status'     => 'pending',
            'user_id'    => Auth::id(),
        ]);

        // Clear the cache
        $this->pending = $gedcom;

        // Accept this pending change
        if (Auth::user()->getPreference(UserInterface::PREF_AUTO_ACCEPT_EDITS) === '1') {
            Registry::container()->get(PendingChangesService::class)->acceptRecord($this);
            $this->gedcom  = $gedcom;
            $this->pending = null;
        }

        $this->facts = $this->parseFacts();

        Log::addEditLog('Update: ' . static::RECORD_TYPE . ' ' . $this->xref, $this->tree);
    }

    public function deleteRecord(): void
    {
        // Create a pending change
        if (!$this->isPendingDeletion()) {
            DB::table('change')->insert([
                'gedcom_id'  => $this->tree->id(),
                'xref'       => $this->xref,
                'old_gedcom' => $this->gedcom(),
                'new_gedcom' => '',
                'status'     => 'pending',
                'user_id'    => Auth::id(),
            ]);
        }

        // Auto-accept this pending change
        if (Auth::user()->getPreference(UserInterface::PREF_AUTO_ACCEPT_EDITS) === '1') {
            Registry::container()->get(PendingChangesService::class)->acceptRecord($this);
        }

        Log::addEditLog('Delete: ' . static::RECORD_TYPE . ' ' . $this->xref, $this->tree);
    }

    /**
     * Each object type may have its own special rules, and re-implement this function.
     *
     * @param int $access_level
     *
     * @return bool
     */
    protected function canShowByType(int $access_level): bool
    {
        $fact_privacy = $this->tree->getFactPrivacy();

        if (isset($fact_privacy[static::RECORD_TYPE])) {
            // Restriction found
            return $fact_privacy[static::RECORD_TYPE] >= $access_level;
        }

        // No restriction found - must be public:
        return true;
    }

    /**
     * Convert a name record into sortable and full/display versions. This default
     * should be OK for simple record types. INDI/FAM records will need to redefine it.
     *
     * @param string $type
     * @param string $value
     * @param string $gedcom
     *
     * @return void
     */
    protected function addName(string $type, string $value, string $gedcom): void
    {
        $this->getAllNames[] = [
            'type'   => $type,
            'sort'   => preg_replace_callback('/(\d+)/', static fn (array $matches): string => str_pad($matches[0], 10, '0', STR_PAD_LEFT), $value),
            'full'   => '<bdi>' . e($value) . '</bdi>',
            // This is used for display
            'fullNN' => $value,
            // This goes into the database
        ];
    }

    /**
     * Get all the names of a record, including ROMN, FONE and _HEB alternatives.
     * Records without a name (e.g. FAM) will need to redefine this function.
     * Parameters: the level 1 fact containing the name.
     * Return value: an array of name structures, each containing
     * ['type'] = the gedcom fact, e.g. NAME, TITL, FONE, _HEB, etc.
     * ['full'] = the name as specified in the record, e.g. 'Vincent van Gogh' or 'John Unknown'
     * ['sort'] = a sortable version of the name (not for display), e.g. 'Gogh, Vincent' or '@N.N., John'
     *
     * @param int              $level
     * @param string           $fact_type
     * @param Collection<int,Fact> $facts
     *
     * @return void
     */
    protected function extractNamesFromFacts(int $level, string $fact_type, Collection $facts): void
    {
        $sublevel    = $level + 1;
        $subsublevel = $sublevel + 1;
        foreach ($facts as $fact) {
            if (preg_match_all('/^' . $level . ' (' . $fact_type . ') (.+)((\n[' . $sublevel . '-9].+)*)/m', $fact->gedcom(), $matches, PREG_SET_ORDER)) {
                foreach ($matches as $match) {
                    // Treat 1 NAME / 2 TYPE married the same as _MARNM
                    if ($match[1] === 'NAME' && str_contains(strtoupper($match[3]), "\n2 TYPE MARRIED")) {
                        $this->addName('_MARNM', $match[2], $fact->gedcom());
                    } else {
                        $this->addName($match[1], $match[2], $fact->gedcom());
                    }
                    if ($match[3] && preg_match_all('/^' . $sublevel . ' (ROMN|FONE|_\w+) (.+)((\n[' . $subsublevel . '-9].+)*)/m', $match[3], $submatches, PREG_SET_ORDER)) {
                        foreach ($submatches as $submatch) {
                            if ($submatch[1] !== '_RUFNAME') {
                                $this->addName($submatch[1], $submatch[2], $match[3]);
                            }
                        }
                    }
                }
            }
        }
    }

    /**
     * Split the record into facts
     *
     * @return array<Fact>
     */
    private function parseFacts(): array
    {
        // Split the record into facts
        if ($this->gedcom !== '') {
            $gedcom_facts = preg_split('/\n(?=1)/', $this->gedcom);
            array_shift($gedcom_facts);
        } else {
            $gedcom_facts = [];
        }
        if ($this->pending !== null && $this->pending !== '') {
            $pending_facts = preg_split('/\n(?=1)/', $this->pending);
            array_shift($pending_facts);
        } else {
            $pending_facts = [];
        }

        $facts = [];

        foreach ($gedcom_facts as $gedcom_fact) {
            $fact = new Fact($gedcom_fact, $this, md5($gedcom_fact));
            if ($this->pending !== null && !in_array($gedcom_fact, $pending_facts, true)) {
                $fact->setPendingDeletion();
            }
            $facts[] = $fact;
        }
        foreach ($pending_facts as $pending_fact) {
            if (!in_array($pending_fact, $gedcom_facts, true)) {
                $fact = new Fact($pending_fact, $this, md5($pending_fact));
                $fact->setPendingAddition();
                $facts[] = $fact;
            }
        }

        return $facts;
    }

    /**
     * Work out whether this record can be shown to a user with a given access level
     *
     * @param int $access_level
     *
     * @return bool
     */
    private function canShowRecord(int $access_level): bool
    {
        // This setting would better be called "$ENABLE_PRIVACY"
        if (!$this->tree->getPreference('HIDE_LIVE_PEOPLE')) {
            return true;
        }

        // We should always be able to see our own record (unless an admin is applying download restrictions)
        if ($this->xref() === $this->tree->getUserPreference(Auth::user(), UserInterface::PREF_TREE_ACCOUNT_XREF) && $access_level === Auth::accessLevel($this->tree)) {
            return true;
        }

        // Does this record have a restriction notice?
        // Cannot use $this->>fact(), as that function calls this one.
        if (preg_match('/\n1 RESN (.+)/', $this->gedcom(), $match)) {
            $element     = new RestrictionNotice('');
            $restriction = $element->canonical($match[1]);

            if (str_starts_with($restriction, RestrictionNotice::VALUE_CONFIDENTIAL)) {
                return Auth::PRIV_NONE >= $access_level;
            }
            if (str_starts_with($restriction, RestrictionNotice::VALUE_PRIVACY)) {
                return Auth::PRIV_USER >= $access_level;
            }
            if (str_starts_with($restriction, RestrictionNotice::VALUE_NONE)) {
                return true;
            }
        }

        // Does this record have a default RESN?
        $individual_privacy = $this->tree->getIndividualPrivacy();
        if (isset($individual_privacy[$this->xref()])) {
            return $individual_privacy[$this->xref()] >= $access_level;
        }

        // Privacy rules do not apply to admins
        if (Auth::PRIV_NONE >= $access_level) {
            return true;
        }

        // Different types of record have different privacy rules
        return $this->canShowByType($access_level);
    }

    /**
     * Lock the database row, to prevent concurrent edits.
     */
    public function lock(): void
    {
        DB::table('other')
            ->where('o_file', '=', $this->tree->id())
            ->where('o_id', '=', $this->xref())
            ->lockForUpdate()
            ->get();
    }

    /**
     * Change records may contain notes and other fields.  Just update the date/time/author.
     *
     * @param string $gedcom
     *
     * @return string
     */
    private function updateChange(string $gedcom): string
    {
        $gedcom = preg_replace('/\n2 (DATE|_WT_USER).*(\n[3-9].*)*/', '', $gedcom);
        $today  = strtoupper(date('d M Y'));
        $now    = date('H:i:s');
        $author = Auth::user()->userName();

        return $gedcom . "\n2 DATE " . $today . "\n3 TIME " . $now . "\n2 _WT_USER " . $author;
    }
}
