#include "StoryChainDocumentParser.h"

using namespace Parse;
using namespace Lex;
using namespace Syntax;
using namespace Syntax::Defines;
using namespace Parse::Result;

// storychain 解析器================================================
NodeStoryChainParser::NodeStoryChainParser(ProjectCore *core)
	: XSyntaxBase("文学脉络"), pjt_ref(core)
{
    set_common_expression("::换行前缀", {Elm("{换行符}"),Elm("{换行符}", true)});

	auto rule = addRule("文学脉络定义", 0, [this](const QList<LexResult> &seqs, int cnt)->ParseResult
	{
		auto nmidx = cnt - 1, defidx = cnt - 2;

		// 构建语法节点
		auto storychain = new NodeStoryChain(this->docRef(), seqs[nmidx].Text);
		this->refocusNode(storychain);

		// 收集词语
		auto words0 = new Words(storychain, this->docRef(), seqs[defidx].Text, seqs[defidx].StartRow, seqs[defidx].StartCol);
		auto words1 = new Words(storychain, this->docRef(), seqs[nmidx].Text, seqs[nmidx].StartRow, seqs[nmidx].StartCol);
		docRef()->append(words0);
		docRef()->append(words1);

		return ParseResult::SelfManipulate;
	});
    rule->addExpression("脉络定义基础", { Elm("{脉络定义}"), Elm("{描述文本}", true) });
    rule->addExpression("脉络定义拓展", { Exp("::换行前缀"), Exp("脉络定义基础", true)});



	rule = addRule("脉络成分解析", 1, [this](const QList<LexResult> &seqs, int cnt)->ParseResult
	{
		auto nmidx = cnt - 1;

		// 获取语法节点
		auto storychain = this->currNode();

		// 收集词语
		auto word = new Words(storychain, docRef(), seqs[nmidx].Text, seqs[nmidx].StartRow, seqs[nmidx].StartCol);
		docRef()->append(word);

		return ParseResult::EnterNext;
	});
    rule->addExpression("基础脉络界限", { Elm("{左界限}", true) });
    rule->addExpression("拓展脉络界限", { Exp("::换行前缀"), Exp("基础脉络界限", true) });



	rule = addRule("完成脉络解析", 2, [this](const QList<LexResult> &seqs, int cnt)->ParseResult
	{
		auto nmidx = cnt - 1;

		// 获取语法节点
		auto storychain = this->currNode();

		// 收集词语
		auto word = new Words(storychain, docRef(), seqs[nmidx].Text, seqs[nmidx].StartRow, seqs[nmidx].StartCol);
		docRef()->append(word);

		return ParseResult::Completed;
	});
    rule->addExpression("基础脉络跳出", { Elm("{右界限}", true) });
    rule->addExpression("拓展脉络跳出", { Exp("::换行前缀"), Exp("基础脉络跳出", true) });

	addChild(QList<SyntaxParser*>() << new NodeStoryPointParser(this) << new NodeStoryPureTextDesGroupParser(this));
}

ProjectCore * NodeStoryChainParser::project() const
{
	return pjt_ref;
}

