#pragma once

#include "markdownblock.hpp"

#include <QList>
#include <QObject>
#include <QTimer>
#include <QString>
#include <QtQml>

namespace ZShell::llm {

class LlmSegment : public QObject {
	Q_OBJECT
	QML_ELEMENT
	QML_UNCREATABLE("Segments are managed by ChatGeneration")

	Q_PROPERTY(Type type READ type CONSTANT)
	Q_PROPERTY(qint64 timestamp READ timestamp CONSTANT)
	Q_PROPERTY(bool running READ running NOTIFY runningChanged)
	Q_PROPERTY(qint64 elapsedMs READ elapsedMs NOTIFY elapsedMsChanged)

	public:
	enum class Type : int { Reasoning = 0, Content, ToolCall };
	Q_ENUM(Type)

	LlmSegment(Type type, qint64 timestamp, QObject* parent = nullptr);
	~LlmSegment() override;

	[[nodiscard]] Type type() const { return m_type; }
	[[nodiscard]] qint64 timestamp() const { return m_timestamp; }
	[[nodiscard]] bool running() const { return m_running; }
	[[nodiscard]] qint64 elapsedMs() const;

	void begin();
	void close();

	void restore(qint64 elapsedMs);

	Q_SIGNALS:
	void runningChanged();
	void elapsedMsChanged();

	protected:
	virtual void closed() {}

	qint64 m_startedAt = 0;
	qint64 m_endedAt = 0;

	private:
	Type m_type;
	qint64 m_timestamp;
	bool m_running = false;
};

class LlmTextSegment : public LlmSegment {
	Q_OBJECT
	QML_ELEMENT
	QML_UNCREATABLE("Text segments are managed by ChatGeneration")

	Q_PROPERTY(QString text READ text NOTIFY textChanged)
	Q_PROPERTY(
		QList<ZShell::llm::MarkdownBlock*> markdown READ markdown NOTIFY
			markdownChanged)

	public:
	LlmTextSegment(Type type, qint64 timestamp, QObject* parent = nullptr);

	[[nodiscard]] QString text() const { return m_text; }
	void setText(const QString& value);
	void appendText(const QString& piece);

	[[nodiscard]] QList<MarkdownBlock*> markdown() const { return m_blocks; }

	Q_SIGNALS:
	void textChanged();
	void markdownChanged();

	private:
	void scheduleMarkdown();
	bool parseMarkdown();
	void closed() override;

	QString m_text;
	QList<MarkdownBlock*> m_blocks;
	QTimer m_markdownTimer;
	bool m_markdownDirty = false;
	bool m_parseInFlight = false;
};

class LlmToolCall : public LlmSegment {
	Q_OBJECT
	QML_ELEMENT
	QML_UNCREATABLE("Tool calls are managed by ChatGeneration")

	Q_PROPERTY(QString name READ name NOTIFY nameChanged)
	Q_PROPERTY(QString toolCallId READ toolCallId NOTIFY toolCallIdChanged)
	Q_PROPERTY(QString arguments READ arguments NOTIFY argumentsChanged)
	Q_PROPERTY(QString result READ result NOTIFY resultChanged)
	Q_PROPERTY(Status status READ status NOTIFY statusChanged)

	public:
	enum class Status : int { None = 0, Running, Success, Error, Pending };
	Q_ENUM(Status)

	LlmToolCall(qint64 timestamp, QObject* parent = nullptr);

	[[nodiscard]] QString name() const { return m_name; }
	[[nodiscard]] QString toolCallId() const { return m_toolCallId; }
	[[nodiscard]] QString arguments() const { return m_arguments; }
	[[nodiscard]] QString result() const { return m_result; }
	[[nodiscard]] Status status() const { return m_status; }

	void setName(const QString& value);
	void setToolCallId(const QString& value);
	void appendArguments(const QString& piece);
	void setResult(const QString& value);
	void setStatus(Status value);

	void finish(const QString& resultText, bool success);

	Q_SIGNALS:
	void nameChanged();
	void toolCallIdChanged();
	void argumentsChanged();
	void resultChanged();
	void statusChanged();

	private:
	QString m_name;
	QString m_toolCallId;
	QString m_arguments;
	QString m_result;
	Status m_status = Status::None;
};

} // namespace ZShell::llm