<?php

namespace Faker\Provider;

abstract class Text extends Base
{
    protected static $baseText = '';
    protected static $separator = ' ';
    protected static $separatorLen = 1;
    protected $explodedText;
    protected $consecutiveWords = [];
    protected static $textStartsWithUppercase = true;

    /**
     * Generate a text string by the Markov chain algorithm.
     *
     * Depending on the $maxNbChars, returns a random valid looking text. The algorithm
     * generates a weighted table with the specified number of words as the index and the
     * possible following words as the value.
     *
     * @example 'Alice, swallowing down her flamingo, and began by taking the little golden key'
     *
     * @param int $maxNbChars Maximum number of characters the text should contain (minimum: 10)
     * @param int $indexSize  Determines how many words are considered for the generation of the next word.
     *                        The minimum is 1, and it produces a higher level of randomness, although the
     *                        generated text usually doesn't make sense. Higher index sizes (up to 5)
     *                        produce more correct text, at the price of less randomness.
     *
     * @return string
     */
    public function realText($maxNbChars = 200, $indexSize = 2)
    {
        return $this->realTextBetween((int) round($maxNbChars * 0.8), $maxNbChars, $indexSize);
    }

    /**
     * Generate a text string by the Markov chain algorithm.
     *
     * Depending on the $maxNbChars, returns a random valid looking text. The algorithm
     * generates a weighted table with the specified number of words as the index and the
     * possible following words as the value.
     *
     * @example 'Alice, swallowing down her flamingo, and began by taking the little golden key'
     *
     * @param int $minNbChars Minimum number of characters the text should contain (maximum: 8)
     * @param int $maxNbChars Maximum number of characters the text should contain (minimum: 10)
     * @param int $indexSize  Determines how many words are considered for the generation of the next word.
     *                        The minimum is 1, and it produces a higher level of randomness, although the
     *                        generated text usually doesn't make sense. Higher index sizes (up to 5)
     *                        produce more correct text, at the price of less randomness.
     *
     * @return string
     */
    public function realTextBetween($minNbChars = 160, $maxNbChars = 200, $indexSize = 2)
    {
        if ($minNbChars < 1) {
            throw new \InvalidArgumentException('minNbChars must be at least 1');
        }

        if ($maxNbChars < 10) {
            throw new \InvalidArgumentException('maxNbChars must be at least 10');
        }

        if ($indexSize < 1) {
            throw new \InvalidArgumentException('indexSize must be at least 1');
        }

        if ($indexSize > 5) {
            throw new \InvalidArgumentException('indexSize must be at most 5');
        }

        if ($minNbChars >= $maxNbChars) {
            throw new \InvalidArgumentException('minNbChars must be smaller than maxNbChars');
        }

        $words = $this->getConsecutiveWords($indexSize);
        $iterations = 0;

        do {
            ++$iterations;

            if ($iterations >= 100) {
                throw new \OverflowException(sprintf('Maximum retries of %d reached without finding a valid real text', $iterations));
            }

            $result = $this->generateText($maxNbChars, $words);
        } while (static::strlen($result) <= $minNbChars);

        return $result;
    }

    /**
     * @param int   $maxNbChars
     * @param array $words
     *
     * @return string
     */
    protected function generateText($maxNbChars, $words)
    {
        $result = [];
        $resultLength = 0;
        // take a random starting point
        $next = static::randomKey($words);

        while ($resultLength < $maxNbChars && isset($words[$next])) {
            // fetch a random word to append
            $word = static::randomElement($words[$next]);

            // calculate next index
            $currentWords = static::explode($next);
            $currentWords[] = $word;
            array_shift($currentWords);
            $next = static::implode($currentWords);

            // ensure text starts with an uppercase letter
            if ($resultLength == 0 && !static::validStart($word)) {
                continue;
            }

            // append the element
            $result[] = $word;
            $resultLength += static::strlen($word) + static::$separatorLen;
        }

        // remove the element that caused the text to overflow
        array_pop($result);

        // build result
        $result = static::implode($result);

        return static::appendEnd($result);
    }

    protected function getConsecutiveWords($indexSize)
    {
        if (!isset($this->consecutiveWords[$indexSize])) {
            $parts = $this->getExplodedText();
            $words = [];
            $index = [];

            for ($i = 0; $i < $indexSize; ++$i) {
                $index[] = array_shift($parts);
            }

            for ($i = 0, $count = count($parts); $i < $count; ++$i) {
                $stringIndex = static::implode($index);

                if (!isset($words[$stringIndex])) {
                    $words[$stringIndex] = [];
                }
                $word = $parts[$i];
                $words[$stringIndex][] = $word;
                array_shift($index);
                $index[] = $word;
            }
            // cache look up words for performance
            $this->consecutiveWords[$indexSize] = $words;
        }

        return $this->consecutiveWords[$indexSize];
    }

    protected function getExplodedText()
    {
        if ($this->explodedText === null) {
            $this->explodedText = static::explode(preg_replace('/\s+/u', ' ', static::$baseText));
        }

        return $this->explodedText;
    }