// storypoint解析器=================================================
NodeStoryPointParser::NodeStoryPointParser(NodeStoryChainParser *chain)
	: XSyntaxBase("脉络驻点"), parent_parser(chain)
{
    set_common_expression("::换行前缀", {Elm("{换行符}"),Elm("{换行符}", true)});

	auto rule = addRule("脉络驻点定义", 0, [this](const QList<LexResult> &seqs, int c)->ParseResult {
		auto nmidx = c - 1, defidx = c - 2;

		// 语法节点定义
		auto node = this->storyChainParser()->currNode();
		auto storypoint = new NodeStoryPoint(static_cast<NodeStoryChain*>(node), seqs[nmidx].Text);
		node->appendChild(storypoint);
		this->refocusNode(storypoint);

		// 词语收集
		auto word0 = new Words(storypoint, node->document(), seqs[defidx].Text, seqs[defidx].StartRow, seqs[defidx].StartCol);
		auto word1 = new Words(storypoint, node->document(), seqs[nmidx].Text, seqs[nmidx].StartRow, seqs[nmidx].StartCol);
		node->document()->append(word0);
		node->document()->append(word1);

		return ParseResult::SelfManipulate;
	});
    rule->addExpression("基础节点定义", { Elm("{节点定义}"), Elm("{描述文本}", true) });
    rule->addExpression("拓展节点定义", { Exp("::换行前缀"), Exp("基础节点定义", true) });



	rule = addRule("节点成分解析", 1, [this](const QList<LexResult> &seqs, int cnt)->ParseResult
	{
		auto nmidx = cnt - 1;
		auto word = new Words(this->currNode(), this->storyChainParser()->docRef(), seqs[nmidx].Text, seqs[nmidx].StartRow, seqs[nmidx].StartCol);
		this->docRef()->append(word);

		return ParseResult::EnterNext;
	});
    rule->addExpression("基础节点界限", { Elm("{左界限}", true) });
    rule->addExpression("拓展节点界限", { Exp("::换行前缀"), Exp("基础节点界限", true) });



	rule = addRule("完成节点解析", 2, [this](const QList<LexResult> &seqs, int cnt)->ParseResult
	{
		auto nmidx = cnt - 1;
		auto word = new Words(this->currNode(), this->storyChainParser()->docRef(), seqs[nmidx].Text, seqs[nmidx].StartRow, seqs[nmidx].StartCol);
		this->docRef()->append(word);

		return ParseResult::Completed;
	});
    rule->addExpression("基础节点跳出", { Elm("{右界限}", true) });
    rule->addExpression("拓展节点跳出", { Exp("::换行前缀"), Exp("基础节点跳出", true) });

	addChild(QList<SyntaxParser*>() << new NodeStoryPureTextDesGroupParser(this));
}

NodeStoryChainParser * NodeStoryPointParser::storyChainParser() const
{
	return parent_parser;
}

DocCore * NodeStoryPointParser::docRef() const
{
	return this->storyChainParser()->docRef();
}




NodeStoryChain::NodeStoryChain(DocCore * doc, const QString & name)
	: doc_store(doc), name_store(name)
{
}

QString NodeStoryChain::srcPath() const
{
	return doc_store->filePath();
}

QString NodeStoryChain::name() const
{
	return name_store;
}

DocCore * NodeStoryChain::document() const
{
	return doc_store;
}

int NodeStoryChain::typeValue() const
{
	return NODE_STORYCHAIN;
}

DesNode * NodeStoryChain::parent() const
{
	return nullptr;
}

void NodeStoryChain::appendChild(DesNode * ins)
{
	children_nodes.append(ins);
}

QList<DesNode*> NodeStoryChain::children() const
{
	return children_nodes;
}

bool NodeStoryChain::check(QList<QString>& reasons) const
{
	return false;
}

QString NodeStoryChain::toString() const
{
	auto desc_string = QString(depth(), ' ') + "#脉络 " + name() + " {";
	for (auto it : children())
		desc_string += "\n"+ QString(depth(), ' ') + it->toString();
	desc_string +="\n"+ QString(depth(), ' ') + "}";

	return desc_string;
}

NodeStoryPoint::NodeStoryPoint(NodeStoryChain * chain, const QString & name)
	: chain_store(chain), name_store(name)
{
}

NodeStoryChain * NodeStoryPoint::storyChain() const
{
	return chain_store;
}

DocCore * NodeStoryPoint::document() const
{
	return chain_store->document();
}

int NodeStoryPoint::typeValue() const
{
	return NODE_STORYPOINT;
}

DesNode * NodeStoryPoint::parent() const
{
	return chain_store;
}

void NodeStoryPoint::appendChild(DesNode * ins)
{
	children_nodes.append(ins);
}

QList<DesNode*> NodeStoryPoint::children() const
{
	return children_nodes;
}

bool NodeStoryPoint::check(QList<QString>& reasons) const
{
	return false;
}

QString NodeStoryPoint::toString() const
{
	QString desc_string = "";
	desc_string += QString(depth(), ' ') + "#节点 " + name() + " {";
	for (auto it : children())
		desc_string += "\n" + QString(depth(), ' ') + it->toString();
	desc_string += "\n"+QString(depth(), ' ') + "}";

	return desc_string;
}

