<?php
/**
 * SeekQuarry/Yioop --
 * Open Source Pure PHP Search Engine, Crawler, and Indexer
 *
 * Copyright (C) 2009 - 2026  Chris Pollett chris@pollett.org
 *
 * LICENSE:
 *
 * 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/>.
 *
 * @author Chris Pollett chris@pollett.org
 * @license https://www.gnu.org/licenses/ GPL3
 * @link https://www.seekquarry.com/
 * @copyright 2009 - 2026
 * @filesource
 */
namespace seekquarry\yioop\locale\zh_CN\resources;
use seekquarry\yioop\configs as C;
use seekquarry\yioop\library as L;
use seekquarry\yioop\library\PhraseParser;

/**
 * Chinese specific tokenization code. Typically, tokenizer.php
 * either contains a stemmer for the language in question or
 * it specifies how many characters in a char gram
 *
 * @author Chris Pollett
 */

class Tokenizer
{
    /**
     * A list of frequently occurring terms for this locale which should
     * be excluded from certain kinds of queries. This is also used
     * for language detection
     * @var array
     */
    public static $stop_words = ['一', '人', '里', '会', '没', '她', '吗', '去',
        '也', '有', '这', '那', '不', '什', '个', '来', '要', '就', '我', '你',
        '的', '是', '了', '他', '么', '们', '在', '说', '为', '好', '吧', '知道',
        '我的', '和', '你的', '想', '只', '很', '都', '对', '把', '啊', '怎', '得',
        '还', '过', '不是', '到', '样', '飞', '远', '身', '任何', '生活', '够',
        '号', '兰', '瑞', '达', '或', '愿', '蒂', '別', '军', '正', '是不是',
        '证', '不用', '三', '乐', '吉', '男人', '告訴', '路', '搞', '可是',
        '与', '次', '狗', '决', '金', '史', '姆', '部', '正在', '活', '刚',
        '回家', '贝', '如何', '须', '战', '不會', '夫', '喂', '父', '亚', '肯定',
        '女孩', '世界'];
    /**
     * regular expression to determine if the None of the char in this
     * term is in current language.
     * @var string
     */
    public static $non_char_preg = "/^[^\p{Han}]+$/u";
    /**
     * The dictionary of characters can be used as Chinese Numbers
     * @var string
     */
    public static $num_dict =
       "1234567890○〇零一二两三四五六七八九十百千万亿".
       "０１２３４５６７８９壹贰叁肆伍陆柒捌玖拾廿卅卌佰仟萬億";
    /**
     * Dots used in Chinese Numbers
     * @var string
     */
    public static $dot = "\.．点";
    /**
     * A list of characters can be used at the end of numbers
     * @var string
     */
    public static $num_end = "％%";
    /**
     * Exception words of the regex found by functions:
     * isCardinalNumber, isOrdinalNumber, isDate
     * ex. "十分" in most of time means "very", but it will
     * be determined to be "10 minutes" by the function so we
     * need to remove it
     * @var array of string
     */
    public static $exception_list= ["十分","一","一点","千万",
    "万一", "一一", "拾", "一时", "千千", "万万", "陆"];
    /**
     * A list of characters can be used as Chinese punctuations
     * @var string
     */
    public static $punctuation_preg =
    "/^([\x{2000}-\x{206F}\x{3000}-\x{303F}\x{FF00}-\x{FF0F}" .
    "\x{FF1A}-\x{FF20}\x{FF3B}-\x{FF40}\x{FF5B}-\x{FF65}" .
    "\x{FFE0}-\x{FFEE}\x{21}-\x{2F}\x{21}-\x{2F}" .
    "\x{3A}-\x{40}\x{5B}-\x{60}\x{25cf}])\\1*$/u";
    /**
     * Any unique identifier corresponding to the component of a triplet which
     * can be answered using a question answer list
     * @var string
     */
    public static $question_token = "qqq";
    /**
     * Words array that determine if a sentence passed in is a question
     * @var array
     */
    public static $question_words = [
        "any" => ["谁" => "who",
                "哪儿|哪里" => "where",
                "哪个" => "which",
                "哪些" => "list",
                "哪" => ["after" => [   "1|一"=>"which",
                                    "[2-9]|[1-9][0-9]+"=>"list"
                                ],
                       "other"=>"where"
                        ],
                "什么|啥|咋" => [ "after" => [    "地方"=>"where",
                                            "地点"=>"where",
                                            "时\w*"=>"when"
                                       ],
                                "other" => "what"],
                "怎么|怎样|怎么样|如何" => "how",
                "为什么" => "why",
                "多少" => "how many",
                "几\w*" => ["any" => ["吗|\?|？" => "how many"],
                    "other" => false],
                "多久" => "how long",
                "多大" => "how big"
                ],
        "other" => [  "any" => [    "吗"=>"yesno",
                                "呢" => "what about"
                           ],
                    "other" => [  "other" => false,
                                "any" => ["\?|？" => "yesno"]
                             ]
                 ]
        ];
    /**
     * List of adjective-like parts of speech that might appear in lexicon file
     * Predicative adjective: VA
     * other noun-modifier: JJ
     * @var array
     */
    public static $adjective_type = ["VA", "JJ"];
    /**
     * List of adverb-like parts of speech that might appear in lexicon file
     * @var array
     */
    public static $adverb_type = ["AD"];
    /**
     * List of conjunction-like parts of speech that might appear in lexicon
     * file
     * Coordinating conjunction: CC
     * Subordinating conjunction: CS
     * @var array
     */
    public static $conjunction_type = ["CC", "CS"];
    /**
     * List of determiner-like parts of speech that might appear in lexicon
     * file
     * Determiner: DT
     * Cardinal Number: CD
     * Ordinal Number: OD
     * Measure word: M
     * @var array
     */
    public static $determiner_type = ["DT", "CD", "OD", "M"];
    /**
     * List of noun-like parts of speech that might appear in lexicon file
     * Proper Noun: NR
     * Temporal Noun: NT
     * Other Noun: NN
     * Pronoun: PN
     * @var array
     */
    public static $noun_type = ["NR", "NT", "NN", "PN"];
    /**
     * List of verb-like parts of speech that might appear in lexicon file
     * Copula: VC
     * you3 as the main verb: VE
     * Other verb: VV
     * Short passive voice: SB
     * Long passive voice: LB
     * @var array
     */
    public static $verb_type = ["VC", "VE", "VV", "SB", "LB"];
    /**
     * List of particle-like parts of speech that might appear in lexicon file
     * No meaning words that can appear anywhere
     * @var array
     */
    public static $particle_type = [
        "AS", "ETC", "DEC", "DEG", "DEV", "MSP",
        "DER", "SP", "IJ", "FW"];
    /**
     * StochasticTermSegmenter instance used for segmenting chines
     * @var object
     */
    private static $stochastic_term_segmenter;
    /**
     * Named Entity tagger instance used to recognizer noun entities in
     * Chinese text
     * @var object
     */
    private static $named_entity_tagger;
    /**
     * PartOfSpeechContextTagger instance used in adding part of speech
     * annotations to Chinese text
     * @var object
     */
    private static $pos_tagger;
    /**
     * Holds a associative array with keys which are traditional characters
     * and values their simplified character correspondents.
     * @var array
     */
    private static $traditional_simplified_map;
    /**
     * Removes the stop words from the page (used for Word Cloud generation
     * and language detection)
     *
     * @param mixed $data either a string or an array of string to remove
     *      stop words from
     * @return mixed $data with no stop words
     */
    public static function stopwordsRemover($data)
    {
        static $pattern = "";
        if (empty($pattern)) {
            $pattern = '/(' . implode('|', self::$stop_words) . ')/u';
        }
        $data = self::normalize($data);
        $data = preg_replace($pattern, '', $data);
        return $data;
    }
    /**
     * A word segmenter.
     * Such a segmenter on input thisisabunchofwords would output
     * this is a bunch of words
     *
     * @param string $pre_segment  before segmentation
     * @param string $method  indicates which method to use
     * @return string with words separated by space
     */
    public static function segment($pre_segment, $method = "STS")
    {
        switch($method)
        {
            case "RMM":
                return PhraseParser::reverseMaximalMatch($pre_segment, "zh-CN",
                ['/^\d+$/', '/^[a-zA-Z]+$/']);
            case "STS":
                return self::getStochasticTermSegmenter()
                    ->segmentText($pre_segment);
        }
    }
    /**
     * Check if the term passed in is a Cardinal Number
     * @param string $term to check if a cardinal number or not
     * @return bool whether it is a cardinal or not
     */
    public static function isCardinalNumber($term)
    {
        return !in_array($term,self::$exception_list)
            && preg_match("/^([" . self::$num_dict .
            "]+([" . self::$dot . "][" .self::$num_dict .
            "]+)?[" . self::$num_end .
            "]?[余餘多]?[百千万亿佰仟萬億]*)".
            "$|^([".self::$num_dict."]+分之[" . self::$num_dict .
            "]+([" . self::$dot . "][" .self::$num_dict .
            "]+)?)$/u", $term);
    }
    /**
     * Check if the term passed in is a Ordinal Number
     * @param string $term to check if a ordinal number or not
     * @return bool whether it is a ordinal or not
     */
    public static function isOrdinalNumber($term)
    {
        return !in_array($term,self::$exception_list)
            && preg_match("/^第[" . self::$num_dict .
            "]*$/u", $term);
    }
    /**
     * Check if the term passed in is a date
     * @param string $term to check if a date or not
     * @return bool whether it is a date or not
     */
    public static function isDate($term)
    {
        return !in_array($term,self::$exception_list)
            && preg_match("/^[" . self::$num_dict .
            "]+(年|年代|月|日|时|小时|時|小時|" .
            "点|点钟|點|點鐘|分|分鐘|秒|秒鐘)$/u",$term);
    }
    /**
     * Check if the term is a punctuation
     *
     * @param string $term term to test
     * @return int 1 if $term matches the punctuation regex, 0 otherwise
     *  (the return value of preg_match)
     */
    public static function isPunctuation($term)
    {
        return preg_match(self::$punctuation_preg, $term);
    }
    /**
     * Check if all the chars in the term is NOT current language
     * @param string $term is a string that to be checked
     * @return bool true if all the chars in $term is NOT current language
     *         false otherwise
     */
    public static function isNotCurrentLang($term)
    {
        return preg_match(self::$non_char_preg, $term);
    }
    /**
     * Get the segmenter instance, instantiating it if necessary
     * @return StochasticTermSegmenter the cached zh-CN segmenter
     *      instance, constructed lazily on first call
     */
    public static function getStochasticTermSegmenter()
    {
        if (!self::$stochastic_term_segmenter) {
            self::$stochastic_term_segmenter
                = new L\StochasticTermSegmenter("zh-CN");
        }
        return self::$stochastic_term_segmenter;
    }
    /**
     * Determines the part of speech tag of a term using simple rules if
     * possible
     * @param string $term to see if can get a part of speech for via a rule
     * @return string part of speech tag or $term if can't be determine
     */
    public static function getPosKey($term)
    {
        if (self::isPunctuation($term)) {
            return 'PU';
        } else if (self::isCardinalNumber($term)) {
            return 'CD';
        } else if (self::isOrdinalNumber($term)) {
            return 'OD';
        } else if (self::isDate($term)) {
            return 'NT';
        } else if (self::isNotCurrentLang($term)) {
            return 'FW';
        }
        return $term;
    }
    /**
     * Possible tags a term can have that can be determined by a simple rule
     * @return array list of POS tag strings (PU, CD, OD, NT, FW) that
     *      getPosKey can return without consulting the segmenter
     */
    public static function getPosKeyList()
    {
        return ['PU','CD','OD','NT','FW'];
    }
    /**
     * Return list of possible tags that an unknown term can have
     * @return array list of POS tag strings (NN, NR, VV, VA) that an
     *      unknown term might be assigned by the segmenter
     */
    public static function getPosUnknownTagsList()
    {
        return ["NN","NR","VV","VA"];
    }
    /**
     * Get the named entity tagger instance
     * @return NamedEntityContextTagger for Chinese
     */
    public static function getNamedEntityTagger()
    {
        if (!self::$named_entity_tagger) {
            self::$named_entity_tagger
                = new L\NamedEntityContextTagger("zh-CN");
        }
        return self::$named_entity_tagger;
    }
    /**
     * Get Part of Speec instance
     * @return PartOfSpeechContextTagger for Chinese
     */
    public static function getPosTagger()
    {
        if (!self::$pos_tagger) {
            self::$pos_tagger
                = new L\PartOfSpeechContextTagger("zh-CN");
        }
        return self::$pos_tagger;
    }
    /**
     * Converts traditional Chinese characters to simplified characters
     * @param  string $text is a string of Chinese Char
     * @return string normalized form of the text
     */
    public static function normalize($text)
    {
        if (empty(self::$traditional_simplified_map)) {
            $path = C\LOCALE_DIR .
                "/zh_CN/resources/traditional_simplified.txt.gz";
            if (!file_exists($path)) {
                return $text;
            }
            self::$traditional_simplified_map =
                unserialize(gzdecode(file_get_contents($path)));
        }
        if (is_string($text)) {
            if (!($chars = preg_split('//u', $text, -1,
                PREG_SPLIT_NO_EMPTY))) {
                return $text;
            }
        } else {
            return $text;
        }
        $num_chars = count($chars);
        for($i = 0; $i < $num_chars; $i++) {
            if (isset(self::$traditional_simplified_map[$chars[$i]])) {
                $chars[$i] = self::$traditional_simplified_map[$chars[$i]];
            }
        }
        return implode($chars);
    }
    /**
     * Scans a word list for phrases. For phrases found generate
     * a list of question and answer pairs at two levels of granularity:
     * CONCISE (using all terms in original phrase) and RAW (removing
     * (adjectives, etc).
     *
     * @param array $word_and_phrase_list of statements
     * @return array with two fields: QUESTION_LIST consisting of triplets
     *      (SUBJECT, PREDICATES, OBJECT) where one of the components has been
     *      replaced with a question marker.
     */
    public static function extractTripletsPhrases($word_and_phrase_list)
    {
        $triplets_list = [];
        $question_list = [];
        $question_answer_list = [];
        $triplet_types = ['CONCISE', 'RAW'];
        foreach ($word_and_phrase_list as $word_and_phrase => $position_list) {
            // strip parentheticals
            $word_and_phrase = preg_replace(
                "/[\{\[\(【（][^\}\]）】\)]+[\}\]\)）】]/u",
                "", $word_and_phrase);
            $tagged_phrase = self::tagTokenizePartOfSpeech($word_and_phrase);
            $parse_tree = ['cur_node' => 0];
            $extracted_triplets_set = [];
            $extracted_triplets=[];
            $pre_sub = [];
            while ($parse_tree['cur_node'] < count($tagged_phrase)) {
                $parse_tree = self::parseWholePhrase($tagged_phrase,
                ['cur_node'=>$parse_tree['cur_node']],$pre_sub);
                $triplets = self::extractTripletsParseTree($parse_tree);
                if (isset($parse_tree['NP'])) {
                    $pre_sub = $parse_tree['NP'];
                }
                $extracted_triplets_set[] = self::rearrangeTripletsByType(
                    $triplets);
                // next partial sentence
                while($parse_tree['cur_node'] < count($tagged_phrase)
                    && $tagged_phrase[$parse_tree['cur_node']]["tag"] != "PU") {
                    $parse_tree['cur_node']++;
                }
                $parse_tree['cur_node']++;
            }
            foreach($extracted_triplets_set as $extracted_triplets) {
                foreach ($triplet_types as $type) {
                    if (!empty($extracted_triplets[$type])) {
                        $triplets = $extracted_triplets[$type];
                        $questions = $triplets['QUESTION_LIST'];
                        foreach ($questions as $question) {
                            $question_list[$question] = $position_list;
                        }
                        $question_answer_list = array_merge(
                            $question_answer_list,
                            $triplets['QUESTION_ANSWER_LIST']);
                    }
                }
            }
        }
        $out_triplets['QUESTION_LIST'] = $question_list;
        $out_triplets['QUESTION_ANSWER_LIST'] = $question_answer_list;
        return $out_triplets;
    }
    /**
     * Split input text into terms and output an array with one element
     * per term, that element consisting of array with the term token
     * and the part of speech tag.
     *
     * @param string $text string to tag and tokenize
     * @return array of pairs of the form ("token" => token_for_term,
     *     "tag"=> part_of_speech_tag_for_term) for one each token in $text
     */
    public static function tagTokenizePartOfSpeech($text)
    {
        $segmented = self::getStochasticTermSegmenter()->segmentSentence($text);
        $tags = self::getPosTagger()->predict($segmented);
        $result=[];
        for($i = 0; $i < count($segmented); $i++) {
            $result[$i] = [];
            $result[$i]["token"] = $segmented[$i];
            $result[$i]["tag"] = $tags[$i];
        }
        return $result;
    }
    /**
     * Starting at the $cur_node in a $tagged_phrase parse tree for an English
     * sentence, create a phrase string for each of the next nodes
     * which belong to part of speech group $type.
     *
     * @param array &$cur_node node within parse tree
     * @param array $tagged_phrase parse tree for phrase
     * @param string $type self::$noun_type, self::$verb_type, etc
     * @return string phrase string involving only terms of that $type
     */
    public static function parseTypeList(&$cur_node, $tagged_phrase, $type)
    {
        $string = "";
        $previous_string = "";
        $previous_tag = "";
        $start_node = $cur_node;
        $next_tag = (empty($tagged_phrase[$cur_node]['tag'])) ? "" :
            trim($tagged_phrase[$cur_node]['tag']);
        $allowed_conjuncts = [];
        while ($next_tag && (in_array($next_tag, $type) ||
            in_array($next_tag, $allowed_conjuncts))) {
            $previous_string = $string;
            $string .= $tagged_phrase[$cur_node]['token'];
            $cur_node++;
            $allowed_conjuncts = self::$conjunction_type;
            $previous_tag = $next_tag;
            $next_tag = (empty($tagged_phrase[$cur_node]['tag'])) ? "" :
                trim($tagged_phrase[$cur_node]['tag']);
        }
        if (in_array($previous_tag, $allowed_conjuncts) && $start_node <
            $cur_node) {
            $cur_node--;
            $string = $previous_string;
        }
        return $string;
    }
    /**
     * Takes a part-of-speech tagged phrase and pre-tree with a
     * parse-from position and builds a parse tree for an adjective if possible
     *
     * @param array $tagged_phrase
     *      an array of pairs of the form ("token" => token_for_term,
     *     "tag"=> part_of_speech_tag_for_term)
     * @param array $tree that consists of ["cur_node" =>
     *      current parse position in $tagged_phrase]
     * @return array has fields
     *      "cur_node" index of how far we parsed $tagged_phrase
     *      "JJ" a subarray with a token node for the adjective that was
     *      parsed
     */
    public static function parseAdjective($tagged_phrase, $tree)
    {
        $adjective_string = self::parseTypeList($tree['cur_node'],
            $tagged_phrase, self::$adjective_type);
        if (!empty($adjective_string)) {
            $tree["JJ"] = $adjective_string;
            $partical_string = self::parseTypeList($tree['cur_node'],
                $tagged_phrase,self::$particle_type);
            if ($partical_string) {
                $tree["PARTICAL"] = $partical_string;
            }
        }
        return $tree;
    }
    /**
     * Takes a part-of-speech tagged phrase and pre-tree with a
     * parse-from position and builds a parse tree for a determiner if possible
     *
     * @param array $tagged_phrase
     *      an array of pairs of the form ("token" => token_for_term,
     *     "tag"=> part_of_speech_tag_for_term)
     * @param array $tree that consists of ["curnode" =>
     *      current parse position in $tagged_phrase]
     * @return array has fields
     *      "cur_node" index of how far we parsed $tagged_phrase
     *      "DT" a subarray with a token node for the determiner that was
     *      parsed
     */
    public static function parseDeterminer($tagged_phrase, $tree)
    {
        $determiner_string = "";
        /* In: All the cows low, "All the" is considered a determiner.
           That is, we will mush together the predeterminer with the determiner
         */
        $determiner_string = self::parseTypeList($tree['cur_node'],
            $tagged_phrase, self::$determiner_type);
        if (!empty($determiner_string)) {
            $tree["DT"] = $determiner_string;
            $partical_string = self::parseTypeList($tree['cur_node'],
                $tagged_phrase,self::$particle_type);
            if ($partical_string) {
                $tree["PARTICAL"] = $partical_string;
            }
        }
        return $tree;
    }
    /**
     * Takes a part-of-speech tagged phrase and pre-tree with a
     * parse-from position and builds a parse tree for a noun if possible
     *
     * @param array $tagged_phrase
     *      an array of pairs of the form ("token" => token_for_term,
     *     "tag"=> part_of_speech_tag_for_term)
     * @param array $tree that consists of ["curnode" =>
     *      current parse position in $tagged_phrase]
     * @return array has fields
     *      "cur_node" index of how far we parsed $tagged_phrase
     *      "NN" a subarray with a token node for the noun string that was
     *      parsed
     */
    public static function parseNoun($tagged_phrase, $tree)
    {
        //Combining multiple noun into one
        $noun_string = self::parseTypeList($tree['cur_node'], $tagged_phrase,
            self::$noun_type);
        if (!empty($noun_string)) {
            $tree["NN"] = $noun_string;
            $partical_string = self::parseTypeList($tree['cur_node'],
                $tagged_phrase,self::$particle_type);
            if ($partical_string) {
                $tree["PARTICAL"] = $partical_string;
            }
        }
        return $tree;
    }
    /**
     * Takes a part-of-speech tagged phrase and pre-tree with a
     * parse-from position and builds a parse tree for a verb if possible
     *
     * @param array $tagged_phrase
     *      an array of pairs of the form ("token" => token_for_term,
     *     "tag"=> part_of_speech_tag_for_term)
     * @param array $tree that consists of ["curnode" =>
     *      current parse position in $tagged_phrase]
     * @return array has fields
     *      "cur_node" index of how far we parsed $tagged_phrase
     *      "VB" a subarray with a token node for the verb string that was
     *      parsed
     */
    public static function parseVerb($tagged_phrase, $tree)
    {
        $verb_string = self::parseTypeList($tree['cur_node'], $tagged_phrase,
            self::$verb_type);
        if (!empty($verb_string)) {
            $tree["VB"] = $verb_string;
            $partical_string = self::parseTypeList($tree['cur_node'],
                $tagged_phrase,self::$particle_type);
            if ($partical_string) {
                $tree["PARTICAL"] = $partical_string;
            }
        }
        return $tree;
    }
    /**
     * Takes a part-of-speech tagged phrase and pre-tree with a
     * parse-from position and builds a parse tree for a sequence of
     * prepositional phrases if possible
     *
     * @param array $tagged_phrase
     *      an array of pairs of the form ("token" => token_for_term,
     *     "tag"=> part_of_speech_tag_for_term)
     * @param array $tree that consists of ["cur_node" =>
     *      current parse position in $tagged_phrase]
     * @param int $index which term in $tagged_phrase to start to try to parse
     *      a preposition from
     * @return array has fields
     *      "cur_node" index of how far we parsed $tagged_phrase
     *      parsed followed by additional possible fields (here i
     *      represents the ith clause found):
     *      "IN_i" with value a preposition subtree
     *      "DT_i" with value a determiner subtree
     *      "JJ_i" with value an adjective subtree
     *      "NN_i"  with value an additional noun subtree
     */
    public static function parsePrepositionalPhrases($tagged_phrase, $tree,
        $index = 1)
    {
        $cur_node = $tree['cur_node'];
        /* There are two forms of preposition.
           The first one has lc only
           之前(lc) 他在看书 */
        if (isset($tagged_phrase[$cur_node]['tag']) &&
            trim($tagged_phrase[$cur_node]['tag']) == "LC") {
            $tree["LC"] = $tagged_phrase[$cur_node]['token'];
            $tree['cur_node']+=1;
            return $tree;
        }
        /* Second form:
          format: prep [anything] [locolizer|punctuation]
           在(p)今天早上，(pu) 他 在(p) 车 里(lc) 睡觉。
           In the morning today, he was sleeping in the car.
         */
        if (isset($tagged_phrase[$cur_node]['tag']) &&
            trim($tagged_phrase[$cur_node]['tag']) == "P") {
            /* can have multiple prep's in a row, for example,
               it is known in over 20 countries
              */
            $preposition_string = self::parseTypeList($cur_node, $tagged_phrase,
                ["P"]);
            if (!empty($preposition_string)) {
                $tree["P"] = $preposition_string;
            }
            while(isset($tagged_phrase[$cur_node]) &&
                isset($tagged_phrase[$cur_node]['tag']) &&
                !in_array($tagged_phrase[$cur_node]['tag'],["PU", "LC"])) {
                $tree["P"] .= $tagged_phrase[$cur_node]['token'];
                $cur_node++;
            }
            $lc_string = self::parseTypeList($cur_node, $tagged_phrase,
                ["LC"]);
            if ($lc_string) {
                $tree["P"] .= $lc_string;
            }
            $partical_string = self::parseTypeList($cur_node,
                $tagged_phrase,self::$particle_type);
            if ($partical_string) {
                $tree["PARTICAL"] = $partical_string;
            }
        }
        $tree['cur_node'] = $cur_node;
        return $tree;
    }
    /**
     * Takes a part-of-speech tagged phrase and pre-tree with a
     * parse-from position and builds a parse tree for a noun phrase if possible
     *
     * @param array $tagged_phrase
     *      an array of pairs of the form ("token" => token_for_term,
     *     "tag"=> part_of_speech_tag_for_term)
     * @param array $tree that consists of ["curnode" =>
     *      current parse position in $tagged_phrase]
     * @return array has fields
     *      "cur_node" index of how far we parsed $tagged_phrase
     *      "NP" a subarray with possible fields
     *      "DT" with value a determiner subtree
     *      "JJ" with value an adjective subtree
     *      "NN" with value a noun tree
     */
    public static function parseNounPhrase($tagged_phrase, $tree)
    {
        $cur_node = $tree['cur_node'];
        $tree_dt = self::parseDeterminer($tagged_phrase,
            ['cur_node' => $cur_node]);
        $tree_jj = self::parseAdjective($tagged_phrase,
            ['cur_node' => $tree_dt['cur_node']]);
        $tree_pp = self::parsePrepositionalPhrases($tagged_phrase,
            ['cur_node' => $tree_jj['cur_node']]);
        $tree_nn = self::parseNoun($tagged_phrase,
            ['cur_node' => $tree_pp['cur_node']]);
        if ($tree_nn['cur_node'] == $tree_pp['cur_node']) {
            $tree['NP'] = "";
            return $tree;
        }
        $tree_pp2 = self::parsePrepositionalPhrases($tagged_phrase,
            ['cur_node' => $tree_nn['cur_node']]);
        $cur_node = $tree_pp2['cur_node'];
        $cc = "";
        if (!empty($tagged_phrase[$cur_node]['tag']) &&
            in_array($tagged_phrase[$cur_node]['tag'],
            self::$conjunction_type)) {
            $cc = $tagged_phrase[$cur_node]['token'];
            $cur_node++;
        }
        $tree_np = self::parseNounPhrase($tagged_phrase,
            ['cur_node' => $cur_node]);
        if ($tree_np['cur_node'] == $cur_node && $cc) {
            $cur_node--;
            $tree_np = [];
            $cc = "";
        } else {
            $cur_node = $tree_np['cur_node'];
        }
        unset($tree_dt['cur_node'], $tree_jj['cur_node'],
            $tree_nn['cur_node'], $tree_pp['cur_node'],
            $tree_np['cur_node'], $tree_pp2['cur_node']);
        $sub_tree = ['DT' => $tree_dt, 'JJ' => $tree_jj, 'PRP' => $tree_pp,
        'NN' => $tree_nn, 'PRP2'=>$tree_pp2,'CC' => $cc,
            'ADD_NP' => $tree_np];
        return ['cur_node' => $cur_node, 'NP' => $sub_tree];
    }
    /**
     * Takes a part-of-speech tagged phrase and pre-tree with a
     * parse-from position and builds a parse tree for a verb phrase if possible
     *
     * @param array $tagged_phrase
     *      an array of pairs of the form ("token" => token_for_term,
     *     "tag"=> part_of_speech_tag_for_term)
     * @param array $tree that consists of ["curnode" =>
     *      current parse position in $tagged_phrase]
     * @return array has fields
     *      "cur_node" index of how far we parsed $tagged_phrase
     *      "VP" a subarray with possible fields
     *      "VB" with value a verb subtree
     *      "NP" with value an noun phrase subtree
     */
    public static function parseVerbPhrase($tagged_phrase, $tree)
    {
        $cur_node = $tree['cur_node'];
        $adverb_string="";
        do {
            $start_node=$cur_node;
            $adverb_string .= self::parseTypeList($cur_node, $tagged_phrase,
                self::$adverb_type);
            $adverb_string .= self::parseTypeList($cur_node, $tagged_phrase,
                self::$particle_type);
        } while($start_node!=$cur_node);
        if (!empty($adverb_string)) {
            $tree_vb["RB"] = $adverb_string;
        } else {
            $tree_vb=[];
        }
        $tree_vb = array_merge($tree_vb,
            self::parseVerb($tagged_phrase, ['cur_node' => $cur_node]));
        if ($cur_node == $tree_vb['cur_node']) {
            // if no verb return what started with
            return $tree;
        }
        $cur_node = $tree_vb['cur_node'];
        $tree_np = self::parseNounPhrase($tagged_phrase,
            ['cur_node' => $tree_vb['cur_node']]);
        $cur_node = $tree_np['cur_node'];
        if (!empty($tree_np['NP'])) {
            unset($tree_vb['cur_node'], $tree_np['cur_node']);
            return ['VP' => ['VB' => $tree_vb, 'NP' => $tree_np['NP']],
                'cur_node' => $cur_node];
        }
        unset($tree_vb['cur_node']);
        return ['VP' => ['VB' => $tree_vb], 'cur_node' => $cur_node];
    }
    /**
     * Given a part-of-speeech tagged phrase array generates a parse tree
     * for the phrase using a recursive descent parser.
     *
     * @param array $tagged_phrase an array of pairs of the form
     *  ("token" => token_for_term, "tag"=> part_of_speech_tag_for_term)
     * @param $tree that consists of ["curnode" =>
     *  current parse position in $tagged_phrase]
     * @param $tree_np_pre subject found from previous sub-sentence
     * @return array used to represent a tree. The array has up to three fields
     *  $tree["cur_node"] index of how far we parsed our$tagged_phrase
     *  $tree["NP"] contains a subtree for a noun phrase
     *  $tree["VP"] contains a subtree for a verb phrase
     */
    public static function parseWholePhrase($tagged_phrase, $tree,
        $tree_np_pre = [])
    {
        //remove heading adverbs
        $cur_node = $tree['cur_node'];
        do {
            $start_node = $cur_node;
            self::parseTypeList($cur_node, $tagged_phrase,
                self::$adverb_type);
            self::parseTypeList($cur_node, $tagged_phrase,
                self::$particle_type);
        } while ($start_node != $cur_node);
        $tree_np = self::parseNounPhrase($tagged_phrase,
            ["cur_node" => $cur_node]);
        if ($tree_np['cur_node'] == $cur_node) {
            if (!empty($tree_np_pre)) {
                $tree_np['NP'] = $tree_np_pre;
                $tree_np["cur_node"] = $cur_node;
            } else {
                return $tree;
            }
        }
        $tree_vp = self::parseVerbPhrase($tagged_phrase,
            ["cur_node" => $tree_np['cur_node']]);
        if ($tree_np['cur_node'] == $tree_vp['cur_node']) {
            return $tree;
        }
        $cur_node = $tree_vp['cur_node'];
        unset($tree_np['cur_node'], $tree_vp['cur_node']);
        if (!empty($tree_start) && !empty($tree_np['NP'])) {
            $tree_np['NP']['PRP-1'] = $tree_start;
        }
        return ['cur_node' => $cur_node, 'NP' => $tree_np['NP'],
            'VP' => $tree_vp['VP']];
    }
    /**
     * Takes a parse tree of a phrase and computes subject, predicate, and
     * object arrays. Each of these array consists of two components CONCISE and
     * RAW, CONCISE corresponding to something more similar to the words in the
     * original phrase and RAW to the case where extraneous words have been
     * removed
     *
     * @param are $tree a parse tree for a sentence
     * @return array triplet array
     */
    public static function extractTripletsParseTree($tree)
    {
        $triplets = [];
        $triplets['subject'] = self::extractSubjectParseTree($tree);
        $triplets['predicate'] = self::extractPredicateParseTree($tree);
        $triplets['object'] = self::extractObjectParseTree($tree);
        return $triplets;
    }
    /**
     * Takes phrase tree $tree and a part-of-speech $pos returns
     * the deepest $pos only path in tree.
     *
     * @param array $tree phrase to extract type from
     * @param string $pos the part of speech to extract
     * @return string the label of deepest $pos only path in $tree
     */
    public static function extractDeepestSpeechPartPhrase($tree, $pos)
    {
        $extract = "";
        if (!empty($tree[$pos])) {
            $extract = self::extractDeepestSpeechPartPhrase($tree[$pos], $pos);
        }
        if (!$extract && !empty($tree[$pos]) && !empty($tree[$pos][$pos])) {
            $extract = $tree[$pos][$pos];
        }
        return $extract;
    }
    /**
     * Takes a parse tree of a phrase or statement and returns an array
     * with two fields CONCISE and RAW the former having the object of
     * the original phrase (as a string) the latter having the importart
     * parts of the object
     *
     * @param array $tree representation of a parse tree of a phrase
     * @return array with two fields CONCISE and RAW as described above
     */
    public static function extractObjectParseTree($tree)
    {
        $object = [];
        if (!empty($tree['VP'])) {
            $tree_vp = $tree['VP'];
            if (!empty($tree_vp['NP'])) {
                $nb = $tree_vp['NP'];
                $object['CONCISE'] = $tree_vp['NP'];
                while (isset($object['CONCISE']["ADD_NP"]["NP"]) &&
                    is_array($object['CONCISE']["ADD_NP"]["NP"])) {
                    $object['CONCISE'] = $object['CONCISE']["ADD_NP"]["NP"];
                }
                $object['CONCISE'] = $object['CONCISE']["NN"]["NN"] ??
                    "";
                $raw_object = "";
                $it = new \RecursiveIteratorIterator(
                    new \RecursiveArrayIterator($nb));
                foreach ($it as $v) {
                    $raw_object .= $v;
                }
                $object['RAW'] = $raw_object;
            } else {
                $object['CONCISE'] = "";
                $object['RAW'] = "";
            }
        } else {
            $object['CONCISE'] = "";
            $object['RAW'] = "";
        }
        return $object;
    }
    /**
     * Takes a parse tree of a phrase or statement and returns an array
     * with two fields CONCISE and RAW the former having the predicate of
     * the original phrase (as a string) the latter having the importart
     * parts of the predicate
     *
     * @param array $tree representation of a parse tree of a phrase
     * @return array with two fields CONCISE and RAW as described above
     */
    public static function extractPredicateParseTree($tree)
    {
        $predicate = [];
        if (!empty($tree['VP'])) {
            $tree_vp = $tree['VP'];
            $predicate['CONCISE'] = self::extractDeepestSpeechPartPhrase(
                $tree_vp, "VB");
            $raw_predicate = "";
            if (!empty($tree_vp['VB'])) {
                $tree_vb = $tree_vp['VB'];
                $it = new \RecursiveIteratorIterator(
                    new \RecursiveArrayIterator($tree_vb));
                foreach ($it as $v) {
                    $raw_predicate .= $v;
                }
                $predicate['RAW'] = $raw_predicate;
            }
        } else {
            $predicate['CONCISE'] = "";
            $predicate['RAW'] = "";
        }
        return $predicate;
    }
    /**
     * Takes a parse tree of a phrase or statement and returns an array
     * with two fields CONCISE and RAW the former having the subject of
     * the original phrase (as a string) the latter having the importart
     * parts of the subject
     *
     * @param array $tree representation of a parse tree of a phrase
     * @return array with two fields CONCISE and RAW as described above
     */
    public static function extractSubjectParseTree($tree)
    {
        $subject = [];
        if (!empty($tree['NP'])) {
            $subject['CONCISE'] = $tree['NP'];
            while (isset($subject['CONCISE']["ADD_NP"]["NP"]) &&
                is_array($subject['CONCISE']["ADD_NP"]["NP"])) {
                $subject['CONCISE'] = $subject['CONCISE']["ADD_NP"]["NP"];
            }
            $subject['CONCISE'] = $subject['CONCISE']["NN"]["NN"] ?? "";
            $raw_subject = "";
            $it = new \RecursiveIteratorIterator(
                new \RecursiveArrayIterator($tree['NP']));
            foreach ($it as $v) {
                $raw_subject .= $v ;
            }
            $subject['RAW'] = $raw_subject;
        } else {
            $subject['CONCISE'] = "";
            $subject['RAW'] = "";
        }
        return $subject;
    }
    /**
     * Takes a triplets array with subject, predicate, object fields with
     * CONCISE and RAW subfields and rearranges it to have two fields CONCISE
     * and RAW with subject, predicate, object, and QUESTION_ANSWER_LIST
     * subfields
     *
     * @param array $sub_pred_obj_triplets in format described above
     * @return array $processed_triplets in format described above
     */
    public static function rearrangeTripletsByType($sub_pred_obj_triplets)
    {
        $processed_triplet = [];
        $processed_triplets['CONCISE'] =
            self::extractTripletByType($sub_pred_obj_triplets, "CONCISE");
        $processed_triplets['RAW'] =
            self::extractTripletByType($sub_pred_obj_triplets, "RAW");
        return $processed_triplets;
    }
    /**
     * Takes a triplets array with subject, predicate, object fields with
     * CONCISE, RAW subfields and produces a triplits with $type subfield (where
     * $type is one of CONCISE and RAW) and with subject, predicate, object,
     * and QUESTION_ANSWER_LIST subfields
     *
     * @param array $sub_pred_obj_triplets  in format described above
     * @param string $type either CONCISE or RAW
     * @return array $triplets in format described above
     */
    public static function extractTripletByType($sub_pred_obj_triplets, $type)
    {
        $triplets = [];
        if (!empty($sub_pred_obj_triplets['subject'][$type])
            && !empty($sub_pred_obj_triplets['predicate'][$type])
            && !empty($sub_pred_obj_triplets['object'][$type])) {
            $question_answer_triplets = [];
            $sentence = [ trim($sub_pred_obj_triplets['subject'][$type]),
                trim($sub_pred_obj_triplets['predicate'][$type]),
                trim($sub_pred_obj_triplets['object'][$type])];
            $question_triplets = [];
            for ($j = 0; $j < 2; $j++) {
                if ($j == 1 && in_array($sentence[1], ['是'])) {
                    $tmp = $sentence[2];
                    $sentence[2] = $sentence[0];
                    $sentence[0] = $tmp;
                } else if ($j == 1) {
                    break;
                }
                for ($i = 0; $i < 3; $i++) {
                    $q_sentence = $sentence;
                    $q_sentence[$i] = self::$question_token;
                    $q_sentence_string = implode(" ", $q_sentence);
                    $question_triplets[] = $q_sentence_string;
                    $question_answer_triplets[$q_sentence_string] =
                        preg_replace('/\s+/u', ' ',$sentence[$i]);
                }
            }
            $triplets['QUESTION_LIST'] = $question_triplets;
            $triplets['QUESTION_ANSWER_LIST'] = $question_answer_triplets;
        }
        return $triplets;
    }
    /**
     * Takes any question started with WH question and returns the
     * triplet from the question
     *
     * @param string $question question to parse
     * @return array question triplet
     */
    public static function questionParser($question)
    {
        $tagged_question = self::tagTokenizePartOfSpeech($question);
        $generated_questions = [];
        $keywords = self::isQuestion($question);
        if ($keywords) {
            $generated_questions=self::parseQuestion(
                $tagged_question, 1, $keywords);
        }
        return $generated_questions;
    }
    /**
     * Takes a phrase query entered by user and return true if it is question
     * and false if not
     *
     * @param $phrase any statement
     * @return bool returns question word if statement is question
     */
    public static function isQuestion($phrase)
    {
        $terms=self::getStochasticTermSegmenter()->segmentSentence($phrase);
        $qt=self::questionType($terms, self::$question_words);
        if (in_array($qt["types"], ["who","what","which","where","when",
            "whose", "how", "how many", "how long", "how big"])) {
            return $qt["ques_words"];
        }
        return false;
    }
    /**
     * Takes tagged question string starts with Who
     * and returns question triplet from the question string
     *
     * @param string $tagged_question part-of-speech tagged question
     * @param int $index current index in statement
     * @param string $question_word is the question word need to be replaced
     * @return array parsed triplet
     */
    public static function parseQuestion($tagged_question, $index,
        $question_word)
    {
        $generated_questions = [];
        $tree = ["cur_node" => 0];
        $parse_tree = self::parseWholePhrase($tagged_question, $tree);
        $triplets = self::extractTripletsParseTree($parse_tree);
        $triplet_types = ['CONCISE', 'RAW'];
        foreach ($triplet_types as $type) {
            if (!empty($triplets['subject'][$type])
                && !empty($triplets['predicate'][$type])
                && !empty($triplets['object'][$type])) {
                $sub = trim($triplets['subject'][$type]);
                $sub = preg_replace("/^.*".$question_word.".*$/u",
                    self::$question_token, $sub);
                $pre = trim($triplets['predicate'][$type]);
                $pre = preg_replace("/^.*".$question_word.".*$/u",
                    self::$question_token, $pre);
                $obj = trim($triplets['object'][$type]);
                $obj = preg_replace("/^.*".$question_word.".*$/u",
                    self::$question_token, $obj);
                $generated_questions[$type][] = $obj . " " . $pre . " " . $sub;
                $generated_questions[$type][] = $sub . " " . $pre . " " . $obj;
            }
        }
        return $generated_questions;
    }
    /**
     * Helper function for isQuestion
     * @param $term_array segmented Chinese terms
     * @param $type_list currect trace of self::$question_words
     * @return array ["ques_words" => matched question phrase,
     *  "types" => the corresponding type-tag string] -- both are empty
     *  when no question pattern was matched
     */
    public static function questionType($term_array, $type_list)
    {
        if (!isset($type_list["any"])) {
            return ["ques_words"=>"","types"=>""];
        }
        $types = "";
        $ques_words = "";
        for($i = 0; $i < count($term_array); $i++ ) {
            foreach($type_list["any"] as $key => $value) {
                if (preg_match('/^('.$key.')$/u',$term_array[$i])) {
                    if (is_array($value)) {
                        if(isset($value["after"])) {
                            $found_after = false;
                            if (array_key_exists($i+1,$term_array)) {
                                foreach($value["after"] as $key2 => $value2) {
                                    if (preg_match('/^(' . $key2 . ')$/u',
                                        $term_array[$i + 1])) {
                                        $ques_words = $term_array[$i].
                                            " " . $term_array[$i + 1];
                                        $types = $value2;
                                        $found_after = true;
                                        break;
                                    }
                                }
                            }
                            if (!$found_after && isset($type_list["other"]) &&
                                $value["other"]) {
                                $ques_words = $term_array[$i];
                                $types = $value["other"];
                            }
                        } elseif (isset($value["any"])) {
                            $t = self::questionType($term_array,$value);
                            $ques_words[] = $term_array[$i];
                            $types = $t["types"];
                        }
                    } elseif ($value) {
                        $ques_words = $term_array[$i];
                        $types = $value;
                    }
                }
            }
        }
        if ($types == "" && isset($type_list["other"])) {
            if (is_array($type_list["other"])) {
                $t = self::questionType($term_array, $type_list["other"]);
                $ques_words = $t["ques_words"];
                $types = $t["types"];
            } elseif ($type_list["other"]) {
                $types = $type_list["other"];
            }
        }
        return ["ques_words" => $ques_words, "types" => $types];
    }
}