    protected static function explode($text)
    {
        return explode(static::$separator, $text);
    }

    protected static function implode($words)
    {
        return implode(static::$separator, $words);
    }

    protected static function strlen($text)
    {
        return function_exists('mb_strlen') ? mb_strlen($text, 'UTF-8') : strlen($text);
    }

    protected static function validStart($word)
    {
        $isValid = true;

        if (static::$textStartsWithUppercase) {
            $isValid = preg_match('/^\p{Lu}/u', $word);
        }

        return $isValid;
    }

    protected static function appendEnd($text)
    {
        return preg_replace("/([ ,-:;\x{2013}\x{2014}]+$)/us", '', $text) . '.';
    }
}

• [D] ar_EG
• [D] ar_JO
• [D] ar_SA
• [D] at_AT
• [D] bg_BG
• [D] bn_BD
• [D] cs_CZ
• [D] da_DK
• [D] de_AT
• [D] de_CH
• [D] de_DE
• [D] el_CY
• [D] el_GR
• [D] en_AU
• [D] en_CA
• [D] en_GB
• [D] en_HK
• [D] en_IN
• [D] en_NG
• [D] en_NZ
• [D] en_PH
• [D] en_SG
• [D] en_UG
• [D] en_US
• [D] en_ZA
• [D] es_AR
• [D] es_ES
• [D] es_PE
• [D] es_VE
• [D] et_EE
• [D] fa_IR
• [D] fi_FI
• [D] fr_BE
• [D] fr_CA
• [D] fr_CH
• [D] fr_FR
• [D] he_IL
• [D] hr_HR
• [D] hu_HU
• [D] hy_AM
• [D] id_ID
• [D] is_IS
• [D] it_CH
• [D] it_IT
• [D] ja_JP
• [D] ka_GE
• [D] kk_KZ
• [D] ko_KR
• [D] lt_LT
• [D] lv_LV
• [D] me_ME
• [D] mn_MN
• [D] ms_MY
• [D] nb_NO
• [D] ne_NP
• [D] nl_BE
• [D] nl_NL
• [D] pl_PL
• [D] pt_BR
• [D] pt_PT
• [D] ro_MD
• [D] ro_RO
• [D] ru_RU
• [D] sk_SK
• [D] sl_SI
• [D] sr_Cyrl_RS
• [D] sr_Latn_RS
• [D] sr_RS
• [D] sv_SE
• [D] th_TH
• [D] tr_TR
• [D] uk_UA
• [D] vi_VN
• [D] zh_CN
• [D] zh_TW
• [F] Address.php
  Delete
• [F] Barcode.php
  Delete
• [F] Base.php
  Delete
• [F] Biased.php
  Delete
• [F] Color.php
  Delete
• [F] Company.php
  Delete
• [F] DateTime.php
  Delete
• [F] File.php
  Delete
• [F] HtmlLorem.php
  Delete
• [F] Image.php
  Delete
• [F] Internet.php
  Delete
• [F] Lorem.php
  Delete
• [F] Medical.php
  Delete
• [F] Miscellaneous.php
  Delete
• [F] Payment.php
  Delete
• [F] Person.php
  Delete
• [F] PhoneNumber.php
  Delete
• [F] Text.php
  Delete
• [F] UserAgent.php
  Delete
• [F] Uuid.php
  Delete

About Section

About NFC Pay: Our Story and Mission

NFC Pay was founded with a vision to transform the way people handle transactions. Our journey is defined by a commitment to innovation, security, and convenience. We strive to deliver seamless, user-friendly payment solutions that make everyday transactions effortless and secure. Our mission is to empower you to pay with ease and confidence, anytime, anywhere.

• Simplifying Payments, One Tap at a Time.
• Reinventing Your Wallet for Modern Convenience.
• Smart Payments for a Effortless Lifestyle.
• Experience the Ease of Tap and Pay.
• Innovative Solutions for Your Daily Transactions.

FAQ Section

Frequently Asked Questions About NFC Pay

Here are answers to some common questions about NFC Pay. We aim to provide clear and concise information to help you understand how our platform works and how it can benefit you. If you have any further inquiries, please don’t hesitate to contact our support team.

How do I register for NFC Pay?

Download the app and sign up using your email or phone number, then complete the verification process.

Is my payment information secure?

Yes, we use advanced encryption and security protocols to protect your payment details.

Can I add multiple cards to my NFC Pay wallet?

Absolutely, you can link multiple debit or credit cards to your wallet.

How do I transfer money to another user?

Go to the transfer section, select the recipient, enter the amount, and authorize the transfer.

What should I do if I forget my PIN?

Use the “Forgot PIN” feature in the app to reset it following the provided instructions.

How can I activate my merchant account?

Sign up for a merchant account through the app and follow the setup instructions to start accepting payments.

Can I track my payment status?

Yes, you can view and track your payment status in the account dashboard