QString NodeStoryPoint::name() const
{
	return this->name_store;
}

NodeStoryDesGroup::NodeStoryDesGroup(DesNode * parent_refer)
	: parent_refer(parent_refer)
{
}

DocCore * NodeStoryDesGroup::document() const
{
	return parent_refer->document();
}

int NodeStoryDesGroup::typeValue() const
{
	return NODE_DESCRIPTION_GROUP;
}

DesNode * NodeStoryDesGroup::parent() const
{
	return parent_refer;
}

void NodeStoryDesGroup::appendChild(DesNode * ins)
{
	children_nodes << ins;
}

QList<DesNode*> NodeStoryDesGroup::children() const
{
	return children_nodes;
}

bool NodeStoryDesGroup::check(QList<QString>& reasons) const
{
	return false;
}

QString NodeStoryDesGroup::toString() const
{
	QString desc = QString(depth(), ' ') ;
	for (auto it : children())
		desc += it->toString() + " ";

	return desc;
}

NodeStoryDesBlock::NodeStoryDesBlock(DesNode *parent_node, const QString &text)
	: parent_refer(parent_node), text_block(text)
{
}

DocCore * NodeStoryDesBlock::document() const
{
	return parent_refer->document();
}

int NodeStoryDesBlock::typeValue() const
{
	return NODE_DESCRIPTION_BLOCK;
}

DesNode * NodeStoryDesBlock::parent() const
{
	return parent_refer;
}

void NodeStoryDesBlock::appendChild(DesNode * ins)
{
}

QList<DesNode*> NodeStoryDesBlock::children() const
{
	return QList<DesNode*>();
}

bool NodeStoryDesBlock::check(QList<QString>& reasons) const
{
	return false;
}

QString NodeStoryDesBlock::toString() const
{
	return text_block;
}


NodeStoryPureTextDesGroupParser::NodeStoryPureTextDesGroupParser(XSyntaxBase * pparser)
	: XSyntaxBase("描述块"), parent_parser(pparser)
{
    set_common_expression("::换行前缀", {Elm("{换行符}"),Elm("{换行符}", true)});
	auto rule = addRule("提取文本", 0, [this, pparser](const QList<LexResult> &seqs, int cnt)->ParseResult {
		auto curr_node = new NodeStoryDesGroup(pparser->currNode());
		refocusNode(curr_node);
		pparser->currNode()->appendChild(curr_node);

		for (auto idx = 0; idx < cnt; ++idx)
			if (seqs[idx].Token != "{换行符}") {
				auto node_blk = new NodeStoryDesBlock(curr_node, seqs[idx].Text);
				curr_node->appendChild(node_blk);
				auto word = new Words(node_blk, docRef(), seqs[idx].Text, seqs[idx].StartRow, seqs[idx].StartCol);
                docRef()->append(word);
			}

		return ParseResult::Completed;
	});
    rule->addExpression("基础提取文本", { Elm("{描述文本}"), Elm("{描述文本}", true) });
    rule->addExpression("拓展提取文本", { Exp("::换行前缀"), Exp("基础提取文本", true) });


	//rule = addRule("完成提取", 1, [this](const QList<LexResult> &seqs, int cnt)->ParseResult {
	//	refocusNode(nullptr);
	//	return ParseResult::Completed;
	//});
 //   rule->addExpression("基础文本提取跳出", { Elm("{换行符}", true) });
}


StoryChainDocumentParser::StoryChainDocumentParser(ProjectCore * pjt)
{
	appendTokensDefine({
			{"{脉络定义}","#脉络"},
			{"{节点定义}", "#节点"},
			{"{描述文本}", "[^#@\\{\\}\\n]+"},
			{"{左界限}","\\{"},
			{"{右界限}","\\}"},
			{"{换行符}","\\n"},
			{"{引用符}", "@"},
		}, "{无法识别}");

	auto chain_parser = new NodeStoryChainParser(pjt);
	appendParser(chain_parser);
}
