#pragma once

#include "libtokens.h"
#include "ast_basic.h"

namespace lib_token {

	template<typename ExprT> requires std::derived_from<ExprT, ast_basic::IExprInstance>
	using TokenProc = void(*)(std::shared_ptr<ExprT> expr, std::shared_ptr<const lib_token::IToken> t);


	// 基础token实现 ===================================================
	/**
	 * @brief 词法解析成果
	 */
	class TokenContent : public IToken {
	private:
		int row_n, col_n, doc_offset;
		QString text_n, path_p;
		std::shared_ptr<const ITokenDefine> type_def;

	public:
		/**
		* @brief 词法解析内容
		* @param r 行
		* @param c 列
		* @param pos 位置
		* @param t 内容
		* @param p path
		* @param paramType 类型定义
		*/
		TokenContent(int r, int c, uint64_t pos, const QString& t, const QString& p, std::shared_ptr<const ITokenDefine> paramType);

		// WordBase interface
	public:
		virtual QString file() const override;
		virtual uint64_t position() const override;
		virtual QString content() const override;
		virtual int row() const override;
		virtual int column() const override;

		// Token interface
	public:
		virtual std::shared_ptr<const ITokenDefine> defines() const override;
	};


	/**
	* @brief 动作Token
	*/
	template<typename ExprT, TokenProc<ExprT> p> requires std::derived_from<ExprT, ast_basic::IExprInstance>
	class ActionToken : public IActionToken {
	private:
		std::shared_ptr<const IToken> _bind_content;
		std::shared_ptr<const IActionToken> _bind_previous;

	public:
		ActionToken(std::shared_ptr<const IToken> content, std::shared_ptr<const IActionToken> prev)
			: _bind_content(content), _bind_previous(prev) { }

		virtual std::shared_ptr<ast_basic::IExprInstance> makeSure(std::shared_ptr<ast_basic::IExprInstance> expr) {
			auto expr_inst = std::dynamic_pointer_cast<ExprT>(expr);
			p(expr_inst, shared_from_this());
			return expr;
		}

		// 通过 IActionToken 继承
		virtual Type tokenType() const {
			return Type::TokenBind;
		}
		QString file() const override {
			return _bind_content->file();
		}
		uint64_t position() const override {
			return _bind_content->position();
		}
		QString content() const override {
			return _bind_content->content();
		}
		int row() const override {
			return _bind_content->row();
		}
		int column() const override {
			return _bind_content->column();
		}
		std::shared_ptr<const ITokenDefine> defines() const override {
			return _bind_content->defines();
		}
		std::shared_ptr<const IActionToken> prevToken() const override {
			return this->_bind_previous;
		}
	};

	/**
	* @brief 表达式起始token
	*/
	template<typename NExpr> requires std::derived_from<NExpr, ast_basic::IExprInstance>
	class ExprBeginToken : public IActionToken {
	private:
		std::shared_ptr<const IActionToken> _prev_token = nullptr;
		std::shared_ptr<const lib_syntax::ExprRule> _self_rule = nullptr;

		std::shared_ptr<ast_basic::IExprInstance> _parent_expr = nullptr;
		std::shared_ptr<NExpr> _self_expr = nullptr;

	public:
		ExprBeginToken(std::shared_ptr<const lib_syntax::ExprRule> rule, std::shared_ptr<const IActionToken> prev)
			:_prev_token(prev), _self_rule(rule) { }

		std::shared_ptr<ast_basic::IExprInstance> parentExpr() {
			return this->_parent_expr;
		}

		// 通过 IActionToken 继承
		virtual Type tokenType() const {
			return Type::ElementBegin;
		}
		QString file() const override {
			return this->prevToken()->file();
		}

		uint64_t position() const override {
			if (!this->prevToken())
				return 0;
			return this->prevToken()->position();
		}

		QString content() const override {
			throw new lib_token::TokenException("不应该直接访问ExprBeginToken");
		}

		int row() const override {
			if (!this->prevToken())
				return 0;
			return this->prevToken()->row();
		}

		int column() const override {
			if (!this->prevToken())
				return 0;
			return this->prevToken()->column();
		}

		std::shared_ptr<const ITokenDefine> defines() const override {
			return nullptr;
		}

		std::shared_ptr<const IActionToken> prevToken() const override {
			return _prev_token;
		}

		std::shared_ptr<ast_basic::IExprInstance> makeSure(std::shared_ptr<ast_basic::IExprInstance> expr) override {
			this->_parent_expr = expr;
			this->_self_expr = std::make_shared<NExpr>(_self_rule);
			this->_parent_expr->addChild(this->_self_expr);
			return this->_self_expr;
		}
	};

	/**
	* @brief 表达式终止token
	*/
	template<typename ExprT> requires std::derived_from<ExprT, ast_basic::IExprInstance>
	class ExprEndToken : public IActionToken {
	private:
		std::shared_ptr<const IActionToken> _prev_token = nullptr;
		std::shared_ptr<ExprBeginToken<ExprT>> _self_start = nullptr;

	public:
		ExprEndToken(std::shared_ptr<ExprBeginToken<ExprT>> start, std::shared_ptr<const IActionToken> prev)
			: _prev_token(prev), _self_start(start) { }

		// 通过 IActionToken 继承
		virtual Type tokenType() const {
			return Type::ElementEnd;
		}
		QString file() const override {
			return this->prevToken()->file();
		}
		uint64_t position() const override {
			return this->prevToken()->position();
		}
		QString content() const override {
			throw new lib_token::TokenException("不应该直接访问ExprEndToken");
		}
		int row() const override {
			return this->prevToken()->row();
		}
		int column() const override {
			return this->prevToken()->column();
		}
		std::shared_ptr<const ITokenDefine> defines() const override {
			return nullptr;
		}
		std::shared_ptr<const IActionToken> prevToken() const override {
			return _prev_token;
		}
		std::shared_ptr<ast_basic::IExprInstance> makeSure(std::shared_ptr<ast_basic::IExprInstance> expr) override {
			return this->_self_start->parentExpr();
		}
	};
}